170
184
static plugin::TableFunction* innodb_trx_tool= NULL;
171
185
static plugin::TableFunction* innodb_locks_tool= NULL;
172
186
static plugin::TableFunction* innodb_lock_waits_tool= NULL;
173
static plugin::TableFunction* innodb_sys_tables_tool= NULL;
174
static plugin::TableFunction* innodb_sys_tablestats_tool= NULL;
176
static plugin::TableFunction* innodb_sys_indexes_tool= NULL;
177
static plugin::TableFunction* innodb_sys_columns_tool= NULL;
178
static plugin::TableFunction* innodb_sys_fields_tool= NULL;
179
static plugin::TableFunction* innodb_sys_foreign_tool= NULL;
180
static plugin::TableFunction* innodb_sys_foreign_cols_tool= NULL;
182
static ReplicationLog *replication_logger= NULL;
183
typedef constrained_check<uint32_t, UINT32_MAX, 10> open_files_constraint;
184
static open_files_constraint innobase_open_files;
185
typedef constrained_check<uint32_t, 10, 1> mirrored_log_groups_constraint;
186
static mirrored_log_groups_constraint innobase_mirrored_log_groups;
187
typedef constrained_check<uint32_t, 100, 2> log_files_in_group_constraint;
188
static log_files_in_group_constraint innobase_log_files_in_group;
189
typedef constrained_check<uint32_t, 6, 0> force_recovery_constraint;
190
force_recovery_constraint innobase_force_recovery;
191
typedef constrained_check<size_t, SIZE_MAX, 256*1024, 1024> log_buffer_constraint;
192
static log_buffer_constraint innobase_log_buffer_size;
193
typedef constrained_check<size_t, SIZE_MAX, 512*1024, 1024> additional_mem_pool_constraint;
194
static additional_mem_pool_constraint innobase_additional_mem_pool_size;
195
typedef constrained_check<unsigned int, 1000, 1> autoextend_constraint;
196
static autoextend_constraint innodb_auto_extend_increment;
197
typedef constrained_check<size_t, SIZE_MAX, 5242880, 1048576> buffer_pool_constraint;
198
static buffer_pool_constraint innobase_buffer_pool_size;
199
typedef constrained_check<uint32_t, MAX_BUFFER_POOLS, 1> buffer_pool_instances_constraint;
200
static buffer_pool_instances_constraint innobase_buffer_pool_instances;
201
typedef constrained_check<uint32_t, UINT32_MAX, 100> io_capacity_constraint;
202
static io_capacity_constraint innodb_io_capacity;
203
typedef constrained_check<uint32_t, 5000, 1> purge_batch_constraint;
204
static purge_batch_constraint innodb_purge_batch_size;
205
typedef constrained_check<uint32_t, 1, 0> purge_threads_constraint;
206
static purge_threads_constraint innodb_n_purge_threads;
207
typedef constrained_check<uint16_t, 2, 0> trinary_constraint;
208
static trinary_constraint innodb_flush_log_at_trx_commit;
209
typedef constrained_check<unsigned int, 99, 0> max_dirty_pages_constraint;
210
static max_dirty_pages_constraint innodb_max_dirty_pages_pct;
211
static uint64_constraint innodb_max_purge_lag;
212
static uint64_nonzero_constraint innodb_stats_sample_pages;
213
typedef constrained_check<uint32_t, 64, 1> io_threads_constraint;
214
static io_threads_constraint innobase_read_io_threads;
215
static io_threads_constraint innobase_write_io_threads;
217
typedef constrained_check<uint32_t, 1000, 0> concurrency_constraint;
218
static concurrency_constraint innobase_commit_concurrency;
219
static concurrency_constraint innobase_thread_concurrency;
220
static uint32_nonzero_constraint innodb_concurrency_tickets;
222
typedef constrained_check<int64_t, INT64_MAX, 1024*1024, 1024*1024> log_file_constraint;
223
static log_file_constraint innobase_log_file_size;
225
static uint64_constraint innodb_replication_delay;
227
/** Percentage of the buffer pool to reserve for 'old' blocks.
228
Connected to buf_LRU_old_ratio. */
229
typedef constrained_check<uint32_t, 95, 5> old_blocks_constraint;
230
static old_blocks_constraint innobase_old_blocks_pct;
232
static uint32_constraint innodb_sync_spin_loops;
233
static uint32_constraint innodb_spin_wait_delay;
234
static uint32_constraint innodb_thread_sleep_delay;
236
typedef constrained_check<uint32_t, 64, 0> read_ahead_threshold_constraint;
237
static read_ahead_threshold_constraint innodb_read_ahead_threshold;
188
static long innobase_mirrored_log_groups, innobase_log_files_in_group,
189
innobase_log_buffer_size,
190
innobase_force_recovery, innobase_open_files;
191
static long innobase_additional_mem_pool_size= 8*1024*1024L;
192
static ulong innobase_commit_concurrency = 0;
193
static ulong innobase_read_io_threads;
194
static ulong innobase_write_io_threads;
197
* @TODO: Turn this into size_t as soon as we have a Variable<size_t>
199
static int64_t innobase_buffer_pool_size= 128*1024*1024;
200
static int64_t innobase_log_file_size;
239
202
/* The default values for the following char* start-up parameters
240
203
are determined in innobase_init below: */
242
std::string innobase_data_home_dir;
243
std::string innobase_data_file_path;
244
std::string innobase_log_group_home_dir;
245
static string innobase_file_format_name;
246
static string innobase_change_buffering;
248
/* The highest file format being used in the database. The value can be
249
set by user, however, it will be adjusted to the newer file format if
250
a table of such format is created/opened. */
251
static string innobase_file_format_max;
205
static char* innobase_data_home_dir = NULL;
206
static char* innobase_data_file_path = NULL;
207
static char* innobase_log_group_home_dir = NULL;
208
static char* innobase_file_format_name = NULL;
209
static char* innobase_change_buffering = NULL;
211
/* Note: This variable can be set to on/off and any of the supported
212
file formats in the configuration file, but can only be set to any
213
of the supported file formats during runtime. */
214
static char* innobase_file_format_check = NULL;
216
/* The following has a misleading name: starting from 4.0.5, this also
218
static char* innobase_unix_file_flush_method = NULL;
253
220
/* Below we have boolean-valued start-up parameters, and their default
256
typedef constrained_check<uint16_t, 2, 0> trinary_constraint;
257
static trinary_constraint innobase_fast_shutdown;
259
/* "innobase_file_format_check" decides whether we would continue
260
booting the server if the file format stamped on the system
261
table space exceeds the maximum file format supported
262
by the server. Can be set during server startup at command
263
line or configure file, and a read only variable after
266
/* If a new file format is introduced, the file format
267
name needs to be updated accordingly. Please refer to
268
file_format_name_map[] defined in trx0sys.c for the next
271
static my_bool innobase_file_format_check = TRUE;
223
static ulong innobase_fast_shutdown = 1;
224
#ifdef UNIV_LOG_ARCHIVE
225
static my_bool innobase_log_archive = FALSE;
226
static char* innobase_log_arch_dir = NULL;
227
#endif /* UNIV_LOG_ARCHIVE */
272
228
static my_bool innobase_use_doublewrite = TRUE;
273
229
static my_bool innobase_use_checksums = TRUE;
274
230
static my_bool innobase_rollback_on_timeout = FALSE;
275
231
static my_bool innobase_create_status_file = FALSE;
276
static bool innobase_use_replication_log;
277
static bool support_xa;
278
static bool strict_mode;
279
typedef constrained_check<uint32_t, 1024*1024*1024, 1> lock_wait_constraint;
280
static lock_wait_constraint lock_wait_timeout;
232
static my_bool innobase_stats_on_metadata = TRUE;
282
234
static char* internal_innobase_data_file_path = NULL;
236
static char* innodb_version_str = (char*) INNODB_VERSION_STR;
284
238
/* The following counter is used to convey information to InnoDB
285
239
about server activity: in selects it is not sensible to call
286
240
srv_active_wake_master_thread after each fetch or search, we only do
1839
1799
value= value - (value % align_val);
1842
static void auto_extend_update(Session *, sql_var_t)
1844
srv_auto_extend_increment= innodb_auto_extend_increment.get();
1847
static void io_capacity_update(Session *, sql_var_t)
1849
srv_io_capacity= innodb_io_capacity.get();
1852
static void purge_batch_update(Session *, sql_var_t)
1854
srv_purge_batch_size= innodb_purge_batch_size.get();
1857
static void purge_threads_update(Session *, sql_var_t)
1859
srv_n_purge_threads= innodb_n_purge_threads.get();
1862
static void innodb_adaptive_hash_index_update(Session *, sql_var_t)
1864
if (btr_search_enabled)
1866
btr_search_enable();
1868
btr_search_disable();
1872
static void innodb_old_blocks_pct_update(Session *, sql_var_t)
1874
innobase_old_blocks_pct= buf_LRU_old_ratio_update(innobase_old_blocks_pct.get(), TRUE);
1877
static void innodb_thread_concurrency_update(Session *, sql_var_t)
1879
srv_thread_concurrency= innobase_thread_concurrency.get();
1882
static void innodb_sync_spin_loops_update(Session *, sql_var_t)
1884
srv_n_spin_wait_rounds= innodb_sync_spin_loops.get();
1887
static void innodb_spin_wait_delay_update(Session *, sql_var_t)
1889
srv_spin_wait_delay= innodb_spin_wait_delay.get();
1892
static void innodb_thread_sleep_delay_update(Session *, sql_var_t)
1894
srv_thread_sleep_delay= innodb_thread_sleep_delay.get();
1897
static void innodb_read_ahead_threshold_update(Session *, sql_var_t)
1899
srv_read_ahead_threshold= innodb_read_ahead_threshold.get();
1903
static int innodb_commit_concurrency_validate(Session *session, set_var *var)
1905
uint32_t new_value= var->save_result.uint32_t_value;
1907
if ((innobase_commit_concurrency.get() == 0 && new_value != 0) ||
1908
(innobase_commit_concurrency.get() != 0 && new_value == 0))
1910
push_warning_printf(session,
1911
DRIZZLE_ERROR::WARN_LEVEL_WARN,
1913
_("Once InnoDB is running, innodb_commit_concurrency "
1914
"must not change between zero and nonzero."));
1920
/*************************************************************//**
1921
Check if it is a valid file format. This function is registered as
1922
a callback with MySQL.
1923
@return 0 for valid file format */
1926
innodb_file_format_name_validate(
1927
/*=============================*/
1928
Session* , /*!< in: thread handle */
1931
const char *file_format_input = var->value->str_value.ptr();
1932
if (file_format_input == NULL)
1935
if (file_format_input != NULL) {
1938
format_id = innobase_file_format_name_lookup(
1941
if (format_id <= DICT_TF_FORMAT_MAX) {
1942
innobase_file_format_name =
1943
trx_sys_file_format_id_to_name(format_id);
1952
/*************************************************************//**
1953
Check if it is a valid value of innodb_change_buffering. This function is
1954
registered as a callback with MySQL.
1955
@return 0 for valid innodb_change_buffering */
1958
innodb_change_buffering_validate(
1959
/*=============================*/
1960
Session* , /*!< in: thread handle */
1963
const char *change_buffering_input = var->value->str_value.ptr();
1965
if (change_buffering_input == NULL)
1971
use < UT_ARR_SIZE(innobase_change_buffering_values);
1973
if (!innobase_strcasecmp(change_buffering_input,
1974
innobase_change_buffering_values[use]))
1976
ibuf_use= static_cast<ibuf_use_t>(use);
1985
/*************************************************************//**
1986
Check if valid argument to innodb_file_format_max. This function
1987
is registered as a callback with MySQL.
1988
@return 0 for valid file format */
1991
innodb_file_format_max_validate(
1992
/*==============================*/
1993
Session* session, /*!< in: thread handle */
1996
const char *file_format_input = var->value->str_value.ptr();
1997
if (file_format_input == NULL)
2000
if (file_format_input != NULL) {
2001
int format_id = innobase_file_format_validate_and_set(file_format_input);
2003
if (format_id > DICT_TF_FORMAT_MAX) {
2004
/* DEFAULT is "on", which is invalid at runtime. */
2008
if (format_id >= 0) {
2009
innobase_file_format_max=
2010
trx_sys_file_format_id_to_name((uint)format_id);
2012
/* Update the max format id in the system tablespace. */
2013
char name_buff[100];
2014
strcpy(name_buff, innobase_file_format_max.c_str());
2015
if (trx_sys_file_format_max_set(format_id, (const char **)&name_buff))
2017
errmsg_printf(ERRMSG_LVL_WARN,
2018
" [Info] InnoDB: the file format in the system "
2019
"tablespace is now set to %s.\n", name_buff);
2020
innobase_file_format_max= name_buff;
2025
push_warning_printf(session,
2026
DRIZZLE_ERROR::WARN_LEVEL_WARN,
2028
"InnoDB: invalid innodb_file_format_max "
2029
"value; can be any format up to %s "
2030
"or equivalent id of %d",
2031
trx_sys_file_format_id_to_name(DICT_TF_FORMAT_MAX),
2032
DICT_TF_FORMAT_MAX);
2040
1802
/*********************************************************************//**
2041
1803
Opens an InnoDB database.
2042
1804
@return 0 on success, error code on failure */
2052
1814
InnobaseEngine *actuall_engine_ptr;
2053
1815
const module::option_map &vm= context.getOptions();
2055
srv_auto_extend_increment= innodb_auto_extend_increment.get();
2056
srv_io_capacity= innodb_io_capacity.get();
2057
srv_purge_batch_size= innodb_purge_batch_size.get();
2058
srv_n_purge_threads= innodb_n_purge_threads.get();
2059
srv_flush_log_at_trx_commit= innodb_flush_log_at_trx_commit.get();
2060
srv_max_buf_pool_modified_pct= innodb_max_dirty_pages_pct.get();
2061
srv_max_purge_lag= innodb_max_purge_lag.get();
2062
srv_stats_sample_pages= innodb_stats_sample_pages.get();
2063
srv_n_free_tickets_to_enter= innodb_concurrency_tickets.get();
2064
srv_replication_delay= innodb_replication_delay.get();
2065
srv_thread_concurrency= innobase_thread_concurrency.get();
2066
srv_n_spin_wait_rounds= innodb_sync_spin_loops.get();
2067
srv_spin_wait_delay= innodb_spin_wait_delay.get();
2068
srv_thread_sleep_delay= innodb_thread_sleep_delay.get();
2069
srv_read_ahead_threshold= innodb_read_ahead_threshold.get();
2071
1817
/* Inverted Booleans */
2073
1819
innobase_use_checksums= (vm.count("disable-checksums")) ? false : true;
2074
1820
innobase_use_doublewrite= (vm.count("disable-doublewrite")) ? false : true;
2075
1821
srv_adaptive_flushing= (vm.count("disable-adaptive-flushing")) ? false : true;
1822
innobase_stats_on_metadata= (vm.count("disable-stats-on-metadata")) ? false : true;
2076
1823
srv_use_sys_malloc= (vm.count("use-internal-malloc")) ? false : true;
2077
support_xa= (vm.count("disable-xa")) ? false : true;
2078
btr_search_enabled= (vm.count("disable-adaptive-hash-index")) ? false : true;
2081
/* Hafta do this here because we need to late-bind the default value */
1824
(SessionVAR(NULL,support_xa))= (vm.count("disable-xa")) ? false : true;
1825
(SessionVAR(NULL,table_locks))= (vm.count("disable-table-locks")) ? false : true;
1827
if (vm.count("io-capacity"))
1829
if (srv_io_capacity < 100)
1831
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for io-capacity\n"));
2082
1836
if (vm.count("data-home-dir"))
2084
innobase_data_home_dir= vm["data-home-dir"].as<string>();
2088
innobase_data_home_dir= getDataHome().file_string();
1838
innobase_data_home_dir= strdup(vm["data-home-dir"].as<string>().c_str());
1842
innobase_data_home_dir= strdup(getDataHome().c_str());
1845
if (vm.count("fast-shutdown"))
1847
if (innobase_fast_shutdown > 2)
1849
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for fast-shutdown\n"));
1854
if (vm.count("file-format-check"))
1856
innobase_file_format_check= const_cast<char *>(vm["file-format-check"].as<string>().c_str());
1859
if (vm.count("flush-log-at-trx-commit"))
1861
if (srv_flush_log_at_trx_commit > 2)
1863
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for flush-log-at-trx-commit\n"));
1868
if (vm.count("flush-method"))
1870
innobase_unix_file_flush_method= const_cast<char *>(vm["flush-method"].as<string>().c_str());
1874
innobase_unix_file_flush_method= NULL;
1877
#ifdef UNIV_LOG_ARCHIVE
1878
if (vm.count("log-arch-dir"))
1880
innobase_log_arch_dir= const_cast<char *>(vm["log-arch-dir"].as<string>().c_str());
1885
innobase_log_arch_dir= NULL;
1887
#endif /* UNIV_LOG_ARCHIVE */
1889
if (vm.count("max-dirty-pages-pct"))
1891
if (srv_max_buf_pool_modified_pct > 99)
1893
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for max-dirty-pages-pct\n"));
1898
if (vm.count("stats-sample-pages"))
1900
if (srv_stats_sample_pages < 8)
1902
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for stats-sample-pages\n"));
1907
if (vm.count("additional-mem-pool-size"))
1909
align_value(innobase_additional_mem_pool_size);
1911
if (innobase_additional_mem_pool_size < 512*1024L)
1913
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for additional-mem-pool-size\n"));
1919
if (vm.count("autoextend-increment"))
1921
if (srv_auto_extend_increment < 1 || srv_auto_extend_increment > 1000)
1923
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for autoextend-increment\n"));
1928
if (vm.count("buffer-pool-size"))
1930
align_value(innobase_buffer_pool_size, 1024*1024);
1931
if (innobase_buffer_pool_size < 5*1024*1024)
1933
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for buffer-pool-size\n"));
1939
if (vm.count("commit-concurrency"))
1941
if (srv_replication_delay > 1000)
1943
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for commit-concurrency\n"));
1948
if (vm.count("concurrency-tickets"))
1950
if (srv_n_free_tickets_to_enter < 1)
1952
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for concurrency-tickets\n"));
1957
if (vm.count("read-io-threads"))
1959
if (innobase_read_io_threads < 1 || innobase_read_io_threads > 64)
1961
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for read-io-threads\n"));
1966
if (vm.count("write-io-threads"))
1968
if (innobase_write_io_threads < 1 || innobase_write_io_threads > 64)
1970
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for write-io-threads\n"));
1975
if (vm.count("force-recovery"))
1977
if (innobase_force_recovery > 6)
1979
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for force-recovery\n"));
1984
if (vm.count("log-buffer-size"))
1986
align_value(innobase_log_buffer_size);
1987
if (innobase_log_buffer_size < 256*1024L)
1989
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for log-file-size\n"));
1994
if (vm.count("log-file-size"))
1996
align_value(innobase_log_file_size, 1024*1024);
1997
if (innobase_log_file_size < 1*1024*1024L)
1999
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for log-file-size\n"));
2004
if (vm.count("log-files-in-group"))
2006
if (innobase_log_files_in_group < 2 || innobase_log_files_in_group > 100)
2008
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for log-files-in-group\n"));
2013
if (vm.count("mirrored-log-groups"))
2015
if (innobase_mirrored_log_groups < 1 || innobase_mirrored_log_groups > 10)
2017
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for mirrored-log-groups\n"));
2022
if (vm.count("open-files"))
2024
if (innobase_open_files < 10)
2026
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for open-files\n"));
2031
if (vm.count("thread-concurrency"))
2033
if (srv_thread_concurrency > 1000)
2035
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for thread-concurrency\n"));
2092
2040
if (vm.count("data-file-path"))
2094
innobase_data_file_path= vm["data-file-path"].as<string>();
2042
innobase_data_file_path= const_cast<char *>(vm["data-file-path"].as<string>().c_str());
2046
innobase_data_file_path= NULL;
2049
if (vm.count("version"))
2051
innodb_version_str= const_cast<char *>(vm["version"].as<string>().c_str());
2054
if (vm.count("read-ahead-threshold"))
2056
if (srv_read_ahead_threshold > 64)
2058
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for read-ahead-threshold\n"));
2063
if (vm.count("strict-mode"))
2065
(SessionVAR(NULL,strict_mode))= vm["strict-mode"].as<bool>();
2068
if (vm.count("lock-wait-timeout"))
2070
if (vm["lock-wait-timeout"].as<unsigned long>() < 1 || vm["lock-wait-timeout"].as<unsigned long>() > 1024*1024*1024)
2072
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for lock-wait-timeout\n"));
2076
(SessionVAR(NULL,lock_wait_timeout))= vm["lock-wait-timeout"].as<unsigned long>();
2098
2079
innodb_engine_ptr= actuall_engine_ptr= new InnobaseEngine(innobase_engine_name);
2356
2363
innodb_lock_waits_tool= new(std::nothrow)InnodbTrxTool("INNODB_LOCK_WAITS");
2357
2364
context.add(innodb_lock_waits_tool);
2359
innodb_sys_tables_tool= new(std::nothrow)InnodbSysTablesTool();
2360
context.add(innodb_sys_tables_tool);
2362
innodb_sys_tablestats_tool= new(std::nothrow)InnodbSysTableStatsTool();
2363
context.add(innodb_sys_tablestats_tool);
2365
innodb_sys_indexes_tool= new(std::nothrow)InnodbSysIndexesTool();
2366
context.add(innodb_sys_indexes_tool);
2368
innodb_sys_columns_tool= new(std::nothrow)InnodbSysColumnsTool();
2369
context.add(innodb_sys_columns_tool);
2371
innodb_sys_fields_tool= new(std::nothrow)InnodbSysFieldsTool();
2372
context.add(innodb_sys_fields_tool);
2374
innodb_sys_foreign_tool= new(std::nothrow)InnodbSysForeignTool();
2375
context.add(innodb_sys_foreign_tool);
2377
innodb_sys_foreign_cols_tool= new(std::nothrow)InnodbSysForeignColsTool();
2378
context.add(innodb_sys_foreign_cols_tool);
2380
2366
context.add(new(std::nothrow)InnodbInternalTables());
2381
context.add(new(std::nothrow)InnodbReplicationTable());
2383
if (innobase_use_replication_log)
2385
replication_logger= new(std::nothrow)ReplicationLog();
2386
context.add(replication_logger);
2387
ReplicationLog::setup(replication_logger);
2390
context.registerVariable(new sys_var_const_string_val("data-home-dir", innobase_data_home_dir));
2391
context.registerVariable(new sys_var_const_string_val("flush-method",
2392
vm.count("flush-method") ? vm["flush-method"].as<string>() : ""));
2393
context.registerVariable(new sys_var_const_string_val("log-group-home-dir", innobase_log_group_home_dir));
2394
context.registerVariable(new sys_var_const_string_val("data-file-path", innobase_data_file_path));
2395
context.registerVariable(new sys_var_const_string_val("version", vm["version"].as<string>()));
2398
context.registerVariable(new sys_var_bool_ptr_readonly("replication_log", &innobase_use_replication_log));
2399
context.registerVariable(new sys_var_bool_ptr_readonly("checksums", &innobase_use_checksums));
2400
context.registerVariable(new sys_var_bool_ptr_readonly("doublewrite", &innobase_use_doublewrite));
2401
context.registerVariable(new sys_var_bool_ptr("file-per-table", &srv_file_per_table));
2402
context.registerVariable(new sys_var_bool_ptr_readonly("file-format-check", &innobase_file_format_check));
2403
context.registerVariable(new sys_var_bool_ptr("adaptive-flushing", &srv_adaptive_flushing));
2404
context.registerVariable(new sys_var_bool_ptr("status-file", &innobase_create_status_file));
2405
context.registerVariable(new sys_var_bool_ptr_readonly("use-sys-malloc", &srv_use_sys_malloc));
2406
context.registerVariable(new sys_var_bool_ptr_readonly("use-native-aio", &srv_use_native_aio));
2408
context.registerVariable(new sys_var_bool_ptr("support-xa", &support_xa));
2409
context.registerVariable(new sys_var_bool_ptr("strict_mode", &strict_mode));
2410
context.registerVariable(new sys_var_constrained_value<uint32_t>("lock_wait_timeout", lock_wait_timeout));
2412
context.registerVariable(new sys_var_constrained_value_readonly<size_t>("additional_mem_pool_size",innobase_additional_mem_pool_size));
2413
context.registerVariable(new sys_var_constrained_value<uint32_t>("autoextend_increment",
2414
innodb_auto_extend_increment,
2415
auto_extend_update));
2416
context.registerVariable(new sys_var_constrained_value<uint32_t>("io_capacity",
2418
io_capacity_update));
2419
context.registerVariable(new sys_var_constrained_value<uint32_t>("purge_batch_size",
2420
innodb_purge_batch_size,
2421
purge_batch_update));
2422
context.registerVariable(new sys_var_constrained_value<uint32_t>("purge_threads",
2423
innodb_n_purge_threads,
2424
purge_threads_update));
2425
context.registerVariable(new sys_var_constrained_value<uint16_t>("fast_shutdown", innobase_fast_shutdown));
2426
context.registerVariable(new sys_var_std_string("file_format",
2427
innobase_file_format_name,
2428
innodb_file_format_name_validate));
2429
context.registerVariable(new sys_var_std_string("change_buffering",
2430
innobase_change_buffering,
2431
innodb_change_buffering_validate));
2432
context.registerVariable(new sys_var_std_string("file_format_max",
2433
innobase_file_format_max,
2434
innodb_file_format_max_validate));
2435
context.registerVariable(new sys_var_constrained_value_readonly<size_t>("buffer_pool_size", innobase_buffer_pool_size));
2436
context.registerVariable(new sys_var_constrained_value_readonly<int64_t>("log_file_size", innobase_log_file_size));
2437
context.registerVariable(new sys_var_constrained_value_readonly<uint16_t>("flush_log_at_trx_commit",
2438
innodb_flush_log_at_trx_commit));
2439
context.registerVariable(new sys_var_constrained_value_readonly<unsigned int>("max_dirty_pages_pct",
2440
innodb_max_dirty_pages_pct));
2441
context.registerVariable(new sys_var_constrained_value_readonly<uint64_t>("max_purge_lag", innodb_max_purge_lag));
2442
context.registerVariable(new sys_var_constrained_value_readonly<uint64_t>("stats_sample_pages", innodb_stats_sample_pages));
2443
context.registerVariable(new sys_var_bool_ptr("adaptive_hash_index", &btr_search_enabled, innodb_adaptive_hash_index_update));
2445
context.registerVariable(new sys_var_constrained_value<uint32_t>("commit_concurrency",
2446
innobase_commit_concurrency,
2447
innodb_commit_concurrency_validate));
2448
context.registerVariable(new sys_var_constrained_value<uint32_t>("concurrency_tickets",
2449
innodb_concurrency_tickets));
2450
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("read_io_threads", innobase_read_io_threads));
2451
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("write_io_threads", innobase_write_io_threads));
2452
context.registerVariable(new sys_var_constrained_value_readonly<uint64_t>("replication_delay", innodb_replication_delay));
2453
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("force_recovery", innobase_force_recovery));
2454
context.registerVariable(new sys_var_constrained_value_readonly<size_t>("log_buffer_size", innobase_log_buffer_size));
2455
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("log_files_in_group", innobase_log_files_in_group));
2456
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("mirrored_log_groups", innobase_mirrored_log_groups));
2457
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("open_files", innobase_open_files));
2458
context.registerVariable(new sys_var_constrained_value<uint32_t>("old_blocks_pct",
2459
innobase_old_blocks_pct,
2460
innodb_old_blocks_pct_update));
2461
context.registerVariable(new sys_var_uint32_t_ptr("old_blocks_time", &buf_LRU_old_threshold_ms));
2462
context.registerVariable(new sys_var_constrained_value<uint32_t>("sync_spin_loops", innodb_sync_spin_loops, innodb_sync_spin_loops_update));
2463
context.registerVariable(new sys_var_constrained_value<uint32_t>("spin_wait_delay", innodb_spin_wait_delay, innodb_spin_wait_delay_update));
2464
context.registerVariable(new sys_var_constrained_value<uint32_t>("thread_sleep_delay", innodb_thread_sleep_delay, innodb_thread_sleep_delay_update));
2465
context.registerVariable(new sys_var_constrained_value<uint32_t>("thread_concurrency",
2466
innobase_thread_concurrency,
2467
innodb_thread_concurrency_update));
2468
context.registerVariable(new sys_var_constrained_value<uint32_t>("read_ahead_threshold",
2469
innodb_read_ahead_threshold,
2470
innodb_read_ahead_threshold_update));
2471
2368
/* Get the current high water mark format. */
2472
innobase_file_format_max = trx_sys_file_format_max_get();
2473
btr_search_fully_disabled = (!btr_search_enabled);
2369
innobase_file_format_check = (char*) trx_sys_file_format_max_get();
2987
2857
/********************************************************************//**
2988
Get the upper limit of the MySQL integral and floating-point type.
2989
@return maximum allowed value for the field */
2992
innobase_get_int_col_max_value(
2993
/*===========================*/
2994
const Field* field) /*!< in: MySQL field */
2996
uint64_t max_value = 0;
2998
switch(field->key_type()) {
3000
case HA_KEYTYPE_BINARY:
3001
max_value = 0xFFULL;
3004
case HA_KEYTYPE_ULONG_INT:
3005
max_value = 0xFFFFFFFFULL;
3007
case HA_KEYTYPE_LONG_INT:
3008
max_value = 0x7FFFFFFFULL;
3011
case HA_KEYTYPE_ULONGLONG:
3012
max_value = 0xFFFFFFFFFFFFFFFFULL;
3014
case HA_KEYTYPE_LONGLONG:
3015
max_value = 0x7FFFFFFFFFFFFFFFULL;
3017
case HA_KEYTYPE_DOUBLE:
3018
/* We use the maximum as per IEEE754-2008 standard, 2^53 */
3019
max_value = 0x20000000000000ULL;
3028
/*******************************************************************//**
3029
This function checks whether the index column information
3030
is consistent between KEY info from mysql and that from innodb index.
3031
@return TRUE if all column types match. */
3034
innobase_match_index_columns(
3035
/*=========================*/
3036
const KeyInfo* key_info, /*!< in: Index info
3038
const dict_index_t* index_info) /*!< in: Index info
3041
const KeyPartInfo* key_part;
3042
const KeyPartInfo* key_end;
3043
const dict_field_t* innodb_idx_fld;
3044
const dict_field_t* innodb_idx_fld_end;
3046
/* Check whether user defined index column count matches */
3047
if (key_info->key_parts != index_info->n_user_defined_cols) {
3051
key_part = key_info->key_part;
3052
key_end = key_part + key_info->key_parts;
3053
innodb_idx_fld = index_info->fields;
3054
innodb_idx_fld_end = index_info->fields + index_info->n_fields;
3056
/* Check each index column's datatype. We do not check
3057
column name because there exists case that index
3058
column name got modified in mysql but such change does not
3059
propagate to InnoDB.
3060
One hidden assumption here is that the index column sequences
3061
are matched up between those in mysql and Innodb. */
3062
for (; key_part != key_end; ++key_part) {
3065
ulint mtype = innodb_idx_fld->col->mtype;
3067
/* Need to translate to InnoDB column type before
3069
col_type = get_innobase_type_from_mysql_type(&is_unsigned,
3072
/* Ignore Innodb specific system columns. */
3073
while (mtype == DATA_SYS) {
3076
if (innodb_idx_fld >= innodb_idx_fld_end) {
3081
if (col_type != mtype) {
3082
/* Column Type mismatches */
3092
/*******************************************************************//**
3093
This function builds a translation table in INNOBASE_SHARE
3094
structure for fast index location with mysql array number from its
3095
table->key_info structure. This also provides the necessary translation
3096
between the key order in mysql key_info and Innodb ib_table->indexes if
3097
they are not fully matched with each other.
3098
Note we do not have any mutex protecting the translation table
3099
building based on the assumption that there is no concurrent
3100
index creation/drop and DMLs that requires index lookup. All table
3101
handle will be closed before the index creation/drop.
3102
@return TRUE if index translation table built successfully */
3105
innobase_build_index_translation(
3106
/*=============================*/
3107
const Table* table, /*!< in: table in MySQL data
3109
dict_table_t* ib_table, /*!< in: table in Innodb data
3111
INNOBASE_SHARE* share) /*!< in/out: share structure
3112
where index translation table
3113
will be constructed in. */
3115
ulint mysql_num_index;
3117
dict_index_t** index_mapping;
3120
mutex_enter(&dict_sys->mutex);
3122
mysql_num_index = table->getShare()->keys;
3123
ib_num_index = UT_LIST_GET_LEN(ib_table->indexes);
3125
index_mapping = share->idx_trans_tbl.index_mapping;
3127
/* If there exists inconsistency between MySQL and InnoDB dictionary
3128
(metadata) information, the number of index defined in MySQL
3129
could exceed that in InnoDB, do not build index translation
3130
table in such case */
3131
if (UNIV_UNLIKELY(ib_num_index < mysql_num_index)) {
3136
/* If index entry count is non-zero, nothing has
3137
changed since last update, directly return TRUE */
3138
if (share->idx_trans_tbl.index_count) {
3139
/* Index entry count should still match mysql_num_index */
3140
ut_a(share->idx_trans_tbl.index_count == mysql_num_index);
3144
/* The number of index increased, rebuild the mapping table */
3145
if (mysql_num_index > share->idx_trans_tbl.array_size) {
3146
index_mapping = (dict_index_t**) realloc(index_mapping,
3148
sizeof(*index_mapping));
3150
if (!index_mapping) {
3151
/* Report an error if index_mapping continues to be
3152
NULL and mysql_num_index is a non-zero value */
3153
errmsg_printf(ERRMSG_LVL_ERROR,
3154
"InnoDB: fail to allocate memory for "
3155
"index translation table. Number of "
3156
"Index:%lu, array size:%lu",
3158
share->idx_trans_tbl.array_size);
3163
share->idx_trans_tbl.array_size = mysql_num_index;
3166
/* For each index in the mysql key_info array, fetch its
3167
corresponding InnoDB index pointer into index_mapping
3169
for (ulint count = 0; count < mysql_num_index; count++) {
3171
/* Fetch index pointers into index_mapping according to mysql
3173
index_mapping[count] = dict_table_get_index_on_name(
3174
ib_table, table->key_info[count].name);
3176
if (!index_mapping[count]) {
3177
errmsg_printf(ERRMSG_LVL_ERROR, "Cannot find index %s in InnoDB "
3178
"index dictionary.",
3179
table->key_info[count].name);
3184
/* Double check fetched index has the same
3185
column info as those in mysql key_info. */
3186
if (!innobase_match_index_columns(&table->key_info[count],
3187
index_mapping[count])) {
3188
errmsg_printf(ERRMSG_LVL_ERROR, "Found index %s whose column info "
3189
"does not match that of MySQL.",
3190
table->key_info[count].name);
3196
/* Successfully built the translation table */
3197
share->idx_trans_tbl.index_count = mysql_num_index;
3201
/* Build translation table failed. */
3202
free(index_mapping);
3204
share->idx_trans_tbl.array_size = 0;
3205
share->idx_trans_tbl.index_count = 0;
3206
index_mapping = NULL;
3209
share->idx_trans_tbl.index_mapping = index_mapping;
3211
mutex_exit(&dict_sys->mutex);
3216
/*******************************************************************//**
3217
This function uses index translation table to quickly locate the
3218
requested index structure.
3219
Note we do not have mutex protection for the index translatoin table
3220
access, it is based on the assumption that there is no concurrent
3221
translation table rebuild (fter create/drop index) and DMLs that
3222
require index lookup.
3223
@return dict_index_t structure for requested index. NULL if
3224
fail to locate the index structure. */
3227
innobase_index_lookup(
3228
/*==================*/
3229
INNOBASE_SHARE* share, /*!< in: share structure for index
3230
translation table. */
3231
uint keynr) /*!< in: index number for the requested
3234
if (!share->idx_trans_tbl.index_mapping
3235
|| keynr >= share->idx_trans_tbl.index_count) {
3239
return(share->idx_trans_tbl.index_mapping[keynr]);
3242
/********************************************************************//**
3243
2858
Set the autoinc column max value. This should only be called once from
3244
ha_innobase::open(). Therefore there's no need for a covering lock. */
2859
ha_innobase::open(). Therefore there's no need for a covering lock.
2860
@return DB_SUCCESS or error code */
3247
2863
ha_innobase::innobase_initialize_autoinc()
3248
2864
/*======================================*/
2866
dict_index_t* index;
3250
2867
uint64_t auto_inc;
3251
const Field* field = getTable()->found_next_number_field;
3253
if (field != NULL) {
3254
auto_inc = innobase_get_int_col_max_value(field);
3256
/* We have no idea what's been passed in to us as the
3257
autoinc column. We set it to the 0, effectively disabling
3258
updates to the table. */
2868
const char* col_name;
2871
col_name = table->found_next_number_field->field_name;
2872
index = innobase_get_index(table->getShare()->next_number_index);
2874
/* Execute SELECT MAX(col_name) FROM TABLE; */
2875
error = row_search_max_autoinc(index, col_name, &auto_inc);
2880
/* At the this stage we don't know the increment
2881
or the offset, so use default inrement of 1. */
2885
case DB_RECORD_NOT_FOUND:
3261
2886
ut_print_timestamp(stderr);
3262
fprintf(stderr, " InnoDB: Unable to determine the AUTOINC "
3266
if (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE) {
3267
/* If the recovery level is set so high that writes
3268
are disabled we force the AUTOINC counter to 0
3269
value effectively disabling writes to the table.
3270
Secondly, we avoid reading the table in case the read
3271
results in failure due to a corrupted table/index.
3273
We will not return an error to the client, so that the
3274
tables can be dumped with minimal hassle. If an error
3275
were returned in this case, the first attempt to read
3276
the table would fail and subsequent SELECTs would succeed. */
3278
} else if (field == NULL) {
3279
/* This is a far more serious error, best to avoid
3280
opening the table and return failure. */
3281
my_error(ER_AUTOINC_READ_FAILED, MYF(0));
3283
dict_index_t* index;
3284
const char* col_name;
3285
uint64_t read_auto_inc;
3288
update_session(getTable()->in_use);
3289
col_name = field->field_name;
3291
ut_a(prebuilt->trx == session_to_trx(user_session));
3293
index = innobase_get_index(getTable()->getShare()->next_number_index);
3295
/* Execute SELECT MAX(col_name) FROM TABLE; */
3296
err = row_search_max_autoinc(index, col_name, &read_auto_inc);
3300
uint64_t col_max_value;
3302
col_max_value = innobase_get_int_col_max_value(field);
3304
/* At the this stage we do not know the increment
3305
nor the offset, so use a default increment of 1. */
3307
auto_inc = innobase_next_autoinc(read_auto_inc, 1, 1, col_max_value);
3311
case DB_RECORD_NOT_FOUND:
3312
ut_print_timestamp(stderr);
3313
fprintf(stderr, " InnoDB: MySQL and InnoDB data "
3314
"dictionaries are out of sync.\n"
3315
"InnoDB: Unable to find the AUTOINC column "
3316
"%s in the InnoDB table %s.\n"
3317
"InnoDB: We set the next AUTOINC column "
3319
"InnoDB: in effect disabling the AUTOINC "
3320
"next value generation.\n"
3321
"InnoDB: You can either set the next "
3322
"AUTOINC value explicitly using ALTER TABLE\n"
3323
"InnoDB: or fix the data dictionary by "
3324
"recreating the table.\n",
3325
col_name, index->table->name);
3327
/* This will disable the AUTOINC generation. */
3330
/* We want the open to succeed, so that the user can
3331
take corrective action. ie. reads should succeed but
3332
updates should fail. */
3336
/* row_search_max_autoinc() should only return
3337
one of DB_SUCCESS or DB_RECORD_NOT_FOUND. */
2887
fprintf(stderr, " InnoDB: MySQL and InnoDB data "
2888
"dictionaries are out of sync.\n"
2889
"InnoDB: Unable to find the AUTOINC column %s in the "
2890
"InnoDB table %s.\n"
2891
"InnoDB: We set the next AUTOINC column value to the "
2892
"maximum possible value,\n"
2893
"InnoDB: in effect disabling the AUTOINC next value "
2895
"InnoDB: You can either set the next AUTOINC value "
2896
"explicitly using ALTER TABLE\n"
2897
"InnoDB: or fix the data dictionary by recreating "
2899
col_name, index->table->name);
2901
auto_inc = 0xFFFFFFFFFFFFFFFFULL;
3342
2908
dict_table_autoinc_initialize(prebuilt->table, auto_inc);
3345
2913
/*****************************************************************//**
3468
3031
of length ref_length! */
3470
3033
if (!row_table_got_default_clust_index(ib_table)) {
3034
if (primary_key >= MAX_KEY) {
3035
errmsg_printf(ERRMSG_LVL_ERROR, "Table %s has a primary key in InnoDB data "
3036
"dictionary, but not in MySQL!", identifier.getTableName().c_str());
3472
3039
prebuilt->clust_index_was_generated = FALSE;
3474
if (UNIV_UNLIKELY(primary_key >= MAX_KEY)) {
3475
errmsg_printf(ERRMSG_LVL_ERROR, "Table %s has a primary key in "
3476
"InnoDB data dictionary, but not "
3477
"in MySQL!", identifier.getTableName().c_str());
3479
/* This mismatch could cause further problems
3480
if not attended, bring this to the user's attention
3481
by printing a warning in addition to log a message
3483
push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
3485
"InnoDB: Table %s has a "
3486
"primary key in InnoDB data "
3487
"dictionary, but not in "
3488
"MySQL!", identifier.getTableName().c_str());
3490
/* If primary_key >= MAX_KEY, its (primary_key)
3491
value could be out of bound if continue to index
3492
into key_info[] array. Find InnoDB primary index,
3493
and assign its key_length to ref_length.
3494
In addition, since MySQL indexes are sorted starting
3495
with primary index, unique index etc., initialize
3496
ref_length to the first index key length in
3497
case we fail to find InnoDB cluster index.
3499
Please note, this will not resolve the primary
3500
index mismatch problem, other side effects are
3501
possible if users continue to use the table.
3502
However, we allow this table to be opened so
3503
that user can adopt necessary measures for the
3504
mismatch while still being accessible to the table
3506
ref_length = getTable()->key_info[0].key_length;
3508
/* Find correspoinding cluster index
3509
key length in MySQL's key_info[] array */
3510
for (ulint i = 0; i < getTable()->getShare()->keys; i++) {
3511
dict_index_t* index;
3512
index = innobase_get_index(i);
3513
if (dict_index_is_clust(index)) {
3515
getTable()->key_info[i].key_length;
3519
/* MySQL allocates the buffer for ref.
3520
key_info->key_length includes space for all key
3521
columns + one byte for each column that may be
3522
NULL. ref_length must be as exact as possible to
3523
save space, because all row reference buffers are
3524
allocated based on ref_length. */
3526
ref_length = getTable()->key_info[primary_key].key_length;
3041
/* MySQL allocates the buffer for ref. key_info->key_length
3042
includes space for all key columns + one byte for each column
3043
that may be NULL. ref_length must be as exact as possible to
3044
save space, because all row reference buffers are allocated
3045
based on ref_length. */
3047
ref_length = table->key_info[primary_key].key_length;
3529
3049
if (primary_key != MAX_KEY) {
3530
errmsg_printf(ERRMSG_LVL_ERROR,
3531
"Table %s has no primary key in InnoDB data "
3532
"dictionary, but has one in MySQL! If you "
3533
"created the table with a MySQL version < "
3534
"3.23.54 and did not define a primary key, "
3535
"but defined a unique key with all non-NULL "
3536
"columns, then MySQL internally treats that "
3537
"key as the primary key. You can fix this "
3538
"error by dump + DROP + CREATE + reimport "
3539
"of the table.", identifier.getTableName().c_str());
3541
/* This mismatch could cause further problems
3542
if not attended, bring this to the user attention
3543
by printing a warning in addition to log a message
3545
push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
3547
"InnoDB: Table %s has no "
3548
"primary key in InnoDB data "
3549
"dictionary, but has one in "
3550
"MySQL!", identifier.getTableName().c_str());
3050
errmsg_printf(ERRMSG_LVL_ERROR, "Table %s has no primary key in InnoDB data "
3051
"dictionary, but has one in MySQL! If you "
3052
"created the table with a MySQL version < "
3053
"3.23.54 and did not define a primary key, "
3054
"but defined a unique key with all non-NULL "
3055
"columns, then MySQL internally treats that "
3056
"key as the primary key. You can fix this "
3057
"error by dump + DROP + CREATE + reimport "
3058
"of the table.", identifier.getTableName().c_str());
3553
3061
prebuilt->clust_index_was_generated = TRUE;
7439
6723
/* Build the template; we will use a dummy template
7440
6724
in index scans done in checking */
7442
build_template(prebuilt, NULL, getTable(), ROW_MYSQL_WHOLE_ROW);
7445
if (prebuilt->table->ibd_file_missing) {
7446
errmsg_printf(ERRMSG_LVL_ERROR, "InnoDB: Error:\n"
7447
"InnoDB: MySQL is trying to use a table handle"
7448
" but the .ibd file for\n"
7449
"InnoDB: table %s does not exist.\n"
7450
"InnoDB: Have you deleted the .ibd file"
7451
" from the database directory under\n"
7452
"InnoDB: the MySQL datadir, or have you"
7453
" used DISCARD TABLESPACE?\n"
7454
"InnoDB: Please refer to\n"
7455
"InnoDB: " REFMAN "innodb-troubleshooting.html\n"
7456
"InnoDB: how you can resolve the problem.\n",
7457
prebuilt->table->name);
7458
return(HA_ADMIN_CORRUPT);
7461
prebuilt->trx->op_info = "checking table";
7463
old_isolation_level = prebuilt->trx->isolation_level;
7465
/* We must run the index record counts at an isolation level
7466
>= READ COMMITTED, because a dirty read can see a wrong number
7467
of records in some index; to play safe, we use always
7468
REPEATABLE READ here */
7470
prebuilt->trx->isolation_level = TRX_ISO_REPEATABLE_READ;
7472
/* Enlarge the fatal lock wait timeout during CHECK TABLE. */
7473
mutex_enter(&kernel_mutex);
7474
srv_fatal_semaphore_wait_threshold += 7200; /* 2 hours */
7475
mutex_exit(&kernel_mutex);
7477
for (index = dict_table_get_first_index(prebuilt->table);
7479
index = dict_table_get_next_index(index)) {
7481
fputs("Validating index ", stderr);
7482
ut_print_name(stderr, trx, FALSE, index->name);
7486
if (!btr_validate_index(index, prebuilt->trx)) {
7488
push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
7490
"InnoDB: The B-tree of"
7491
" index '%-.200s' is corrupted.",
7496
/* Instead of invoking change_active_index(), set up
7497
a dummy template for non-locking reads, disabling
7498
access to the clustered index. */
7499
prebuilt->index = index;
7501
prebuilt->index_usable = row_merge_is_index_usable(
7502
prebuilt->trx, prebuilt->index);
7504
if (UNIV_UNLIKELY(!prebuilt->index_usable)) {
7505
push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
7506
HA_ERR_TABLE_DEF_CHANGED,
7507
"InnoDB: Insufficient history for"
7513
prebuilt->sql_stat_start = TRUE;
7514
prebuilt->template_type = ROW_MYSQL_DUMMY_TEMPLATE;
7515
prebuilt->n_template = 0;
7516
prebuilt->need_to_access_clustered = FALSE;
7518
dtuple_set_n_fields(prebuilt->search_tuple, 0);
7520
prebuilt->select_lock_type = LOCK_NONE;
7522
if (!row_check_index_for_mysql(prebuilt, index, &n_rows)) {
7523
push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
7525
"InnoDB: The B-tree of"
7526
" index '%-.200s' is corrupted.",
7531
if (user_session->getKilled()) {
7536
fprintf(stderr, "%lu entries in index %s\n", n_rows,
7540
if (index == dict_table_get_first_index(prebuilt->table)) {
7541
n_rows_in_table = n_rows;
7542
} else if (n_rows != n_rows_in_table) {
7543
push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
7545
"InnoDB: Index '%-.200s'"
7546
" contains %lu entries,"
7550
(ulong) n_rows_in_table);
7555
/* Restore the original isolation level */
7556
prebuilt->trx->isolation_level = old_isolation_level;
7558
/* We validate also the whole adaptive hash index for all tables
7559
at every CHECK TABLE */
7561
if (!btr_search_validate()) {
7562
push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
7564
"InnoDB: The adaptive hash index is corrupted.");
7568
/* Restore the fatal lock wait timeout after CHECK TABLE. */
7569
mutex_enter(&kernel_mutex);
7570
srv_fatal_semaphore_wait_threshold -= 7200; /* 2 hours */
7571
mutex_exit(&kernel_mutex);
7573
prebuilt->trx->op_info = "";
7574
if (user_session->getKilled()) {
7575
my_error(ER_QUERY_INTERRUPTED, MYF(0));
7578
return(is_ok ? HA_ADMIN_OK : HA_ADMIN_CORRUPT);
6726
build_template(prebuilt, NULL, table, ROW_MYSQL_WHOLE_ROW);
6729
ret = row_check_table_for_mysql(prebuilt);
6731
if (ret == DB_SUCCESS) {
6732
return(HA_ADMIN_OK);
6735
return(HA_ADMIN_CORRUPT);
7581
6738
/*************************************************************//**
8258
7407
#endif /* UNIV_DEBUG */
8262
buf1len = snprintf(buf1, sizeof buf1,
8264
block_mutex->cfile_name,
8265
(ulong) block_mutex->cline);
8266
buf2len = snprintf(buf2, sizeof buf2,
8268
(ulong) block_mutex_oswait_count);
8270
if (stat_print(session, innobase_engine_name,
8271
strlen(innobase_engine_name), buf1, buf1len,
8273
mutex_exit(&mutex_list_mutex);
7410
mutex = UT_LIST_GET_NEXT(list, mutex);
8278
7413
mutex_exit(&mutex_list_mutex);
8280
7415
mutex_enter(&rw_lock_list_mutex);
8282
for (lock = UT_LIST_GET_FIRST(rw_lock_list); lock != NULL;
8283
lock = UT_LIST_GET_NEXT(list, lock)) {
8284
if (lock->count_os_wait == 0) {
8288
if (buf_pool_is_block_lock(lock)) {
8290
block_lock_oswait_count += lock->count_os_wait;
8294
buf1len = snprintf(buf1, sizeof buf1, "%s:%lu",
8295
lock->cfile_name, (ulong) lock->cline);
8296
buf2len = snprintf(buf2, sizeof buf2, "os_waits=%lu",
8297
(ulong) lock->count_os_wait);
8299
if (stat_print(session, innobase_engine_name,
8300
strlen(innobase_engine_name), buf1, buf1len,
8302
mutex_exit(&rw_lock_list_mutex);
8308
buf1len = snprintf(buf1, sizeof buf1,
8310
block_lock->cfile_name,
8311
(ulong) block_lock->cline);
8312
buf2len = snprintf(buf2, sizeof buf2,
8314
(ulong) block_lock_oswait_count);
8316
if (stat_print(session, innobase_engine_name,
8317
strlen(innobase_engine_name), buf1, buf1len,
8319
mutex_exit(&rw_lock_list_mutex);
7417
lock = UT_LIST_GET_FIRST(rw_lock_list);
7419
while (lock != NULL) {
7420
if (lock->count_os_wait
7421
&& !buf_pool_is_block_lock(lock)) {
7422
buf1len= snprintf(buf1, sizeof(buf1), "%s:%lu",
7423
lock->cfile_name, (unsigned long) lock->cline);
7424
buf2len= snprintf(buf2, sizeof(buf2),
7425
"os_waits=%lu", lock->count_os_wait);
7427
if (stat_print(session, innobase_engine_name,
7428
engine_name_len, buf1, buf1len,
7430
mutex_exit(&rw_lock_list_mutex);
7434
lock = UT_LIST_GET_NEXT(list, lock);
8324
7437
mutex_exit(&rw_lock_list_mutex);
8326
7439
#ifdef UNIV_DEBUG
8327
buf2len = snprintf(buf2, sizeof buf2,
8328
"count=%lu, spin_waits=%lu, spin_rounds=%lu, "
8329
"os_waits=%lu, os_yields=%lu, os_wait_times=%lu",
8330
(ulong) rw_lock_count,
8331
(ulong) rw_lock_count_spin_loop,
8332
(ulong) rw_lock_count_spin_rounds,
8333
(ulong) rw_lock_count_os_wait,
8334
(ulong) rw_lock_count_os_yield,
8335
(ulong) (rw_lock_wait_time / 1000));
7440
buf2len= my_snprintf(buf2, sizeof(buf2),
7441
"count=%lu, spin_waits=%lu, spin_rounds=%lu, "
7442
"os_waits=%lu, os_yields=%lu, os_wait_times=%lu",
7443
rw_lock_count, rw_lock_count_spin_loop,
7444
rw_lock_count_spin_rounds,
7445
rw_lock_count_os_wait, rw_lock_count_os_yield,
7446
(ulong) (rw_lock_wait_time/1000));
8337
7448
if (stat_print(session, innobase_engine_name, engine_name_len,
8338
7449
STRING_WITH_LEN("rw_lock_mutexes"), buf2, buf2len)) {
9185
8264
/************************************************************//**
8265
Validate the file format check value, is it one of "on" or "off",
8266
as a side effect it sets the srv_check_file_format_at_startup variable.
8267
@return true if config value one of "on" or "off" */
8270
innobase_file_format_check_on_off(
8271
/*==============================*/
8272
const char* format_check) /*!< in: parameter value */
8276
if (!innobase_strcasecmp(format_check, "off")) {
8278
/* Set the value to disable checking. */
8279
srv_check_file_format_at_startup = DICT_TF_FORMAT_MAX + 1;
8281
} else if (!innobase_strcasecmp(format_check, "on")) {
8283
/* Set the value to the lowest supported format. */
8284
srv_check_file_format_at_startup = DICT_TF_FORMAT_51;
8292
/************************************************************//**
9186
8293
Validate the file format check config parameters, as a side effect it
9187
sets the srv_max_file_format_at_startup variable.
9188
@return the format_id if valid config value, otherwise, return -1 */
8294
sets the srv_check_file_format_at_startup variable.
8295
@return true if valid config value */
9191
innobase_file_format_validate_and_set(
8298
innobase_file_format_check_validate(
9192
8299
/*================================*/
9193
const char* format_max) /*!< in: parameter value */
8300
const char* format_check) /*!< in: parameter value */
9195
8302
uint format_id;
9197
format_id = innobase_file_format_name_lookup(format_max);
8305
format_id = innobase_file_format_name_lookup(format_check);
9199
8307
if (format_id < DICT_TF_FORMAT_MAX + 1) {
9200
srv_max_file_format_at_startup = format_id;
9201
return((int) format_id);
8308
srv_check_file_format_at_startup = format_id;
8316
/*************************************************************//**
8317
Check if it is a valid file format. This function is registered as
8318
a callback with MySQL.
8319
@return 0 for valid file format */
8322
innodb_file_format_name_validate(
8323
/*=============================*/
8324
Session* , /*!< in: thread handle */
8325
drizzle_sys_var* , /*!< in: pointer to system
8327
void* save, /*!< out: immediate result
8328
for update function */
8329
drizzle_value* value) /*!< in: incoming string */
8331
const char* file_format_input;
8332
char buff[STRING_BUFFER_USUAL_SIZE];
8333
int len = sizeof(buff);
8336
ut_a(value != NULL);
8338
file_format_input = value->val_str(value, buff, &len);
8340
if (file_format_input != NULL) {
8343
format_id = innobase_file_format_name_lookup(
8346
if (format_id <= DICT_TF_FORMAT_MAX) {
8348
*static_cast<const char**>(save) = file_format_input;
8353
*static_cast<const char**>(save) = NULL;
8357
/****************************************************************//**
8358
Update the system variable innodb_file_format using the "saved"
8359
value. This function is registered as a callback with MySQL. */
8362
innodb_file_format_name_update(
8363
/*===========================*/
8364
Session* , /*!< in: thread handle */
8365
drizzle_sys_var* , /*!< in: pointer to
8367
void* var_ptr, /*!< out: where the
8368
formal string goes */
8369
const void* save) /*!< in: immediate result
8370
from check function */
8372
const char* format_name;
8374
ut_a(var_ptr != NULL);
8377
format_name = *static_cast<const char*const*>(save);
8382
format_id = innobase_file_format_name_lookup(format_name);
8384
if (format_id <= DICT_TF_FORMAT_MAX) {
8385
srv_file_format = format_id;
8389
*static_cast<const char**>(var_ptr)
8390
= trx_sys_file_format_id_to_name(srv_file_format);
8393
/*************************************************************//**
8394
Check if valid argument to innodb_file_format_check. This
8395
function is registered as a callback with MySQL.
8396
@return 0 for valid file format */
8399
innodb_file_format_check_validate(
8400
/*==============================*/
8401
Session* , /*!< in: thread handle */
8402
drizzle_sys_var* , /*!< in: pointer to system
8404
void* save, /*!< out: immediate result
8405
for update function */
8406
drizzle_value* value) /*!< in: incoming string */
8408
const char* file_format_input;
8409
char buff[STRING_BUFFER_USUAL_SIZE];
8410
int len = sizeof(buff);
8413
ut_a(value != NULL);
8415
file_format_input = value->val_str(value, buff, &len);
8417
if (file_format_input != NULL) {
8419
/* Check if user set on/off, we want to print a suitable
8420
message if they did so. */
8422
if (innobase_file_format_check_on_off(file_format_input)) {
8423
errmsg_printf(ERRMSG_LVL_WARN,
8424
"InnoDB: invalid innodb_file_format_check "
8425
"value; on/off can only be set at startup or "
8426
"in the configuration file");
8427
} else if (innobase_file_format_check_validate(
8428
file_format_input)) {
8430
*static_cast<const char**>(save) = file_format_input;
8435
errmsg_printf(ERRMSG_LVL_WARN,
8436
"InnoDB: invalid innodb_file_format_check "
8437
"value; can be any format up to %s "
8438
"or its equivalent numeric id",
8439
trx_sys_file_format_id_to_name(
8440
DICT_TF_FORMAT_MAX));
8444
*static_cast<const char**>(save) = NULL;
8448
/****************************************************************//**
8449
Update the system variable innodb_file_format_check using the "saved"
8450
value. This function is registered as a callback with MySQL. */
8453
innodb_file_format_check_update(
8454
/*============================*/
8455
Session* session, /*!< in: thread handle */
8456
drizzle_sys_var* , /*!< in: pointer to
8458
void* var_ptr, /*!< out: where the
8459
formal string goes */
8460
const void* save) /*!< in: immediate result
8461
from check function */
8463
const char* format_name_in;
8464
const char** format_name_out;
8468
ut_a(var_ptr != NULL);
8470
format_name_in = *static_cast<const char*const*>(save);
8472
if (!format_name_in) {
8477
format_id = innobase_file_format_name_lookup(format_name_in);
8479
if (format_id > DICT_TF_FORMAT_MAX) {
8480
/* DEFAULT is "on", which is invalid at runtime. */
8481
push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
8483
"Ignoring SET innodb_file_format=%s",
8488
format_name_out = static_cast<const char**>(var_ptr);
8490
/* Update the max format id in the system tablespace. */
8491
if (trx_sys_file_format_max_set(format_id, format_name_out)) {
8492
ut_print_timestamp(stderr);
8494
" [Info] InnoDB: the file format in the system "
8495
"tablespace is now set to %s.\n", *format_name_out);
8499
/****************************************************************//**
8500
Update the system variable innodb_adaptive_hash_index using the "saved"
8501
value. This function is registered as a callback with MySQL. */
8504
innodb_adaptive_hash_index_update(
8505
/*==============================*/
8506
Session* , /*!< in: thread handle */
8507
drizzle_sys_var* , /*!< in: pointer to
8509
void* , /*!< out: where the
8510
formal string goes */
8511
const void* save) /*!< in: immediate result
8512
from check function */
8514
if (*(bool*) save) {
8515
btr_search_enable();
8517
btr_search_disable();
8521
/*************************************************************//**
8522
Check if it is a valid value of innodb_change_buffering. This function is
8523
registered as a callback with MySQL.
8524
@return 0 for valid innodb_change_buffering */
8527
innodb_change_buffering_validate(
8528
/*=============================*/
8529
Session* , /*!< in: thread handle */
8530
drizzle_sys_var* , /*!< in: pointer to system
8532
void* save, /*!< out: immediate result
8533
for update function */
8534
drizzle_value* value) /*!< in: incoming string */
8536
const char* change_buffering_input;
8537
char buff[STRING_BUFFER_USUAL_SIZE];
8538
int len = sizeof(buff);
8541
ut_a(value != NULL);
8543
change_buffering_input = value->val_str(value, buff, &len);
8545
if (change_buffering_input != NULL) {
8548
for (use = 0; use < UT_ARR_SIZE(innobase_change_buffering_values);
8550
if (!innobase_strcasecmp(
8551
change_buffering_input,
8552
innobase_change_buffering_values[use])) {
8553
*(ibuf_use_t*) save = (ibuf_use_t) use;
8562
/****************************************************************//**
8563
Update the system variable innodb_change_buffering using the "saved"
8564
value. This function is registered as a callback with MySQL. */
8567
innodb_change_buffering_update(
8568
/*===========================*/
8569
Session* , /*!< in: thread handle */
8570
drizzle_sys_var* , /*!< in: pointer to
8572
void* var_ptr, /*!< out: where the
8573
formal string goes */
8574
const void* save) /*!< in: immediate result
8575
from check function */
8577
ut_a(var_ptr != NULL);
8579
ut_a((*(ibuf_use_t*) save) < IBUF_USE_COUNT);
8581
ibuf_use = *(const ibuf_use_t*) save;
8583
*(const char**) var_ptr = innobase_change_buffering_values[ibuf_use];
8586
/* plugin options */
8587
static DRIZZLE_SYSVAR_BOOL(checksums, innobase_use_checksums,
8588
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8589
"Enable InnoDB checksums validation (enabled by default). ",
8592
static DRIZZLE_SYSVAR_STR(data_home_dir, innobase_data_home_dir,
8593
PLUGIN_VAR_READONLY,
8594
"The common part for InnoDB table spaces.",
8597
static DRIZZLE_SYSVAR_BOOL(doublewrite, innobase_use_doublewrite,
8598
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8599
"Enable InnoDB doublewrite buffer (enabled by default). ",
8602
static DRIZZLE_SYSVAR_ULONG(io_capacity, srv_io_capacity,
8603
PLUGIN_VAR_RQCMDARG,
8604
"Number of IOPs the server can do. Tunes the background IO rate",
8605
NULL, NULL, 200, 100, ~0L, 0);
8607
static DRIZZLE_SYSVAR_ULONG(fast_shutdown, innobase_fast_shutdown,
8608
PLUGIN_VAR_OPCMDARG,
8609
"Speeds up the shutdown process of the InnoDB storage engine. Possible "
8610
"values are 0, 1 (faster)"
8611
" or 2 (fastest - crash-like)"
8613
NULL, NULL, 1, 0, 2, 0);
8615
static DRIZZLE_SYSVAR_BOOL(file_per_table, srv_file_per_table,
8616
PLUGIN_VAR_NOCMDARG,
8617
"Stores each InnoDB table to an .ibd file in the database dir.",
8620
static DRIZZLE_SYSVAR_STR(file_format, innobase_file_format_name,
8621
PLUGIN_VAR_RQCMDARG,
8622
"File format to use for new tables in .ibd files.",
8623
innodb_file_format_name_validate,
8624
innodb_file_format_name_update, "Antelope");
8626
static DRIZZLE_SYSVAR_STR(file_format_check, innobase_file_format_check,
8627
PLUGIN_VAR_OPCMDARG,
8628
"The highest file format in the tablespace.",
8629
innodb_file_format_check_validate,
8630
innodb_file_format_check_update,
8633
static DRIZZLE_SYSVAR_ULONG(flush_log_at_trx_commit, srv_flush_log_at_trx_commit,
8634
PLUGIN_VAR_OPCMDARG,
8635
"Set to 0 (write and flush once per second),"
8636
" 1 (write and flush at each commit)"
8637
" or 2 (write at commit, flush once per second).",
8638
NULL, NULL, 1, 0, 2, 0);
8640
static DRIZZLE_SYSVAR_STR(flush_method, innobase_unix_file_flush_method,
8641
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8642
"With which method to flush data.", NULL, NULL, NULL);
8644
#ifdef UNIV_LOG_ARCHIVE
8645
static DRIZZLE_SYSVAR_STR(log_arch_dir, innobase_log_arch_dir,
8646
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8647
"Where full logs should be archived.", NULL, NULL, NULL);
8649
static DRIZZLE_SYSVAR_BOOL(log_archive, innobase_log_archive,
8650
PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
8651
"Set to 1 if you want to have logs archived.", NULL, NULL, FALSE);
8652
#endif /* UNIV_LOG_ARCHIVE */
8654
static DRIZZLE_SYSVAR_STR(log_group_home_dir, innobase_log_group_home_dir,
8655
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8656
"Path to InnoDB log files.", NULL, NULL, NULL);
8658
static DRIZZLE_SYSVAR_ULONG(max_dirty_pages_pct, srv_max_buf_pool_modified_pct,
8659
PLUGIN_VAR_RQCMDARG,
8660
"Percentage of dirty pages allowed in bufferpool.",
8661
NULL, NULL, 75, 0, 99, 0);
8663
static DRIZZLE_SYSVAR_BOOL(adaptive_flushing, srv_adaptive_flushing,
8664
PLUGIN_VAR_NOCMDARG,
8665
"Attempt flushing dirty pages to avoid IO bursts at checkpoints.",
8668
static DRIZZLE_SYSVAR_ULONG(max_purge_lag, srv_max_purge_lag,
8669
PLUGIN_VAR_RQCMDARG,
8670
"Desired maximum length of the purge queue (0 = no limit)",
8671
NULL, NULL, 0, 0, ~0L, 0);
8673
static DRIZZLE_SYSVAR_BOOL(status_file, innobase_create_status_file,
8674
PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_NOSYSVAR,
8675
"Enable SHOW INNODB STATUS output in the innodb_status.<pid> file",
8678
static DRIZZLE_SYSVAR_BOOL(stats_on_metadata, innobase_stats_on_metadata,
8679
PLUGIN_VAR_OPCMDARG,
8680
"Enable statistics gathering for metadata commands such as SHOW TABLE STATUS (on by default)",
8683
static DRIZZLE_SYSVAR_ULONGLONG(stats_sample_pages, srv_stats_sample_pages,
8684
PLUGIN_VAR_RQCMDARG,
8685
"The number of index pages to sample when calculating statistics (default 8)",
8686
NULL, NULL, 8, 1, ~0ULL, 0);
8688
static DRIZZLE_SYSVAR_BOOL(adaptive_hash_index, btr_search_enabled,
8689
PLUGIN_VAR_OPCMDARG,
8690
"Enable InnoDB adaptive hash index (enabled by default).",
8691
NULL, innodb_adaptive_hash_index_update, TRUE);
8693
static DRIZZLE_SYSVAR_ULONG(replication_delay, srv_replication_delay,
8694
PLUGIN_VAR_RQCMDARG,
8695
"Replication thread delay (ms) on the slave server if "
8696
"innodb_thread_concurrency is reached (0 by default)",
8697
NULL, NULL, 0, 0, ~0UL, 0);
8699
static DRIZZLE_SYSVAR_LONG(additional_mem_pool_size, innobase_additional_mem_pool_size,
8700
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8701
"Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.",
8702
NULL, NULL, 8*1024*1024L, 512*1024L, LONG_MAX, 1024);
8704
static DRIZZLE_SYSVAR_UINT(autoextend_increment, srv_auto_extend_increment,
8705
PLUGIN_VAR_RQCMDARG,
8706
"Data file autoextend increment in megabytes",
8707
NULL, NULL, 8L, 1L, 1000L, 0);
8709
static DRIZZLE_SYSVAR_LONGLONG(buffer_pool_size, innobase_buffer_pool_size,
8710
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8711
"The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",
8712
NULL, NULL, 128*1024*1024L, 5*1024*1024L, INT64_MAX, 1024*1024L);
8714
static DRIZZLE_SYSVAR_ULONG(commit_concurrency, innobase_commit_concurrency,
8715
PLUGIN_VAR_RQCMDARG,
8716
"Helps in performance tuning in heavily concurrent environments.",
8717
innobase_commit_concurrency_validate, NULL, 0, 0, 1000, 0);
8719
static DRIZZLE_SYSVAR_ULONG(concurrency_tickets, srv_n_free_tickets_to_enter,
8720
PLUGIN_VAR_RQCMDARG,
8721
"Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got the ticket",
8722
NULL, NULL, 500L, 1L, ~0L, 0);
8724
static DRIZZLE_SYSVAR_ULONG(read_io_threads, innobase_read_io_threads,
8725
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8726
"Number of background read I/O threads in InnoDB.",
8727
NULL, NULL, 4, 1, 64, 0);
8729
static DRIZZLE_SYSVAR_ULONG(write_io_threads, innobase_write_io_threads,
8730
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8731
"Number of background write I/O threads in InnoDB.",
8732
NULL, NULL, 4, 1, 64, 0);
8734
static DRIZZLE_SYSVAR_LONG(force_recovery, innobase_force_recovery,
8735
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8736
"Helps to save your data in case the disk image of the database becomes corrupt.",
8737
NULL, NULL, 0, 0, 6, 0);
8739
static DRIZZLE_SYSVAR_LONG(log_buffer_size, innobase_log_buffer_size,
8740
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8741
"The size of the buffer which InnoDB uses to write log to the log files on disk.",
8742
NULL, NULL, 8*1024*1024L, 256*1024L, LONG_MAX, 1024);
8744
static DRIZZLE_SYSVAR_LONGLONG(log_file_size, innobase_log_file_size,
8745
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8746
"Size of each log file in a log group.",
8747
NULL, NULL, 20*1024*1024L, 1*1024*1024L, INT64_MAX, 1024*1024L);
8749
static DRIZZLE_SYSVAR_LONG(log_files_in_group, innobase_log_files_in_group,
8750
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8751
"Number of log files in the log group. InnoDB writes to the files in a circular fashion. Value 3 is recommended here.",
8752
NULL, NULL, 2, 2, 100, 0);
8754
static DRIZZLE_SYSVAR_LONG(mirrored_log_groups, innobase_mirrored_log_groups,
8755
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8756
"Number of identical copies of log groups we keep for the database. Currently this should be set to 1.",
8757
NULL, NULL, 1, 1, 10, 0);
8759
static DRIZZLE_SYSVAR_LONG(open_files, innobase_open_files,
8760
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8761
"How many files at the maximum InnoDB keeps open at the same time.",
8762
NULL, NULL, 300L, 10L, LONG_MAX, 0);
8764
static DRIZZLE_SYSVAR_ULONG(sync_spin_loops, srv_n_spin_wait_rounds,
8765
PLUGIN_VAR_RQCMDARG,
8766
"Count of spin-loop rounds in InnoDB mutexes (30 by default)",
8767
NULL, NULL, 30L, 0L, ~0L, 0);
8769
static DRIZZLE_SYSVAR_ULONG(spin_wait_delay, srv_spin_wait_delay,
8770
PLUGIN_VAR_OPCMDARG,
8771
"Maximum delay between polling for a spin lock (6 by default)",
8772
NULL, NULL, 6L, 0L, ~0L, 0);
8774
static DRIZZLE_SYSVAR_ULONG(thread_concurrency, srv_thread_concurrency,
8775
PLUGIN_VAR_RQCMDARG,
8776
"Helps in performance tuning in heavily concurrent environments. Sets the maximum number of threads allowed inside InnoDB. Value 0 will disable the thread throttling.",
8777
NULL, NULL, 0, 0, 1000, 0);
8779
static DRIZZLE_SYSVAR_ULONG(thread_sleep_delay, srv_thread_sleep_delay,
8780
PLUGIN_VAR_RQCMDARG,
8781
"Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0 disable a sleep",
8782
NULL, NULL, 10000L, 0L, ~0L, 0);
8784
static DRIZZLE_SYSVAR_STR(data_file_path, innobase_data_file_path,
8785
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8786
"Path to individual files and their sizes.",
8789
static DRIZZLE_SYSVAR_STR(version, innodb_version_str,
8790
PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_READONLY,
8791
"InnoDB version", NULL, NULL, INNODB_VERSION_STR);
8793
static DRIZZLE_SYSVAR_BOOL(use_sys_malloc, srv_use_sys_malloc,
8794
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8795
"Use OS memory allocator instead of InnoDB's internal memory allocator",
8798
static DRIZZLE_SYSVAR_STR(change_buffering, innobase_change_buffering,
8799
PLUGIN_VAR_RQCMDARG,
8800
"Buffer changes to reduce random access: "
8801
"OFF, ON, inserting, deleting, changing, or purging.",
8802
innodb_change_buffering_validate,
8803
innodb_change_buffering_update, NULL);
8805
static DRIZZLE_SYSVAR_ULONG(read_ahead_threshold, srv_read_ahead_threshold,
8806
PLUGIN_VAR_RQCMDARG,
8807
"Number of pages that must be accessed sequentially for InnoDB to"
8808
"trigger a readahead.",
8809
NULL, NULL, 56, 0, 64, 0);
9209
8811
static void init_options(drizzled::module::option_context &context)
9263
8863
context("disable-stats-on-metadata",
9264
8864
"Disable statistics gathering for metadata commands such as SHOW TABLE STATUS (on by default)");
9265
8865
context("stats-sample-pages",
9266
po::value<uint64_nonzero_constraint>(&innodb_stats_sample_pages)->default_value(8),
8866
po::value<uint64_t>(&srv_stats_sample_pages)->default_value(8),
9267
8867
"The number of index pages to sample when calculating statistics (default 8)");
9268
8868
context("disable-adaptive-hash-index",
9269
8869
"Enable InnoDB adaptive hash index (enabled by default)");
9270
8870
context("replication-delay",
9271
po::value<uint64_constraint>(&innodb_replication_delay)->default_value(0),
8871
po::value<unsigned long>(&srv_replication_delay)->default_value(0),
9272
8872
"Replication thread delay (ms) on the slave server if innodb_thread_concurrency is reached (0 by default)");
9273
8873
context("additional-mem-pool-size",
9274
po::value<additional_mem_pool_constraint>(&innobase_additional_mem_pool_size)->default_value(8*1024*1024L),
8874
po::value<long>(&innobase_additional_mem_pool_size)->default_value(8*1024*1024L),
9275
8875
"Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.");
9276
8876
context("autoextend-increment",
9277
po::value<autoextend_constraint>(&innodb_auto_extend_increment)->default_value(8L),
8877
po::value<uint32_t>(&srv_auto_extend_increment)->default_value(8L),
9278
8878
"Data file autoextend increment in megabytes");
9279
8879
context("buffer-pool-size",
9280
po::value<buffer_pool_constraint>(&innobase_buffer_pool_size)->default_value(128*1024*1024L),
8880
po::value<int64_t>(&innobase_buffer_pool_size)->default_value(128*1024*1024L),
9281
8881
"The size of the memory buffer InnoDB uses to cache data and indexes of its tables.");
9282
context("buffer-pool-instances",
9283
po::value<buffer_pool_instances_constraint>(&innobase_buffer_pool_instances)->default_value(1),
9284
"Number of buffer pool instances, set to higher value on high-end machines to increase scalability");
9286
8882
context("commit-concurrency",
9287
po::value<concurrency_constraint>(&innobase_commit_concurrency)->default_value(0),
8883
po::value<unsigned long>(&innobase_commit_concurrency)->default_value(0),
9288
8884
"Helps in performance tuning in heavily concurrent environments.");
9289
8885
context("concurrency-tickets",
9290
po::value<uint32_nonzero_constraint>(&innodb_concurrency_tickets)->default_value(500L),
8886
po::value<unsigned long>(&srv_n_free_tickets_to_enter)->default_value(500L),
9291
8887
"Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got the ticket");
9292
8888
context("read-io-threads",
9293
po::value<io_threads_constraint>(&innobase_read_io_threads)->default_value(4),
8889
po::value<unsigned long>(&innobase_read_io_threads)->default_value(4),
9294
8890
"Number of background read I/O threads in InnoDB.");
9295
8891
context("write-io-threads",
9296
po::value<io_threads_constraint>(&innobase_write_io_threads)->default_value(4),
8892
po::value<unsigned long>(&innobase_write_io_threads)->default_value(4),
9297
8893
"Number of background write I/O threads in InnoDB.");
9298
8894
context("force-recovery",
9299
po::value<force_recovery_constraint>(&innobase_force_recovery)->default_value(0),
8895
po::value<long>(&innobase_force_recovery)->default_value(0),
9300
8896
"Helps to save your data in case the disk image of the database becomes corrupt.");
9301
8897
context("log-buffer-size",
9302
po::value<log_buffer_constraint>(&innobase_log_buffer_size)->default_value(8*1024*1024L),
8898
po::value<long>(&innobase_log_buffer_size)->default_value(8*1024*1024L),
9303
8899
"The size of the buffer which InnoDB uses to write log to the log files on disk.");
9304
8900
context("log-file-size",
9305
po::value<log_file_constraint>(&innobase_log_file_size)->default_value(20*1024*1024L),
8901
po::value<int64_t>(&innobase_log_file_size)->default_value(20*1024*1024L),
9306
8902
"The size of the buffer which InnoDB uses to write log to the log files on disk.");
9307
8903
context("log-files-in-group",
9308
po::value<log_files_in_group_constraint>(&innobase_log_files_in_group)->default_value(2),
8904
po::value<long>(&innobase_log_files_in_group)->default_value(2),
9309
8905
"Number of log files in the log group. InnoDB writes to the files in a circular fashion.");
9310
8906
context("mirrored-log-groups",
9311
po::value<mirrored_log_groups_constraint>(&innobase_mirrored_log_groups)->default_value(1),
8907
po::value<long>(&innobase_mirrored_log_groups)->default_value(1),
9312
8908
"Number of identical copies of log groups we keep for the database. Currently this should be set to 1.");
9313
8909
context("open-files",
9314
po::value<open_files_constraint>(&innobase_open_files)->default_value(300L),
8910
po::value<long>(&innobase_open_files)->default_value(300L),
9315
8911
"How many files at the maximum InnoDB keeps open at the same time.");
9316
8912
context("sync-spin-loops",
9317
po::value<uint32_constraint>(&innodb_sync_spin_loops)->default_value(30L),
8913
po::value<unsigned long>(&srv_n_spin_wait_rounds)->default_value(30L),
9318
8914
"Count of spin-loop rounds in InnoDB mutexes (30 by default)");
9319
8915
context("spin-wait-delay",
9320
po::value<uint32_constraint>(&innodb_spin_wait_delay)->default_value(6L),
8916
po::value<unsigned long>(&srv_spin_wait_delay)->default_value(6L),
9321
8917
"Maximum delay between polling for a spin lock (6 by default)");
9322
8918
context("thread-concurrency",
9323
po::value<concurrency_constraint>(&innobase_thread_concurrency)->default_value(0),
8919
po::value<unsigned long>(&srv_thread_concurrency)->default_value(0),
9324
8920
"Helps in performance tuning in heavily concurrent environments. Sets the maximum number of threads allowed inside InnoDB. Value 0 will disable the thread throttling.");
9325
8921
context("thread-sleep-delay",
9326
po::value<uint32_constraint>(&innodb_thread_sleep_delay)->default_value(10000L),
8922
po::value<unsigned long>(&srv_thread_sleep_delay)->default_value(10000L),
9327
8923
"Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0 disable a sleep");
9328
8924
context("data-file-path",
9329
8925
po::value<string>(),
9334
8930
context("use-internal-malloc",
9335
8931
"Use InnoDB's internal memory allocator instal of the OS memory allocator.");
9336
8932
context("change-buffering",
9337
po::value<string>(&innobase_change_buffering),
8933
po::value<string>(),
9338
8934
"Buffer changes to reduce random access: OFF, ON, inserting, deleting, changing, or purging.");
9339
8935
context("read-ahead-threshold",
9340
po::value<read_ahead_threshold_constraint>(&innodb_read_ahead_threshold)->default_value(56),
8936
po::value<unsigned long>(&srv_read_ahead_threshold)->default_value(56),
9341
8937
"Number of pages that must be accessed sequentially for InnoDB to trigger a readahead.");
9342
8938
context("disable-xa",
9343
8939
"Disable InnoDB support for the XA two-phase commit");
9344
8940
context("disable-table-locks",
9345
8941
"Disable InnoDB locking in LOCK TABLES");
9346
8942
context("strict-mode",
9347
po::value<bool>(&strict_mode)->default_value(false)->zero_tokens(),
8943
po::value<bool>()->default_value(false)->zero_tokens(),
9348
8944
"Use strict mode when evaluating create options.");
9349
context("replication-log",
9350
po::value<bool>(&innobase_use_replication_log)->default_value(false),
9351
_("Enable internal replication log."));
9352
8945
context("lock-wait-timeout",
9353
po::value<lock_wait_constraint>(&lock_wait_timeout)->default_value(50),
9354
_("Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back. Values above 100000000 disable the timeout."));
9355
context("old-blocks-pct",
9356
po::value<old_blocks_constraint>(&innobase_old_blocks_pct)->default_value(100 * 3 / 8),
9357
_("Percentage of the buffer pool to reserve for 'old' blocks."));
9358
context("old-blocks-time",
9359
po::value<uint32_t>(&buf_LRU_old_threshold_ms)->default_value(0),
9360
_("ove blocks to the 'new' end of the buffer pool if the first access"
9361
" was at least this many milliseconds ago."
9362
" The timeout is disabled if 0 (the default)."));
8946
po::value<unsigned long>()->default_value(50),
8947
"Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back. Values above 100000000 disable the timeout.");
8950
static drizzle_sys_var* innobase_system_variables[]= {
8951
DRIZZLE_SYSVAR(additional_mem_pool_size),
8952
DRIZZLE_SYSVAR(autoextend_increment),
8953
DRIZZLE_SYSVAR(buffer_pool_size),
8954
DRIZZLE_SYSVAR(checksums),
8955
DRIZZLE_SYSVAR(commit_concurrency),
8956
DRIZZLE_SYSVAR(concurrency_tickets),
8957
DRIZZLE_SYSVAR(data_file_path),
8958
DRIZZLE_SYSVAR(data_home_dir),
8959
DRIZZLE_SYSVAR(doublewrite),
8960
DRIZZLE_SYSVAR(fast_shutdown),
8961
DRIZZLE_SYSVAR(read_io_threads),
8962
DRIZZLE_SYSVAR(write_io_threads),
8963
DRIZZLE_SYSVAR(file_per_table),
8964
DRIZZLE_SYSVAR(file_format),
8965
DRIZZLE_SYSVAR(file_format_check),
8966
DRIZZLE_SYSVAR(flush_log_at_trx_commit),
8967
DRIZZLE_SYSVAR(flush_method),
8968
DRIZZLE_SYSVAR(force_recovery),
8969
DRIZZLE_SYSVAR(lock_wait_timeout),
8970
#ifdef UNIV_LOG_ARCHIVE
8971
DRIZZLE_SYSVAR(log_arch_dir),
8972
DRIZZLE_SYSVAR(log_archive),
8973
#endif /* UNIV_LOG_ARCHIVE */
8974
DRIZZLE_SYSVAR(log_buffer_size),
8975
DRIZZLE_SYSVAR(log_file_size),
8976
DRIZZLE_SYSVAR(log_files_in_group),
8977
DRIZZLE_SYSVAR(log_group_home_dir),
8978
DRIZZLE_SYSVAR(max_dirty_pages_pct),
8979
DRIZZLE_SYSVAR(max_purge_lag),
8980
DRIZZLE_SYSVAR(adaptive_flushing),
8981
DRIZZLE_SYSVAR(mirrored_log_groups),
8982
DRIZZLE_SYSVAR(open_files),
8983
DRIZZLE_SYSVAR(stats_on_metadata),
8984
DRIZZLE_SYSVAR(stats_sample_pages),
8985
DRIZZLE_SYSVAR(adaptive_hash_index),
8986
DRIZZLE_SYSVAR(replication_delay),
8987
DRIZZLE_SYSVAR(status_file),
8988
DRIZZLE_SYSVAR(strict_mode),
8989
DRIZZLE_SYSVAR(support_xa),
8990
DRIZZLE_SYSVAR(sync_spin_loops),
8991
DRIZZLE_SYSVAR(spin_wait_delay),
8992
DRIZZLE_SYSVAR(table_locks),
8993
DRIZZLE_SYSVAR(thread_concurrency),
8994
DRIZZLE_SYSVAR(thread_sleep_delay),
8995
DRIZZLE_SYSVAR(version),
8996
DRIZZLE_SYSVAR(use_sys_malloc),
8997
DRIZZLE_SYSVAR(change_buffering),
8998
DRIZZLE_SYSVAR(read_ahead_threshold),
8999
DRIZZLE_SYSVAR(io_capacity),
9367
9003
DRIZZLE_DECLARE_PLUGIN
added
removed
plugin/innobase/handler/ha_innodb.cc
