← 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: 2010-10-26 14:51:47 UTC
  • mfrom: (1879.1.3 build)
  • Revision ID: kalebral@gmail.com-20101026145147-yqop1w9qw7watara
Merge Monty - clean up of set_var and sys_var
Merge Monty - Generate ChangeLog from bzr as part of distcheck. Also, cleaned up AUTHORS file from bzr log parsed by hand.
Merge Shrews - update transaction log documentation

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sys_var.cc
45
45
 
46
46
#include "config.h"
47
47
#include "drizzled/option.h"
48
 
#include <drizzled/error.h>
49
 
#include <drizzled/gettext.h>
50
 
#include <drizzled/tztime.h>
51
 
#include <drizzled/data_home.h>
52
 
#include <drizzled/set_var.h>
53
 
#include <drizzled/session.h>
54
 
#include <drizzled/sql_base.h>
55
 
#include <drizzled/lock.h>
56
 
#include <drizzled/item/uint.h>
57
 
#include <drizzled/item/null.h>
58
 
#include <drizzled/item/float.h>
59
 
#include <drizzled/plugin.h>
 
48
#include "drizzled/error.h"
 
49
#include "drizzled/gettext.h"
 
50
#include "drizzled/tztime.h"
 
51
#include "drizzled/data_home.h"
 
52
#include "drizzled/set_var.h"
 
53
#include "drizzled/session.h"
 
54
#include "drizzled/sql_base.h"
 
55
#include "drizzled/lock.h"
 
56
#include "drizzled/item/uint.h"
 
57
#include "drizzled/item/null.h"
 
58
#include "drizzled/item/float.h"
 
59
#include "drizzled/item/string.h"
 
60
#include "drizzled/plugin.h"
60
61
#include "drizzled/version.h"
61
62
#include "drizzled/strfunc.h"
62
63
#include "drizzled/internal/m_string.h"
129
130
*/
130
131
static sys_var_session_uint64_t
131
132
sys_auto_increment_increment("auto_increment_increment",
132
 
                             &system_variables::auto_increment_increment);
 
133
                             &drizzle_system_variables::auto_increment_increment);
133
134
static sys_var_session_uint64_t
134
135
sys_auto_increment_offset("auto_increment_offset",
135
 
                          &system_variables::auto_increment_offset);
 
136
                          &drizzle_system_variables::auto_increment_offset);
136
137
 
137
138
static sys_var_fs_path sys_basedir("basedir", basedir);
138
139
static sys_var_fs_path sys_pid_file("pid_file", pid_file);
143
144
static sys_var_constrained_value<uint32_t> sys_back_log("back_log", back_log);
144
145
 
145
146
static sys_var_session_uint64_t sys_bulk_insert_buff_size("bulk_insert_buffer_size",
146
 
                                                          &system_variables::bulk_insert_buff_size);
 
147
                                                          &drizzle_system_variables::bulk_insert_buff_size);
147
148
static sys_var_session_uint32_t sys_completion_type("completion_type",
148
 
                                                    &system_variables::completion_type,
 
149
                                                    &drizzle_system_variables::completion_type,
149
150
                                                    check_completion_type,
150
151
                                                    fix_completion_type);
151
152
static sys_var_collation_sv
152
 
sys_collation_server("collation_server", &system_variables::collation_server, &default_charset_info);
 
153
sys_collation_server("collation_server", &drizzle_system_variables::collation_server, &default_charset_info);
153
154
static sys_var_fs_path       sys_datadir("datadir", getDataHome());
154
155
 
155
156
static sys_var_session_uint64_t sys_join_buffer_size("join_buffer_size",
156
 
                                                     &system_variables::join_buff_size);
 
157
                                                     &drizzle_system_variables::join_buff_size);
157
158
static sys_var_session_uint32_t sys_max_allowed_packet("max_allowed_packet",
158
 
                                                       &system_variables::max_allowed_packet);
 
159
                                                       &drizzle_system_variables::max_allowed_packet);
159
160
static sys_var_uint64_t_ptr     sys_max_connect_errors("max_connect_errors",
160
161
                                               &max_connect_errors);
161
162
static sys_var_session_uint64_t sys_max_error_count("max_error_count",
162
 
                                                  &system_variables::max_error_count);
 
163
                                                  &drizzle_system_variables::max_error_count);
163
164
static sys_var_session_uint64_t sys_max_heap_table_size("max_heap_table_size",
164
 
                                                        &system_variables::max_heap_table_size);
 
165
                                                        &drizzle_system_variables::max_heap_table_size);
165
166
static sys_var_session_uint64_t sys_pseudo_thread_id("pseudo_thread_id",
166
 
                                              &system_variables::pseudo_thread_id,
 
167
                                              &drizzle_system_variables::pseudo_thread_id,
167
168
                                              0, check_pseudo_thread_id);
168
169
static sys_var_session_ha_rows  sys_max_join_size("max_join_size",
169
 
                                                  &system_variables::max_join_size,
 
170
                                                  &drizzle_system_variables::max_join_size,
170
171
                                                  fix_max_join_size);
171
172
static sys_var_session_uint64_t sys_max_seeks_for_key("max_seeks_for_key",
172
 
                                                      &system_variables::max_seeks_for_key);
 
173
                                                      &drizzle_system_variables::max_seeks_for_key);
173
174
static sys_var_session_uint64_t   sys_max_length_for_sort_data("max_length_for_sort_data",
174
 
                                                               &system_variables::max_length_for_sort_data);
 
175
                                                               &drizzle_system_variables::max_length_for_sort_data);
175
176
static sys_var_session_size_t   sys_max_sort_length("max_sort_length",
176
 
                                                    &system_variables::max_sort_length);
 
177
                                                    &drizzle_system_variables::max_sort_length);
177
178
static sys_var_uint64_t_ptr     sys_max_write_lock_count("max_write_lock_count",
178
179
                                                 &max_write_lock_count);
179
180
static sys_var_session_uint64_t sys_min_examined_row_limit("min_examined_row_limit",
180
 
                                                           &system_variables::min_examined_row_limit);
 
181
                                                           &drizzle_system_variables::min_examined_row_limit);
181
182
 
182
183
/* these two cannot be static */
183
184
static sys_var_session_bool sys_optimizer_prune_level("optimizer_prune_level",
184
 
                                                      &system_variables::optimizer_prune_level);
 
185
                                                      &drizzle_system_variables::optimizer_prune_level);
185
186
static sys_var_session_uint32_t sys_optimizer_search_depth("optimizer_search_depth",
186
 
                                                           &system_variables::optimizer_search_depth);
 
187
                                                           &drizzle_system_variables::optimizer_search_depth);
187
188
 
188
189
static sys_var_session_uint64_t sys_preload_buff_size("preload_buffer_size",
189
 
                                                      &system_variables::preload_buff_size);
 
190
                                                      &drizzle_system_variables::preload_buff_size);
190
191
static sys_var_session_uint32_t sys_read_buff_size("read_buffer_size",
191
 
                                                   &system_variables::read_buff_size);
 
192
                                                   &drizzle_system_variables::read_buff_size);
192
193
static sys_var_session_uint32_t sys_read_rnd_buff_size("read_rnd_buffer_size",
193
 
                                                       &system_variables::read_rnd_buff_size);
 
194
                                                       &drizzle_system_variables::read_rnd_buff_size);
194
195
static sys_var_session_uint32_t sys_div_precincrement("div_precision_increment",
195
 
                                                      &system_variables::div_precincrement);
 
196
                                                      &drizzle_system_variables::div_precincrement);
196
197
 
197
198
static sys_var_session_size_t   sys_range_alloc_block_size("range_alloc_block_size",
198
 
                                                           &system_variables::range_alloc_block_size);
 
199
                                                           &drizzle_system_variables::range_alloc_block_size);
199
200
static sys_var_session_uint32_t sys_query_alloc_block_size("query_alloc_block_size",
200
 
                                                           &system_variables::query_alloc_block_size,
 
201
                                                           &drizzle_system_variables::query_alloc_block_size,
201
202
                                                           NULL, fix_session_mem_root);
202
203
static sys_var_session_uint32_t sys_query_prealloc_size("query_prealloc_size",
203
 
                                                        &system_variables::query_prealloc_size,
 
204
                                                        &drizzle_system_variables::query_prealloc_size,
204
205
                                                        NULL, fix_session_mem_root);
205
206
static sys_var_readonly sys_tmpdir("tmpdir", OPT_GLOBAL, SHOW_CHAR, get_tmpdir);
206
207
 
214
215
                                           fix_server_id);
215
216
 
216
217
static sys_var_session_size_t   sys_sort_buffer("sort_buffer_size",
217
 
                                                &system_variables::sortbuff_size);
 
218
                                                &drizzle_system_variables::sortbuff_size);
218
219
 
219
220
static sys_var_session_size_t sys_transaction_message_threshold("transaction_message_threshold",
220
 
                                                                &system_variables::transaction_message_threshold);
 
221
                                                                &drizzle_system_variables::transaction_message_threshold);
221
222
 
222
223
static sys_var_session_storage_engine sys_storage_engine("storage_engine",
223
 
                                       &system_variables::storage_engine);
 
224
                                       &drizzle_system_variables::storage_engine);
224
225
static sys_var_const_str        sys_system_time_zone("system_time_zone",
225
226
                                             system_time_zone);
226
227
static sys_var_size_t_ptr       sys_table_def_size("table_definition_cache",
230
231
static sys_var_uint64_t_ptr     sys_table_lock_wait_timeout("table_lock_wait_timeout",
231
232
                                                    &table_lock_wait_timeout);
232
233
static sys_var_session_enum     sys_tx_isolation("tx_isolation",
233
 
                                             &system_variables::tx_isolation,
 
234
                                             &drizzle_system_variables::tx_isolation,
234
235
                                             &tx_isolation_typelib,
235
236
                                             fix_tx_isolation,
236
237
                                             check_tx_isolation);
237
238
static sys_var_session_uint64_t sys_tmp_table_size("tmp_table_size",
238
 
                                           &system_variables::tmp_table_size);
 
239
                                           &drizzle_system_variables::tmp_table_size);
239
240
static sys_var_bool_ptr  sys_timed_mutexes("timed_mutexes", &internal::timed_mutexes);
240
241
static sys_var_const_str  sys_version("version", version().c_str());
241
242
 
275
276
/* Local state variables */
276
277
 
277
278
static sys_var_session_ha_rows  sys_select_limit("sql_select_limit",
278
 
                                                 &system_variables::select_limit);
 
279
                                                 &drizzle_system_variables::select_limit);
279
280
static sys_var_timestamp sys_timestamp("timestamp");
280
281
static sys_var_last_insert_id
281
282
sys_last_insert_id("last_insert_id");
309
310
                                          get_warning_count);
310
311
 
311
312
sys_var_session_uint64_t sys_group_concat_max_len("group_concat_max_len",
312
 
                                                  &system_variables::group_concat_max_len);
 
313
                                                  &drizzle_system_variables::group_concat_max_len);
313
314
 
314
315
sys_var_session_time_zone sys_time_zone("time_zone");
315
316
 
1548
1549
  Initialize the system variables
1549
1550
 
1550
1551
  SYNOPSIS
1551
 
    set_var_init()
 
1552
    sys_var_init()
1552
1553
 
1553
1554
  RETURN VALUES
1554
1555
    0           SUCCESS
1555
1556
    otherwise   FAILURE
1556
1557
*/
1557
1558
 
1558
 
int set_var_init()
 
1559
int sys_var_init()
1559
1560
{
1560
1561
  try
1561
1562
  {
1686
1687
}
1687
1688
 
1688
1689
 
1689
 
/**
1690
 
  Execute update of all variables.
1691
 
 
1692
 
  First run a check of all variables that all updates will go ok.
1693
 
  If yes, then execute all updates, returning an error if any one failed.
1694
 
 
1695
 
  This should ensure that in all normal cases none all or variables are
1696
 
  updated.
1697
 
 
1698
 
  @param Session                Thread id
1699
 
  @param var_list       List of variables to update
1700
 
 
1701
 
  @retval
1702
 
    0   ok
1703
 
  @retval
1704
 
    1   ERROR, message sent (normally no variables was updated)
1705
 
  @retval
1706
 
    -1  ERROR, message not sent
1707
 
*/
1708
 
 
1709
 
int sql_set_variables(Session *session, List<set_var_base> *var_list)
1710
 
{
1711
 
  int error;
1712
 
  List_iterator_fast<set_var_base> it(*var_list);
1713
 
 
1714
 
  set_var_base *var;
1715
 
  while ((var=it++))
1716
 
  {
1717
 
    if ((error= var->check(session)))
1718
 
      goto err;
1719
 
  }
1720
 
  if (!(error= test(session->is_error())))
1721
 
  {
1722
 
    it.rewind();
1723
 
    while ((var= it++))
1724
 
      error|= var->update(session);         // Returns 0, -1 or 1
1725
 
  }
1726
 
 
1727
 
err:
1728
 
  free_underlaid_joins(session, &session->lex->select_lex);
1729
 
  return(error);
1730
 
}
1731
 
 
1732
 
 
1733
 
/*****************************************************************************
1734
 
  Functions to handle SET mysql_internal_variable=const_expr
1735
 
*****************************************************************************/
1736
 
 
1737
 
int set_var::check(Session *session)
1738
 
{
1739
 
  if (var->is_readonly())
1740
 
  {
1741
 
    my_error(ER_INCORRECT_GLOBAL_LOCAL_VAR, MYF(0), var->getName().c_str(), "read only");
1742
 
    return -1;
1743
 
  }
1744
 
  if (var->check_type(type))
1745
 
  {
1746
 
    int err= type == OPT_GLOBAL ? ER_LOCAL_VARIABLE : ER_GLOBAL_VARIABLE;
1747
 
    my_error(err, MYF(0), var->getName().c_str());
1748
 
    return -1;
1749
 
  }
1750
 
  /* value is a NULL pointer if we are using SET ... = DEFAULT */
1751
 
  if (!value)
1752
 
  {
1753
 
    if (var->check_default(type))
1754
 
    {
1755
 
      my_error(ER_NO_DEFAULT, MYF(0), var->getName().c_str());
1756
 
      return -1;
1757
 
    }
1758
 
    return 0;
1759
 
  }
1760
 
 
1761
 
  if ((!value->fixed &&
1762
 
       value->fix_fields(session, &value)) || value->check_cols(1))
1763
 
    return -1;
1764
 
  if (var->check_update_type(value->result_type()))
1765
 
  {
1766
 
    my_error(ER_WRONG_TYPE_FOR_VAR, MYF(0), var->getName().c_str());
1767
 
    return -1;
1768
 
  }
1769
 
  return var->check(session, this) ? -1 : 0;
1770
 
}
1771
 
 
1772
 
/**
1773
 
  Update variable
1774
 
 
1775
 
  @param   session    thread handler
1776
 
  @returns 0|1    ok or ERROR
1777
 
 
1778
 
  @note ERROR can be only due to abnormal operations involving
1779
 
  the server's execution evironment such as
1780
 
  out of memory, hard disk failure or the computer blows up.
1781
 
  Consider set_var::check() method if there is a need to return
1782
 
  an error due to logics.
1783
 
*/
1784
 
int set_var::update(Session *session)
1785
 
{
1786
 
  if (! value)
1787
 
    var->set_default(session, type);
1788
 
  else if (var->update(session, this))
1789
 
    return -1;                          // should never happen
1790
 
  if (var->getAfterUpdateTrigger())
1791
 
    (*var->getAfterUpdateTrigger())(session, type);
1792
 
  return 0;
1793
 
}
1794
 
 
1795
 
/*****************************************************************************
1796
 
  Functions to handle SET @user_variable=const_expr
1797
 
*****************************************************************************/
1798
 
 
1799
 
int set_var_user::check(Session *session)
1800
 
{
1801
 
  /*
1802
 
    Item_func_set_user_var can't substitute something else on its place =>
1803
 
    0 can be passed as last argument (reference on item)
1804
 
  */
1805
 
  return (user_var_item->fix_fields(session, (Item**) 0) ||
1806
 
          user_var_item->check(0)) ? -1 : 0;
1807
 
}
1808
 
 
1809
 
 
1810
 
int set_var_user::update(Session *)
1811
 
{
1812
 
  if (user_var_item->update())
1813
 
  {
1814
 
    /* Give an error if it's not given already */
1815
 
    my_message(ER_SET_CONSTANTS_ONLY, ER(ER_SET_CONSTANTS_ONLY), MYF(0));
1816
 
    return -1;
1817
 
  }
1818
 
  return 0;
1819
 
}
1820
 
 
1821
1690
/****************************************************************************
1822
1691
 Functions to handle table_type
1823
1692
****************************************************************************/