~drizzle-trunk/drizzle/development

bool throw_bounds_warning(THD *thd, bool fixed, bool unsignd,

                          const char *name, int64_t val);

static KEY_CACHE *create_key_cache(const char *name, uint length);

 

/*

  Variable definition list

static sys_var_const_str_ptr    sys_repl_report_user(&vars, "report_user", &report_user);

static sys_var_const_str_ptr    sys_repl_report_password(&vars, "report_password", &report_password);

 

{

  thd->sys_var_tmp.long_value= report_port;

}

 

static sys_var_readonly    sys_repl_report_port(&vars, "report_port", OPT_GLOBAL, SHOW_INT, slave_get_report_port);

  return 0;

}

 

                              enum_var_type type __attribute__((unused)),

                              LEX_STRING *base __attribute__((unused)))

{

 

  if ((length= tmp.length()))

    length--;

}

 

void sys_var_set_slave_mode::set_default(THD *thd __attribute__((unused)),

}

 

 

                               enum_var_type type __attribute__((unused)),

                               LEX_STRING *base __attribute__((unused)))

{

}

 

 

                                     enum_var_type type __attribute__((unused)),

                                     LEX_STRING *base __attribute__((unused)))

{

}

 

bool sys_var_thd_ulong::check(THD *thd, set_var *var)

 }

 

 

                                    LEX_STRING *base __attribute__((unused)))

{

  if (type == OPT_GLOBAL)

}

 

 

}

 

 

                                      LEX_STRING *base __attribute__((unused)))

{

  if (type == OPT_GLOBAL)

}

 

bool sys_var_thd_uint64_t::check(THD *thd, set_var *var)

}

 

 

                                        LEX_STRING *base __attribute__((unused)))

{

  if (type == OPT_GLOBAL)

}

 

 

}

 

 

                                   LEX_STRING *base __attribute__((unused)))

{

  if (type == OPT_GLOBAL)

}

 

 

}

 

 

                                   LEX_STRING *base __attribute__((unused)))

{

  ulong tmp= ((type == OPT_GLOBAL) ?

              global_system_variables.*offset :

              thd->variables.*offset);

}

 

bool sys_var_thd_bit::check(THD *thd, set_var *var)

}

 

 

                                  enum_var_type type __attribute__((unused)),

                                  LEX_STRING *base __attribute__((unused)))

{

  */

  thd->sys_var_tmp.bool_value= ((thd->options & bit_flag) ?

                                   !reverse : reverse);

}

 

 

}

 

 

                                               LEX_STRING *base __attribute__((unused)))

{

  if (type == OPT_GLOBAL)

    */

    res= thd->strmake((global_system_variables.*offset)->format.str,

                      (global_system_variables.*offset)->format.length);

  }

}

 

 

}

 

 

                                        LEX_STRING *base __attribute__((unused)))

{

  const CHARSET_INFO * const cs= ci_ptr(thd,type)[0];

}

 

 

}

 

 

                                       LEX_STRING *base __attribute__((unused)))

{

  const CHARSET_INFO *cs= ((type == OPT_GLOBAL) ?

                     global_system_variables.*offset : thd->variables.*offset);

}

 

 

}

 

 

                                          enum_var_type type __attribute__((unused)),

                                          LEX_STRING *base __attribute__((unused)))

{

  KEY_CACHE *key_cache= get_key_cache(base);

  if (!key_cache)

    key_cache= &zero_key_cache;

}

 

 

}

 

 

                                     enum_var_type type __attribute__((unused)),

                                     LEX_STRING *base __attribute__((unused)))

{

 

  if ((length= tmp.length()))

    length--;

}

 

 

}

 

 

                                    enum_var_type type __attribute__((unused)),

                                    LEX_STRING *base __attribute__((unused)))

{

  thd->sys_var_tmp.long_value= (long) thd->start_time;

}

 

 

}

 

 

                                         enum_var_type type __attribute__((unused)),

                                         LEX_STRING *base __attribute__((unused)))

{

  */

  thd->sys_var_tmp.uint64_t_value= 

    thd->read_first_successful_insert_id_in_prev_stmt();

}

 

 

}

 

 

                                    enum_var_type type __attribute__((unused)),

                                    LEX_STRING *base __attribute__((unused)))

{

  thd->sys_var_tmp.uint64_t_value=

    thd->auto_inc_intervals_forced.minimum();

}

 

 

}

 

 

                                        LEX_STRING *base __attribute__((unused)))

{

  /* 

    time zone name is guaranteed to be zero ended.

  */

  if (type == OPT_GLOBAL)

  else

  {

    /*

      (binlog code stores session value only).

    */

    thd->time_zone_used= 1;

  }

}

 

}

 

 

                                        LEX_STRING *base __attribute__((unused)))

{

  if (type != OPT_GLOBAL &&

      thd->user_connect && thd->user_connect->user_resources.user_conn)

}

 

 

}

 

 

                                            enum_var_type type,

                                            LEX_STRING *base __attribute__((unused)))

{

  return type == OPT_GLOBAL ?

}

 

 

}

 

 

                                          LEX_STRING *base __attribute__((unused)))

{

  thd->tmp_double_value= (double) ((type == OPT_GLOBAL) ?

                                   global_system_variables.*offset :

                                   thd->variables.*offset) / 1000000.0;

}

 

 

  return 0;

}

 

{

  thd->sys_var_tmp.long_value=

    (thd->warn_count[(uint) DRIZZLE_ERROR::WARN_LEVEL_NOTE] +

     thd->warn_count[(uint) DRIZZLE_ERROR::WARN_LEVEL_ERROR] +

     thd->warn_count[(uint) DRIZZLE_ERROR::WARN_LEVEL_WARN]);

}

 

{

  thd->sys_var_tmp.long_value= 

    thd->warn_count[(uint) DRIZZLE_ERROR::WARN_LEVEL_ERROR];

}

 

 

  @retval

    ptr         pointer to NUL-terminated string

*/

{

  if (opt_mysql_tmpdir)

}

 

/****************************************************************************

  Return variable name and length for hashing of variables.

*/

 

                                 bool first __attribute__((unused)))

{

  *length= var->name_length;

}

 

 

  {

    var->name_length= strlen(var->name);

    /* this fails if there is a conflicting variable name. see HASH_UNIQUE */

      goto error;

    if (long_options)

      var->option_limits= find_option(long_options, var->name);

 

error:

  for (; first != var; first= first->next)

  return 1;

}

 

  /* A write lock should be held on LOCK_system_variables_hash */

   

  for (sys_var *var= first; var; var= var->next)

 

  return result;

}

int mysql_append_static_vars(const SHOW_VAR *show_vars, uint count)

{

  for (; count > 0; count--, show_vars++)

      return 1;

  return 0;

}

    A lock on LOCK_system_variable_hash should be held

  */

  var= (sys_var*) hash_search(&system_variable_hash,

  if (!(var || no_error))

    my_error(ER_UNKNOWN_SYSTEM_VARIABLE, MYF(0), (char*) str);

 

}

 

 

                                             LEX_STRING *base __attribute__((unused)))

{

  handlerton *hton;

  LEX_STRING *engine_name;

  plugin_ref plugin= thd->variables.*offset;

    plugin= my_plugin_lock(thd, &(global_system_variables.*offset));

  hton= plugin_data(plugin, handlerton*);

  engine_name= &hton2plugin[hton->slot]->name;

  if (type == OPT_GLOBAL)

    plugin_unlock(thd, plugin);

  return result;

}

 

 

                                               LEX_STRING *base __attribute__((unused)))

{

  LEX_STRING opts;

  uint64_t val= ((type == OPT_GLOBAL) ? global_system_variables.*offset :

                  thd->variables.*offset);

  (void) symbolic_mode_representation(thd, val, &opts);

}

 

 

  Named list handling

****************************************************************************/

 

                NAMED_LIST **found)

{

  I_List_iterator<NAMED_LIST> it(*list);

 

 

void delete_elements(I_List<NAMED_LIST> *list,

{

  NAMED_LIST *element;

  while ((element= list->get()))

  if ((key_cache= (KEY_CACHE*) my_malloc(sizeof(KEY_CACHE),

                                             MYF(MY_ZEROFILL | MY_WME))))

  {

    {

      free((char*) key_cache);

      key_cache= 0;