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_file_io_threads,
191
innobase_force_recovery, innobase_open_files;
192
static long innobase_additional_mem_pool_size= 8*1024*1024L;
193
static ulong innobase_commit_concurrency = 0;
194
static ulong innobase_read_io_threads;
195
static ulong innobase_write_io_threads;
198
* @TODO: Turn this into size_t as soon as we have a Variable<size_t>
200
static int64_t innobase_buffer_pool_size= 128*1024*1024;
201
static int64_t innobase_log_file_size;
239
203
/* The default values for the following char* start-up parameters
240
204
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;
206
static char* innobase_data_home_dir = NULL;
207
static char* innobase_data_file_path = NULL;
208
static char* innobase_log_group_home_dir = NULL;
209
static char* innobase_file_format_name = NULL;
210
static char* innobase_change_buffering = NULL;
212
/* Note: This variable can be set to on/off and any of the supported
213
file formats in the configuration file, but can only be set to any
214
of the supported file formats during runtime. */
215
static char* innobase_file_format_check = NULL;
217
/* The following has a misleading name: starting from 4.0.5, this also
219
static char* innobase_unix_file_flush_method = NULL;
253
221
/* 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;
224
static ulong innobase_fast_shutdown = 1;
225
#ifdef UNIV_LOG_ARCHIVE
226
static my_bool innobase_log_archive = FALSE;
227
static char* innobase_log_arch_dir = NULL;
228
#endif /* UNIV_LOG_ARCHIVE */
272
229
static my_bool innobase_use_doublewrite = TRUE;
273
230
static my_bool innobase_use_checksums = TRUE;
274
231
static my_bool innobase_rollback_on_timeout = FALSE;
275
232
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;
233
static my_bool innobase_stats_on_metadata = TRUE;
282
235
static char* internal_innobase_data_file_path = NULL;
237
static char* innodb_version_str = (char*) INNODB_VERSION_STR;
284
239
/* The following counter is used to convey information to InnoDB
285
240
about server activity: in selects it is not sensible to call
286
241
srv_active_wake_master_thread after each fetch or search, we only do
2049
1844
module::Context &context) /*!< in: Drizzle Plugin Context */
1846
static char current_dir[3]; /*!< Set if using current lib */
2053
1850
uint format_id;
2054
1851
InnobaseEngine *actuall_engine_ptr;
2055
1852
const module::option_map &vm= context.getOptions();
2057
srv_auto_extend_increment= innodb_auto_extend_increment.get();
2058
srv_io_capacity= innodb_io_capacity.get();
2059
srv_purge_batch_size= innodb_purge_batch_size.get();
2060
srv_n_purge_threads= innodb_n_purge_threads.get();
2061
srv_flush_log_at_trx_commit= innodb_flush_log_at_trx_commit.get();
2062
srv_max_buf_pool_modified_pct= innodb_max_dirty_pages_pct.get();
2063
srv_max_purge_lag= innodb_max_purge_lag.get();
2064
srv_stats_sample_pages= innodb_stats_sample_pages.get();
2065
srv_n_free_tickets_to_enter= innodb_concurrency_tickets.get();
2066
srv_replication_delay= innodb_replication_delay.get();
2067
srv_thread_concurrency= innobase_thread_concurrency.get();
2068
srv_n_spin_wait_rounds= innodb_sync_spin_loops.get();
2069
srv_spin_wait_delay= innodb_spin_wait_delay.get();
2070
srv_thread_sleep_delay= innodb_thread_sleep_delay.get();
2071
srv_read_ahead_threshold= innodb_read_ahead_threshold.get();
2073
/* Inverted Booleans */
2075
innobase_use_checksums= (vm.count("disable-checksums")) ? false : true;
2076
innobase_use_doublewrite= (vm.count("disable-doublewrite")) ? false : true;
2077
srv_adaptive_flushing= (vm.count("disable-adaptive-flushing")) ? false : true;
2078
srv_use_sys_malloc= (vm.count("use-internal-malloc")) ? false : true;
2079
support_xa= (vm.count("disable-xa")) ? false : true;
2080
btr_search_enabled= (vm.count("disable-adaptive-hash-index")) ? false : true;
2083
/* Hafta do this here because we need to late-bind the default value */
1854
if (vm.count("io-capacity"))
1856
if (srv_io_capacity < 100)
1858
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for io-capacity\n"));
2084
1863
if (vm.count("data-home-dir"))
2086
innobase_data_home_dir= vm["data-home-dir"].as<string>();
2090
innobase_data_home_dir= getDataHome().file_string();
1865
innobase_data_home_dir= strdup(vm["data-home-dir"].as<string>().c_str());
1870
innobase_data_home_dir= NULL;
1873
if (vm.count("fast-shutdown"))
1875
if (innobase_fast_shutdown > 2)
1877
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for fast-shutdown\n"));
1882
if (vm.count("file-format-check"))
1884
innobase_file_format_check= const_cast<char *>(vm["file-format-check"].as<string>().c_str());
1887
if (vm.count("flush-log-at-trx-commit"))
1889
if (srv_flush_log_at_trx_commit > 2)
1891
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for flush-log-at-trx-commit\n"));
1896
if (vm.count("flush-method"))
1898
innobase_unix_file_flush_method= const_cast<char *>(vm["flush-method"].as<string>().c_str());
1902
innobase_unix_file_flush_method= NULL;
1905
#ifdef UNIV_LOG_ARCHIVE
1906
if (vm.count("log-arch-dir"))
1908
innobase_log_arch_dir= const_cast<char *>(vm["log-arch-dir"].as<string>().c_str());
1913
innobase_log_arch_dir= NULL;
1915
#endif /* UNIV_LOG_ARCHIVE */
1917
if (vm.count("max-dirty-pages-pct"))
1919
if (srv_max_buf_pool_modified_pct > 99)
1921
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for max-dirty-pages-pct\n"));
1926
if (vm.count("stats-sample-pages"))
1928
if (srv_stats_sample_pages < 8)
1930
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for stats-sample-pages\n"));
1935
if (vm.count("additional-mem-pool-size"))
1937
align_value(innobase_additional_mem_pool_size);
1939
if (innobase_additional_mem_pool_size < 512*1024L)
1941
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for additional-mem-pool-size\n"));
1947
if (vm.count("autoextend-increment"))
1949
if (srv_auto_extend_increment < 1 || srv_auto_extend_increment > 1000)
1951
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for autoextend-increment\n"));
1956
if (vm.count("buffer-pool-size"))
1958
align_value(innobase_buffer_pool_size, 1024*1024);
1959
if (innobase_buffer_pool_size < 5*1024*1024)
1961
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for buffer-pool-size\n"));
1967
if (vm.count("commit-concurrency"))
1969
if (srv_replication_delay > 1000)
1971
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for commit-concurrency\n"));
1976
if (vm.count("concurrency-tickets"))
1978
if (srv_n_free_tickets_to_enter < 1)
1980
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for concurrency-tickets\n"));
1985
if (vm.count("file-io-threads"))
1987
if (innobase_file_io_threads < 4 || innobase_file_io_threads > 64)
1989
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for file-io-threads\n"));
1994
if (vm.count("read-io-threads"))
1996
if (innobase_read_io_threads < 1 || innobase_read_io_threads > 64)
1998
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for read-io-threads\n"));
2003
if (vm.count("write-io-threads"))
2005
if (innobase_write_io_threads < 1 || innobase_write_io_threads > 64)
2007
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for write-io-threads\n"));
2012
if (vm.count("force-recovery"))
2014
if (innobase_force_recovery > 6)
2016
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for force-recovery\n"));
2021
if (vm.count("log-buffer-size"))
2023
align_value(innobase_log_buffer_size);
2024
if (innobase_log_buffer_size < 256*1024L)
2026
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for log-file-size\n"));
2031
if (vm.count("log-file-size"))
2033
align_value(innobase_log_file_size, 1024*1024);
2034
if (innobase_log_file_size < 1*1024*1024L)
2036
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for log-file-size\n"));
2041
if (vm.count("log-files-in-group"))
2043
if (innobase_log_files_in_group < 2 || innobase_log_files_in_group > 100)
2045
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for log-files-in-group\n"));
2050
if (vm.count("mirrored-log-groups"))
2052
if (innobase_mirrored_log_groups < 1 || innobase_mirrored_log_groups > 10)
2054
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for mirrored-log-groups\n"));
2059
if (vm.count("open-files"))
2061
if (innobase_open_files < 10)
2063
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for open-files\n"));
2068
if (vm.count("thread-concurrency"))
2070
if (srv_thread_concurrency > 1000)
2072
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for thread-concurrency\n"));
2094
2077
if (vm.count("data-file-path"))
2096
innobase_data_file_path= vm["data-file-path"].as<string>();
2079
innobase_data_file_path= const_cast<char *>(vm["data-file-path"].as<string>().c_str());
2083
innobase_data_file_path= NULL;
2086
if (vm.count("version"))
2088
innodb_version_str= const_cast<char *>(vm["version"].as<string>().c_str());
2091
if (vm.count("read-ahead-threshold"))
2093
if (srv_read_ahead_threshold > 64)
2095
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for read-ahead-threshold\n"));
2100
if (vm.count("support-xa"))
2102
(SessionVAR(NULL,support_xa))= vm["support-xa"].as<bool>();
2105
if (vm.count("table-locks"))
2107
(SessionVAR(NULL,table_locks))= vm["table-locks"].as<bool>();
2110
if (vm.count("strict-mode"))
2112
(SessionVAR(NULL,strict_mode))= vm["strict-mode"].as<bool>();
2115
if (vm.count("lock-wait-timeout"))
2117
if (vm["lock-wait-timeout"].as<unsigned long>() < 1 || vm["lock-wait-timeout"].as<unsigned long>() > 1024*1024*1024)
2119
errmsg_printf(ERRMSG_LVL_ERROR, _("Invalid value for lock-wait-timeout\n"));
2123
(SessionVAR(NULL,lock_wait_timeout))= vm["lock-wait-timeout"].as<unsigned long>();
2100
2126
innodb_engine_ptr= actuall_engine_ptr= new InnobaseEngine(innobase_engine_name);
2358
2428
innodb_lock_waits_tool= new(std::nothrow)InnodbTrxTool("INNODB_LOCK_WAITS");
2359
2429
context.add(innodb_lock_waits_tool);
2361
innodb_sys_tables_tool= new(std::nothrow)InnodbSysTablesTool();
2362
context.add(innodb_sys_tables_tool);
2364
innodb_sys_tablestats_tool= new(std::nothrow)InnodbSysTableStatsTool();
2365
context.add(innodb_sys_tablestats_tool);
2367
innodb_sys_indexes_tool= new(std::nothrow)InnodbSysIndexesTool();
2368
context.add(innodb_sys_indexes_tool);
2370
innodb_sys_columns_tool= new(std::nothrow)InnodbSysColumnsTool();
2371
context.add(innodb_sys_columns_tool);
2373
innodb_sys_fields_tool= new(std::nothrow)InnodbSysFieldsTool();
2374
context.add(innodb_sys_fields_tool);
2376
innodb_sys_foreign_tool= new(std::nothrow)InnodbSysForeignTool();
2377
context.add(innodb_sys_foreign_tool);
2379
innodb_sys_foreign_cols_tool= new(std::nothrow)InnodbSysForeignColsTool();
2380
context.add(innodb_sys_foreign_cols_tool);
2382
2431
context.add(new(std::nothrow)InnodbInternalTables());
2383
context.add(new(std::nothrow)InnodbReplicationTable());
2385
if (innobase_use_replication_log)
2387
replication_logger= new(std::nothrow)ReplicationLog();
2388
context.add(replication_logger);
2389
ReplicationLog::setup(replication_logger);
2392
context.registerVariable(new sys_var_const_string_val("data-home-dir", innobase_data_home_dir));
2393
context.registerVariable(new sys_var_const_string_val("flush-method",
2394
vm.count("flush-method") ? vm["flush-method"].as<string>() : ""));
2395
context.registerVariable(new sys_var_const_string_val("log-group-home-dir", innobase_log_group_home_dir));
2396
context.registerVariable(new sys_var_const_string_val("data-file-path", innobase_data_file_path));
2397
context.registerVariable(new sys_var_const_string_val("version", vm["version"].as<string>()));
2400
context.registerVariable(new sys_var_bool_ptr_readonly("replication_log", &innobase_use_replication_log));
2401
context.registerVariable(new sys_var_bool_ptr_readonly("checksums", &innobase_use_checksums));
2402
context.registerVariable(new sys_var_bool_ptr_readonly("doublewrite", &innobase_use_doublewrite));
2403
context.registerVariable(new sys_var_bool_ptr("file-per-table", &srv_file_per_table));
2404
context.registerVariable(new sys_var_bool_ptr_readonly("file-format-check", &innobase_file_format_check));
2405
context.registerVariable(new sys_var_bool_ptr("adaptive-flushing", &srv_adaptive_flushing));
2406
context.registerVariable(new sys_var_bool_ptr("status-file", &innobase_create_status_file));
2407
context.registerVariable(new sys_var_bool_ptr_readonly("use-sys-malloc", &srv_use_sys_malloc));
2408
context.registerVariable(new sys_var_bool_ptr_readonly("use-native-aio", &srv_use_native_aio));
2410
context.registerVariable(new sys_var_bool_ptr("support-xa", &support_xa));
2411
context.registerVariable(new sys_var_bool_ptr("strict_mode", &strict_mode));
2412
context.registerVariable(new sys_var_constrained_value<uint32_t>("lock_wait_timeout", lock_wait_timeout));
2414
context.registerVariable(new sys_var_constrained_value_readonly<size_t>("additional_mem_pool_size",innobase_additional_mem_pool_size));
2415
context.registerVariable(new sys_var_constrained_value<uint32_t>("autoextend_increment",
2416
innodb_auto_extend_increment,
2417
auto_extend_update));
2418
context.registerVariable(new sys_var_constrained_value<uint32_t>("io_capacity",
2420
io_capacity_update));
2421
context.registerVariable(new sys_var_constrained_value<uint32_t>("purge_batch_size",
2422
innodb_purge_batch_size,
2423
purge_batch_update));
2424
context.registerVariable(new sys_var_constrained_value<uint32_t>("purge_threads",
2425
innodb_n_purge_threads,
2426
purge_threads_update));
2427
context.registerVariable(new sys_var_constrained_value<uint16_t>("fast_shutdown", innobase_fast_shutdown));
2428
context.registerVariable(new sys_var_std_string("file_format",
2429
innobase_file_format_name,
2430
innodb_file_format_name_validate));
2431
context.registerVariable(new sys_var_std_string("change_buffering",
2432
innobase_change_buffering,
2433
innodb_change_buffering_validate));
2434
context.registerVariable(new sys_var_std_string("file_format_max",
2435
innobase_file_format_max,
2436
innodb_file_format_max_validate));
2437
context.registerVariable(new sys_var_constrained_value_readonly<size_t>("buffer_pool_size", innobase_buffer_pool_size));
2438
context.registerVariable(new sys_var_constrained_value_readonly<int64_t>("log_file_size", innobase_log_file_size));
2439
context.registerVariable(new sys_var_constrained_value_readonly<uint16_t>("flush_log_at_trx_commit",
2440
innodb_flush_log_at_trx_commit));
2441
context.registerVariable(new sys_var_constrained_value_readonly<unsigned int>("max_dirty_pages_pct",
2442
innodb_max_dirty_pages_pct));
2443
context.registerVariable(new sys_var_constrained_value_readonly<uint64_t>("max_purge_lag", innodb_max_purge_lag));
2444
context.registerVariable(new sys_var_constrained_value_readonly<uint64_t>("stats_sample_pages", innodb_stats_sample_pages));
2445
context.registerVariable(new sys_var_bool_ptr("adaptive_hash_index", &btr_search_enabled, innodb_adaptive_hash_index_update));
2447
context.registerVariable(new sys_var_constrained_value<uint32_t>("commit_concurrency",
2448
innobase_commit_concurrency,
2449
innodb_commit_concurrency_validate));
2450
context.registerVariable(new sys_var_constrained_value<uint32_t>("concurrency_tickets",
2451
innodb_concurrency_tickets));
2452
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("read_io_threads", innobase_read_io_threads));
2453
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("write_io_threads", innobase_write_io_threads));
2454
context.registerVariable(new sys_var_constrained_value_readonly<uint64_t>("replication_delay", innodb_replication_delay));
2455
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("force_recovery", innobase_force_recovery));
2456
context.registerVariable(new sys_var_constrained_value_readonly<size_t>("log_buffer_size", innobase_log_buffer_size));
2457
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("log_files_in_group", innobase_log_files_in_group));
2458
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("mirrored_log_groups", innobase_mirrored_log_groups));
2459
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("open_files", innobase_open_files));
2460
context.registerVariable(new sys_var_constrained_value<uint32_t>("old_blocks_pct",
2461
innobase_old_blocks_pct,
2462
innodb_old_blocks_pct_update));
2463
context.registerVariable(new sys_var_uint32_t_ptr("old_blocks_time", &buf_LRU_old_threshold_ms));
2464
context.registerVariable(new sys_var_constrained_value<uint32_t>("sync_spin_loops", innodb_sync_spin_loops, innodb_sync_spin_loops_update));
2465
context.registerVariable(new sys_var_constrained_value<uint32_t>("spin_wait_delay", innodb_spin_wait_delay, innodb_spin_wait_delay_update));
2466
context.registerVariable(new sys_var_constrained_value<uint32_t>("thread_sleep_delay", innodb_thread_sleep_delay, innodb_thread_sleep_delay_update));
2467
context.registerVariable(new sys_var_constrained_value<uint32_t>("thread_concurrency",
2468
innobase_thread_concurrency,
2469
innodb_thread_concurrency_update));
2470
context.registerVariable(new sys_var_constrained_value<uint32_t>("read_ahead_threshold",
2471
innodb_read_ahead_threshold,
2472
innodb_read_ahead_threshold_update));
2473
2433
/* Get the current high water mark format. */
2474
innobase_file_format_max = trx_sys_file_format_max_get();
2475
btr_search_fully_disabled = (!btr_search_enabled);
2434
innobase_file_format_check = (char*) trx_sys_file_format_max_get();
2989
2922
/********************************************************************//**
2990
Get the upper limit of the MySQL integral and floating-point type.
2991
@return maximum allowed value for the field */
2994
innobase_get_int_col_max_value(
2995
/*===========================*/
2996
const Field* field) /*!< in: MySQL field */
2998
uint64_t max_value = 0;
3000
switch(field->key_type()) {
3002
case HA_KEYTYPE_BINARY:
3003
max_value = 0xFFULL;
3006
case HA_KEYTYPE_ULONG_INT:
3007
max_value = 0xFFFFFFFFULL;
3009
case HA_KEYTYPE_LONG_INT:
3010
max_value = 0x7FFFFFFFULL;
3013
case HA_KEYTYPE_ULONGLONG:
3014
max_value = 0xFFFFFFFFFFFFFFFFULL;
3016
case HA_KEYTYPE_LONGLONG:
3017
max_value = 0x7FFFFFFFFFFFFFFFULL;
3019
case HA_KEYTYPE_DOUBLE:
3020
/* We use the maximum as per IEEE754-2008 standard, 2^53 */
3021
max_value = 0x20000000000000ULL;
3030
/*******************************************************************//**
3031
This function checks whether the index column information
3032
is consistent between KEY info from mysql and that from innodb index.
3033
@return TRUE if all column types match. */
3036
innobase_match_index_columns(
3037
/*=========================*/
3038
const KeyInfo* key_info, /*!< in: Index info
3040
const dict_index_t* index_info) /*!< in: Index info
3043
const KeyPartInfo* key_part;
3044
const KeyPartInfo* key_end;
3045
const dict_field_t* innodb_idx_fld;
3046
const dict_field_t* innodb_idx_fld_end;
3048
/* Check whether user defined index column count matches */
3049
if (key_info->key_parts != index_info->n_user_defined_cols) {
3053
key_part = key_info->key_part;
3054
key_end = key_part + key_info->key_parts;
3055
innodb_idx_fld = index_info->fields;
3056
innodb_idx_fld_end = index_info->fields + index_info->n_fields;
3058
/* Check each index column's datatype. We do not check
3059
column name because there exists case that index
3060
column name got modified in mysql but such change does not
3061
propagate to InnoDB.
3062
One hidden assumption here is that the index column sequences
3063
are matched up between those in mysql and Innodb. */
3064
for (; key_part != key_end; ++key_part) {
3067
ulint mtype = innodb_idx_fld->col->mtype;
3069
/* Need to translate to InnoDB column type before
3071
col_type = get_innobase_type_from_mysql_type(&is_unsigned,
3074
/* Ignore Innodb specific system columns. */
3075
while (mtype == DATA_SYS) {
3078
if (innodb_idx_fld >= innodb_idx_fld_end) {
3083
if (col_type != mtype) {
3084
/* Column Type mismatches */
3094
/*******************************************************************//**
3095
This function builds a translation table in INNOBASE_SHARE
3096
structure for fast index location with mysql array number from its
3097
table->key_info structure. This also provides the necessary translation
3098
between the key order in mysql key_info and Innodb ib_table->indexes if
3099
they are not fully matched with each other.
3100
Note we do not have any mutex protecting the translation table
3101
building based on the assumption that there is no concurrent
3102
index creation/drop and DMLs that requires index lookup. All table
3103
handle will be closed before the index creation/drop.
3104
@return TRUE if index translation table built successfully */
3107
innobase_build_index_translation(
3108
/*=============================*/
3109
const Table* table, /*!< in: table in MySQL data
3111
dict_table_t* ib_table, /*!< in: table in Innodb data
3113
INNOBASE_SHARE* share) /*!< in/out: share structure
3114
where index translation table
3115
will be constructed in. */
3117
ulint mysql_num_index;
3119
dict_index_t** index_mapping;
3122
mutex_enter(&dict_sys->mutex);
3124
mysql_num_index = table->getShare()->keys;
3125
ib_num_index = UT_LIST_GET_LEN(ib_table->indexes);
3127
index_mapping = share->idx_trans_tbl.index_mapping;
3129
/* If there exists inconsistency between MySQL and InnoDB dictionary
3130
(metadata) information, the number of index defined in MySQL
3131
could exceed that in InnoDB, do not build index translation
3132
table in such case */
3133
if (UNIV_UNLIKELY(ib_num_index < mysql_num_index)) {
3138
/* If index entry count is non-zero, nothing has
3139
changed since last update, directly return TRUE */
3140
if (share->idx_trans_tbl.index_count) {
3141
/* Index entry count should still match mysql_num_index */
3142
ut_a(share->idx_trans_tbl.index_count == mysql_num_index);
3146
/* The number of index increased, rebuild the mapping table */
3147
if (mysql_num_index > share->idx_trans_tbl.array_size) {
3148
index_mapping = (dict_index_t**) realloc(index_mapping,
3150
sizeof(*index_mapping));
3152
if (!index_mapping) {
3153
/* Report an error if index_mapping continues to be
3154
NULL and mysql_num_index is a non-zero value */
3155
errmsg_printf(ERRMSG_LVL_ERROR,
3156
"InnoDB: fail to allocate memory for "
3157
"index translation table. Number of "
3158
"Index:%lu, array size:%lu",
3160
share->idx_trans_tbl.array_size);
3165
share->idx_trans_tbl.array_size = mysql_num_index;
3168
/* For each index in the mysql key_info array, fetch its
3169
corresponding InnoDB index pointer into index_mapping
3171
for (ulint count = 0; count < mysql_num_index; count++) {
3173
/* Fetch index pointers into index_mapping according to mysql
3175
index_mapping[count] = dict_table_get_index_on_name(
3176
ib_table, table->key_info[count].name);
3178
if (!index_mapping[count]) {
3179
errmsg_printf(ERRMSG_LVL_ERROR, "Cannot find index %s in InnoDB "
3180
"index dictionary.",
3181
table->key_info[count].name);
3186
/* Double check fetched index has the same
3187
column info as those in mysql key_info. */
3188
if (!innobase_match_index_columns(&table->key_info[count],
3189
index_mapping[count])) {
3190
errmsg_printf(ERRMSG_LVL_ERROR, "Found index %s whose column info "
3191
"does not match that of MySQL.",
3192
table->key_info[count].name);
3198
/* Successfully built the translation table */
3199
share->idx_trans_tbl.index_count = mysql_num_index;
3203
/* Build translation table failed. */
3204
free(index_mapping);
3206
share->idx_trans_tbl.array_size = 0;
3207
share->idx_trans_tbl.index_count = 0;
3208
index_mapping = NULL;
3211
share->idx_trans_tbl.index_mapping = index_mapping;
3213
mutex_exit(&dict_sys->mutex);
3218
/*******************************************************************//**
3219
This function uses index translation table to quickly locate the
3220
requested index structure.
3221
Note we do not have mutex protection for the index translatoin table
3222
access, it is based on the assumption that there is no concurrent
3223
translation table rebuild (fter create/drop index) and DMLs that
3224
require index lookup.
3225
@return dict_index_t structure for requested index. NULL if
3226
fail to locate the index structure. */
3229
innobase_index_lookup(
3230
/*==================*/
3231
INNOBASE_SHARE* share, /*!< in: share structure for index
3232
translation table. */
3233
uint keynr) /*!< in: index number for the requested
3236
if (!share->idx_trans_tbl.index_mapping
3237
|| keynr >= share->idx_trans_tbl.index_count) {
3241
return(share->idx_trans_tbl.index_mapping[keynr]);
3244
/********************************************************************//**
3245
2923
Set the autoinc column max value. This should only be called once from
3246
ha_innobase::open(). Therefore there's no need for a covering lock. */
2924
ha_innobase::open(). Therefore there's no need for a covering lock.
2925
@return DB_SUCCESS or error code */
3249
2928
ha_innobase::innobase_initialize_autoinc()
3250
2929
/*======================================*/
2931
dict_index_t* index;
3252
2932
uint64_t auto_inc;
3253
const Field* field = getTable()->found_next_number_field;
3255
if (field != NULL) {
3256
auto_inc = innobase_get_int_col_max_value(field);
3258
/* We have no idea what's been passed in to us as the
3259
autoinc column. We set it to the 0, effectively disabling
3260
updates to the table. */
2933
const char* col_name;
2936
col_name = table->found_next_number_field->field_name;
2937
index = innobase_get_index(table->getShare()->next_number_index);
2939
/* Execute SELECT MAX(col_name) FROM TABLE; */
2940
error = row_search_max_autoinc(index, col_name, &auto_inc);
2945
/* At the this stage we don't know the increment
2946
or the offset, so use default inrement of 1. */
2950
case DB_RECORD_NOT_FOUND:
3263
2951
ut_print_timestamp(stderr);
3264
fprintf(stderr, " InnoDB: Unable to determine the AUTOINC "
3268
if (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE) {
3269
/* If the recovery level is set so high that writes
3270
are disabled we force the AUTOINC counter to 0
3271
value effectively disabling writes to the table.
3272
Secondly, we avoid reading the table in case the read
3273
results in failure due to a corrupted table/index.
3275
We will not return an error to the client, so that the
3276
tables can be dumped with minimal hassle. If an error
3277
were returned in this case, the first attempt to read
3278
the table would fail and subsequent SELECTs would succeed. */
3280
} else if (field == NULL) {
3281
/* This is a far more serious error, best to avoid
3282
opening the table and return failure. */
3283
my_error(ER_AUTOINC_READ_FAILED, MYF(0));
3285
dict_index_t* index;
3286
const char* col_name;
3287
uint64_t read_auto_inc;
3290
update_session(getTable()->in_use);
3291
col_name = field->field_name;
3293
ut_a(prebuilt->trx == session_to_trx(user_session));
3295
index = innobase_get_index(getTable()->getShare()->next_number_index);
3297
/* Execute SELECT MAX(col_name) FROM TABLE; */
3298
err = row_search_max_autoinc(index, col_name, &read_auto_inc);
3302
uint64_t col_max_value;
3304
col_max_value = innobase_get_int_col_max_value(field);
3306
/* At the this stage we do not know the increment
3307
nor the offset, so use a default increment of 1. */
3309
auto_inc = innobase_next_autoinc(read_auto_inc, 1, 1, col_max_value);
3313
case DB_RECORD_NOT_FOUND:
3314
ut_print_timestamp(stderr);
3315
fprintf(stderr, " InnoDB: MySQL and InnoDB data "
3316
"dictionaries are out of sync.\n"
3317
"InnoDB: Unable to find the AUTOINC column "
3318
"%s in the InnoDB table %s.\n"
3319
"InnoDB: We set the next AUTOINC column "
3321
"InnoDB: in effect disabling the AUTOINC "
3322
"next value generation.\n"
3323
"InnoDB: You can either set the next "
3324
"AUTOINC value explicitly using ALTER TABLE\n"
3325
"InnoDB: or fix the data dictionary by "
3326
"recreating the table.\n",
3327
col_name, index->table->name);
3329
/* This will disable the AUTOINC generation. */
3332
/* We want the open to succeed, so that the user can
3333
take corrective action. ie. reads should succeed but
3334
updates should fail. */
3338
/* row_search_max_autoinc() should only return
3339
one of DB_SUCCESS or DB_RECORD_NOT_FOUND. */
2952
fprintf(stderr, " InnoDB: MySQL and InnoDB data "
2953
"dictionaries are out of sync.\n"
2954
"InnoDB: Unable to find the AUTOINC column %s in the "
2955
"InnoDB table %s.\n"
2956
"InnoDB: We set the next AUTOINC column value to the "
2957
"maximum possible value,\n"
2958
"InnoDB: in effect disabling the AUTOINC next value "
2960
"InnoDB: You can either set the next AUTOINC value "
2961
"explicitly using ALTER TABLE\n"
2962
"InnoDB: or fix the data dictionary by recreating "
2964
col_name, index->table->name);
2966
auto_inc = 0xFFFFFFFFFFFFFFFFULL;
3344
2973
dict_table_autoinc_initialize(prebuilt->table, auto_inc);
3347
2978
/*****************************************************************//**
9187
8340
/************************************************************//**
8341
Validate the file format check value, is it one of "on" or "off",
8342
as a side effect it sets the srv_check_file_format_at_startup variable.
8343
@return true if config value one of "on" or "off" */
8346
innobase_file_format_check_on_off(
8347
/*==============================*/
8348
const char* format_check) /*!< in: parameter value */
8352
if (!innobase_strcasecmp(format_check, "off")) {
8354
/* Set the value to disable checking. */
8355
srv_check_file_format_at_startup = DICT_TF_FORMAT_MAX + 1;
8357
} else if (!innobase_strcasecmp(format_check, "on")) {
8359
/* Set the value to the lowest supported format. */
8360
srv_check_file_format_at_startup = DICT_TF_FORMAT_51;
8368
/************************************************************//**
9188
8369
Validate the file format check config parameters, as a side effect it
9189
sets the srv_max_file_format_at_startup variable.
9190
@return the format_id if valid config value, otherwise, return -1 */
8370
sets the srv_check_file_format_at_startup variable.
8371
@return true if valid config value */
9193
innobase_file_format_validate_and_set(
8374
innobase_file_format_check_validate(
9194
8375
/*================================*/
9195
const char* format_max) /*!< in: parameter value */
8376
const char* format_check) /*!< in: parameter value */
9197
8378
uint format_id;
9199
format_id = innobase_file_format_name_lookup(format_max);
8381
format_id = innobase_file_format_name_lookup(format_check);
9201
8383
if (format_id < DICT_TF_FORMAT_MAX + 1) {
9202
srv_max_file_format_at_startup = format_id;
9203
return((int) format_id);
8384
srv_check_file_format_at_startup = format_id;
8392
/*************************************************************//**
8393
Check if it is a valid file format. This function is registered as
8394
a callback with MySQL.
8395
@return 0 for valid file format */
8398
innodb_file_format_name_validate(
8399
/*=============================*/
8400
Session* , /*!< in: thread handle */
8401
drizzle_sys_var* , /*!< in: pointer to system
8403
void* save, /*!< out: immediate result
8404
for update function */
8405
drizzle_value* value) /*!< in: incoming string */
8407
const char* file_format_input;
8408
char buff[STRING_BUFFER_USUAL_SIZE];
8409
int len = sizeof(buff);
8412
ut_a(value != NULL);
8414
file_format_input = value->val_str(value, buff, &len);
8416
if (file_format_input != NULL) {
8419
format_id = innobase_file_format_name_lookup(
8422
if (format_id <= DICT_TF_FORMAT_MAX) {
8424
*static_cast<const char**>(save) = file_format_input;
8429
*static_cast<const char**>(save) = NULL;
8433
/****************************************************************//**
8434
Update the system variable innodb_file_format using the "saved"
8435
value. This function is registered as a callback with MySQL. */
8438
innodb_file_format_name_update(
8439
/*===========================*/
8440
Session* , /*!< in: thread handle */
8441
drizzle_sys_var* , /*!< in: pointer to
8443
void* var_ptr, /*!< out: where the
8444
formal string goes */
8445
const void* save) /*!< in: immediate result
8446
from check function */
8448
const char* format_name;
8450
ut_a(var_ptr != NULL);
8453
format_name = *static_cast<const char*const*>(save);
8458
format_id = innobase_file_format_name_lookup(format_name);
8460
if (format_id <= DICT_TF_FORMAT_MAX) {
8461
srv_file_format = format_id;
8465
*static_cast<const char**>(var_ptr)
8466
= trx_sys_file_format_id_to_name(srv_file_format);
8469
/*************************************************************//**
8470
Check if valid argument to innodb_file_format_check. This
8471
function is registered as a callback with MySQL.
8472
@return 0 for valid file format */
8475
innodb_file_format_check_validate(
8476
/*==============================*/
8477
Session* , /*!< in: thread handle */
8478
drizzle_sys_var* , /*!< in: pointer to system
8480
void* save, /*!< out: immediate result
8481
for update function */
8482
drizzle_value* value) /*!< in: incoming string */
8484
const char* file_format_input;
8485
char buff[STRING_BUFFER_USUAL_SIZE];
8486
int len = sizeof(buff);
8489
ut_a(value != NULL);
8491
file_format_input = value->val_str(value, buff, &len);
8493
if (file_format_input != NULL) {
8495
/* Check if user set on/off, we want to print a suitable
8496
message if they did so. */
8498
if (innobase_file_format_check_on_off(file_format_input)) {
8499
errmsg_printf(ERRMSG_LVL_WARN,
8500
"InnoDB: invalid innodb_file_format_check "
8501
"value; on/off can only be set at startup or "
8502
"in the configuration file");
8503
} else if (innobase_file_format_check_validate(
8504
file_format_input)) {
8506
*static_cast<const char**>(save) = file_format_input;
8511
errmsg_printf(ERRMSG_LVL_WARN,
8512
"InnoDB: invalid innodb_file_format_check "
8513
"value; can be any format up to %s "
8514
"or its equivalent numeric id",
8515
trx_sys_file_format_id_to_name(
8516
DICT_TF_FORMAT_MAX));
8520
*static_cast<const char**>(save) = NULL;
8524
/****************************************************************//**
8525
Update the system variable innodb_file_format_check using the "saved"
8526
value. This function is registered as a callback with MySQL. */
8529
innodb_file_format_check_update(
8530
/*============================*/
8531
Session* session, /*!< in: thread handle */
8532
drizzle_sys_var* , /*!< in: pointer to
8534
void* var_ptr, /*!< out: where the
8535
formal string goes */
8536
const void* save) /*!< in: immediate result
8537
from check function */
8539
const char* format_name_in;
8540
const char** format_name_out;
8544
ut_a(var_ptr != NULL);
8546
format_name_in = *static_cast<const char*const*>(save);
8548
if (!format_name_in) {
8553
format_id = innobase_file_format_name_lookup(format_name_in);
8555
if (format_id > DICT_TF_FORMAT_MAX) {
8556
/* DEFAULT is "on", which is invalid at runtime. */
8557
push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
8559
"Ignoring SET innodb_file_format=%s",
8564
format_name_out = static_cast<const char**>(var_ptr);
8566
/* Update the max format id in the system tablespace. */
8567
if (trx_sys_file_format_max_set(format_id, format_name_out)) {
8568
ut_print_timestamp(stderr);
8570
" [Info] InnoDB: the file format in the system "
8571
"tablespace is now set to %s.\n", *format_name_out);
8575
/****************************************************************//**
8576
Update the system variable innodb_adaptive_hash_index using the "saved"
8577
value. This function is registered as a callback with MySQL. */
8580
innodb_adaptive_hash_index_update(
8581
/*==============================*/
8582
Session* , /*!< in: thread handle */
8583
drizzle_sys_var* , /*!< in: pointer to
8585
void* , /*!< out: where the
8586
formal string goes */
8587
const void* save) /*!< in: immediate result
8588
from check function */
8590
if (*(bool*) save) {
8591
btr_search_enable();
8593
btr_search_disable();
8597
/*************************************************************//**
8598
Check if it is a valid value of innodb_change_buffering. This function is
8599
registered as a callback with MySQL.
8600
@return 0 for valid innodb_change_buffering */
8603
innodb_change_buffering_validate(
8604
/*=============================*/
8605
Session* , /*!< in: thread handle */
8606
drizzle_sys_var* , /*!< in: pointer to system
8608
void* save, /*!< out: immediate result
8609
for update function */
8610
drizzle_value* value) /*!< in: incoming string */
8612
const char* change_buffering_input;
8613
char buff[STRING_BUFFER_USUAL_SIZE];
8614
int len = sizeof(buff);
8617
ut_a(value != NULL);
8619
change_buffering_input = value->val_str(value, buff, &len);
8621
if (change_buffering_input != NULL) {
8624
for (use = 0; use < UT_ARR_SIZE(innobase_change_buffering_values);
8626
if (!innobase_strcasecmp(
8627
change_buffering_input,
8628
innobase_change_buffering_values[use])) {
8629
*(ibuf_use_t*) save = (ibuf_use_t) use;
8638
/****************************************************************//**
8639
Update the system variable innodb_change_buffering using the "saved"
8640
value. This function is registered as a callback with MySQL. */
8643
innodb_change_buffering_update(
8644
/*===========================*/
8645
Session* , /*!< in: thread handle */
8646
drizzle_sys_var* , /*!< in: pointer to
8648
void* var_ptr, /*!< out: where the
8649
formal string goes */
8650
const void* save) /*!< in: immediate result
8651
from check function */
8653
ut_a(var_ptr != NULL);
8655
ut_a((*(ibuf_use_t*) save) < IBUF_USE_COUNT);
8657
ibuf_use = *(const ibuf_use_t*) save;
8659
*(const char**) var_ptr = innobase_change_buffering_values[ibuf_use];
8662
/* plugin options */
8663
static DRIZZLE_SYSVAR_BOOL(checksums, innobase_use_checksums,
8664
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8665
"Enable InnoDB checksums validation (enabled by default). ",
8668
static DRIZZLE_SYSVAR_STR(data_home_dir, innobase_data_home_dir,
8669
PLUGIN_VAR_READONLY,
8670
"The common part for InnoDB table spaces.",
8673
static DRIZZLE_SYSVAR_BOOL(doublewrite, innobase_use_doublewrite,
8674
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8675
"Enable InnoDB doublewrite buffer (enabled by default). ",
8678
static DRIZZLE_SYSVAR_ULONG(io_capacity, srv_io_capacity,
8679
PLUGIN_VAR_RQCMDARG,
8680
"Number of IOPs the server can do. Tunes the background IO rate",
8681
NULL, NULL, 200, 100, ~0L, 0);
8683
static DRIZZLE_SYSVAR_ULONG(fast_shutdown, innobase_fast_shutdown,
8684
PLUGIN_VAR_OPCMDARG,
8685
"Speeds up the shutdown process of the InnoDB storage engine. Possible "
8686
"values are 0, 1 (faster)"
8687
" or 2 (fastest - crash-like)"
8689
NULL, NULL, 1, 0, 2, 0);
8691
static DRIZZLE_SYSVAR_BOOL(file_per_table, srv_file_per_table,
8692
PLUGIN_VAR_NOCMDARG,
8693
"Stores each InnoDB table to an .ibd file in the database dir.",
8696
static DRIZZLE_SYSVAR_STR(file_format, innobase_file_format_name,
8697
PLUGIN_VAR_RQCMDARG,
8698
"File format to use for new tables in .ibd files.",
8699
innodb_file_format_name_validate,
8700
innodb_file_format_name_update, "Antelope");
8702
static DRIZZLE_SYSVAR_STR(file_format_check, innobase_file_format_check,
8703
PLUGIN_VAR_OPCMDARG,
8704
"The highest file format in the tablespace.",
8705
innodb_file_format_check_validate,
8706
innodb_file_format_check_update,
8709
static DRIZZLE_SYSVAR_ULONG(flush_log_at_trx_commit, srv_flush_log_at_trx_commit,
8710
PLUGIN_VAR_OPCMDARG,
8711
"Set to 0 (write and flush once per second),"
8712
" 1 (write and flush at each commit)"
8713
" or 2 (write at commit, flush once per second).",
8714
NULL, NULL, 1, 0, 2, 0);
8716
static DRIZZLE_SYSVAR_STR(flush_method, innobase_unix_file_flush_method,
8717
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8718
"With which method to flush data.", NULL, NULL, NULL);
8720
#ifdef UNIV_LOG_ARCHIVE
8721
static DRIZZLE_SYSVAR_STR(log_arch_dir, innobase_log_arch_dir,
8722
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8723
"Where full logs should be archived.", NULL, NULL, NULL);
8725
static DRIZZLE_SYSVAR_BOOL(log_archive, innobase_log_archive,
8726
PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
8727
"Set to 1 if you want to have logs archived.", NULL, NULL, FALSE);
8728
#endif /* UNIV_LOG_ARCHIVE */
8730
static DRIZZLE_SYSVAR_STR(log_group_home_dir, innobase_log_group_home_dir,
8731
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8732
"Path to InnoDB log files.", NULL, NULL, NULL);
8734
static DRIZZLE_SYSVAR_ULONG(max_dirty_pages_pct, srv_max_buf_pool_modified_pct,
8735
PLUGIN_VAR_RQCMDARG,
8736
"Percentage of dirty pages allowed in bufferpool.",
8737
NULL, NULL, 75, 0, 99, 0);
8739
static DRIZZLE_SYSVAR_BOOL(adaptive_flushing, srv_adaptive_flushing,
8740
PLUGIN_VAR_NOCMDARG,
8741
"Attempt flushing dirty pages to avoid IO bursts at checkpoints.",
8744
static DRIZZLE_SYSVAR_ULONG(max_purge_lag, srv_max_purge_lag,
8745
PLUGIN_VAR_RQCMDARG,
8746
"Desired maximum length of the purge queue (0 = no limit)",
8747
NULL, NULL, 0, 0, ~0L, 0);
8749
static DRIZZLE_SYSVAR_BOOL(status_file, innobase_create_status_file,
8750
PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_NOSYSVAR,
8751
"Enable SHOW INNODB STATUS output in the innodb_status.<pid> file",
8754
static DRIZZLE_SYSVAR_BOOL(stats_on_metadata, innobase_stats_on_metadata,
8755
PLUGIN_VAR_OPCMDARG,
8756
"Enable statistics gathering for metadata commands such as SHOW TABLE STATUS (on by default)",
8759
static DRIZZLE_SYSVAR_ULONGLONG(stats_sample_pages, srv_stats_sample_pages,
8760
PLUGIN_VAR_RQCMDARG,
8761
"The number of index pages to sample when calculating statistics (default 8)",
8762
NULL, NULL, 8, 1, ~0ULL, 0);
8764
static DRIZZLE_SYSVAR_BOOL(adaptive_hash_index, btr_search_enabled,
8765
PLUGIN_VAR_OPCMDARG,
8766
"Enable InnoDB adaptive hash index (enabled by default).",
8767
NULL, innodb_adaptive_hash_index_update, TRUE);
8769
static DRIZZLE_SYSVAR_ULONG(replication_delay, srv_replication_delay,
8770
PLUGIN_VAR_RQCMDARG,
8771
"Replication thread delay (ms) on the slave server if "
8772
"innodb_thread_concurrency is reached (0 by default)",
8773
NULL, NULL, 0, 0, ~0UL, 0);
8775
static DRIZZLE_SYSVAR_LONG(additional_mem_pool_size, innobase_additional_mem_pool_size,
8776
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8777
"Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.",
8778
NULL, NULL, 8*1024*1024L, 512*1024L, LONG_MAX, 1024);
8780
static DRIZZLE_SYSVAR_UINT(autoextend_increment, srv_auto_extend_increment,
8781
PLUGIN_VAR_RQCMDARG,
8782
"Data file autoextend increment in megabytes",
8783
NULL, NULL, 8L, 1L, 1000L, 0);
8785
static DRIZZLE_SYSVAR_LONGLONG(buffer_pool_size, innobase_buffer_pool_size,
8786
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8787
"The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",
8788
NULL, NULL, 128*1024*1024L, 5*1024*1024L, INT64_MAX, 1024*1024L);
8790
static DRIZZLE_SYSVAR_ULONG(commit_concurrency, innobase_commit_concurrency,
8791
PLUGIN_VAR_RQCMDARG,
8792
"Helps in performance tuning in heavily concurrent environments.",
8793
innobase_commit_concurrency_validate, NULL, 0, 0, 1000, 0);
8795
static DRIZZLE_SYSVAR_ULONG(concurrency_tickets, srv_n_free_tickets_to_enter,
8796
PLUGIN_VAR_RQCMDARG,
8797
"Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got the ticket",
8798
NULL, NULL, 500L, 1L, ~0L, 0);
8800
static DRIZZLE_SYSVAR_LONG(file_io_threads, innobase_file_io_threads,
8801
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8802
"Number of file I/O threads in InnoDB.",
8803
NULL, NULL, 4, 4, 64, 0);
8805
static DRIZZLE_SYSVAR_ULONG(read_io_threads, innobase_read_io_threads,
8806
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8807
"Number of background read I/O threads in InnoDB.",
8808
NULL, NULL, 4, 1, 64, 0);
8810
static DRIZZLE_SYSVAR_ULONG(write_io_threads, innobase_write_io_threads,
8811
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8812
"Number of background write I/O threads in InnoDB.",
8813
NULL, NULL, 4, 1, 64, 0);
8815
static DRIZZLE_SYSVAR_LONG(force_recovery, innobase_force_recovery,
8816
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8817
"Helps to save your data in case the disk image of the database becomes corrupt.",
8818
NULL, NULL, 0, 0, 6, 0);
8820
static DRIZZLE_SYSVAR_LONG(log_buffer_size, innobase_log_buffer_size,
8821
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8822
"The size of the buffer which InnoDB uses to write log to the log files on disk.",
8823
NULL, NULL, 8*1024*1024L, 256*1024L, LONG_MAX, 1024);
8825
static DRIZZLE_SYSVAR_LONGLONG(log_file_size, innobase_log_file_size,
8826
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8827
"Size of each log file in a log group.",
8828
NULL, NULL, 20*1024*1024L, 1*1024*1024L, INT64_MAX, 1024*1024L);
8830
static DRIZZLE_SYSVAR_LONG(log_files_in_group, innobase_log_files_in_group,
8831
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8832
"Number of log files in the log group. InnoDB writes to the files in a circular fashion. Value 3 is recommended here.",
8833
NULL, NULL, 2, 2, 100, 0);
8835
static DRIZZLE_SYSVAR_LONG(mirrored_log_groups, innobase_mirrored_log_groups,
8836
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8837
"Number of identical copies of log groups we keep for the database. Currently this should be set to 1.",
8838
NULL, NULL, 1, 1, 10, 0);
8840
static DRIZZLE_SYSVAR_LONG(open_files, innobase_open_files,
8841
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8842
"How many files at the maximum InnoDB keeps open at the same time.",
8843
NULL, NULL, 300L, 10L, LONG_MAX, 0);
8845
static DRIZZLE_SYSVAR_ULONG(sync_spin_loops, srv_n_spin_wait_rounds,
8846
PLUGIN_VAR_RQCMDARG,
8847
"Count of spin-loop rounds in InnoDB mutexes (30 by default)",
8848
NULL, NULL, 30L, 0L, ~0L, 0);
8850
static DRIZZLE_SYSVAR_ULONG(spin_wait_delay, srv_spin_wait_delay,
8851
PLUGIN_VAR_OPCMDARG,
8852
"Maximum delay between polling for a spin lock (6 by default)",
8853
NULL, NULL, 6L, 0L, ~0L, 0);
8855
static DRIZZLE_SYSVAR_ULONG(thread_concurrency, srv_thread_concurrency,
8856
PLUGIN_VAR_RQCMDARG,
8857
"Helps in performance tuning in heavily concurrent environments. Sets the maximum number of threads allowed inside InnoDB. Value 0 will disable the thread throttling.",
8858
NULL, NULL, 0, 0, 1000, 0);
8860
static DRIZZLE_SYSVAR_ULONG(thread_sleep_delay, srv_thread_sleep_delay,
8861
PLUGIN_VAR_RQCMDARG,
8862
"Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0 disable a sleep",
8863
NULL, NULL, 10000L, 0L, ~0L, 0);
8865
static DRIZZLE_SYSVAR_STR(data_file_path, innobase_data_file_path,
8866
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8867
"Path to individual files and their sizes.",
8870
static DRIZZLE_SYSVAR_STR(version, innodb_version_str,
8871
PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_READONLY,
8872
"InnoDB version", NULL, NULL, INNODB_VERSION_STR);
8874
static DRIZZLE_SYSVAR_BOOL(use_sys_malloc, srv_use_sys_malloc,
8875
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8876
"Use OS memory allocator instead of InnoDB's internal memory allocator",
8879
static DRIZZLE_SYSVAR_STR(change_buffering, innobase_change_buffering,
8880
PLUGIN_VAR_RQCMDARG,
8881
"Buffer changes to reduce random access: "
8882
"OFF, ON, inserting, deleting, changing, or purging.",
8883
innodb_change_buffering_validate,
8884
innodb_change_buffering_update, NULL);
8886
static DRIZZLE_SYSVAR_ULONG(read_ahead_threshold, srv_read_ahead_threshold,
8887
PLUGIN_VAR_RQCMDARG,
8888
"Number of pages that must be accessed sequentially for InnoDB to"
8889
"trigger a readahead.",
8890
NULL, NULL, 56, 0, 64, 0);
9211
8892
static void init_options(drizzled::module::option_context &context)
9213
context("disable-checksums",
9214
"Disable InnoDB checksums validation.");
8894
context("checksums",
8895
po::value<bool>(&innobase_use_checksums)->default_value(true)->zero_tokens(),
8896
"Enable InnoDB checksums validation.");
9215
8897
context("data-home-dir",
9216
8898
po::value<string>(),
9217
8899
"The common part for InnoDB table spaces.");
9218
context("disable-doublewrite",
9219
"Disable InnoDB doublewrite buffer.");
8900
context("doublewrite",
8901
po::value<bool>(&innobase_use_doublewrite)->default_value(true)->zero_tokens(),
8902
"Enable InnoDB doublewrite buffer.");
9220
8903
context("io-capacity",
9221
po::value<io_capacity_constraint>(&innodb_io_capacity)->default_value(200),
8904
po::value<unsigned long>(&srv_io_capacity)->default_value(200),
9222
8905
"Number of IOPs the server can do. Tunes the background IO rate");
9223
8906
context("fast-shutdown",
9224
po::value<trinary_constraint>(&innobase_fast_shutdown)->default_value(1),
8907
po::value<unsigned long>(&innobase_fast_shutdown)->default_value(1),
9225
8908
"Speeds up the shutdown process of the InnoDB storage engine. Possible values are 0, 1 (faster) or 2 (fastest - crash-like).");
9226
context("purge-batch-size",
9227
po::value<purge_batch_constraint>(&innodb_purge_batch_size)->default_value(20),
9228
"Number of UNDO logs to purge in one batch from the history list. "
9230
context("purge-threads",
9231
po::value<purge_threads_constraint>(&innodb_n_purge_threads)->default_value(0),
9232
"Purge threads can be either 0 or 1. Defalut is 0.");
9233
8909
context("file-per-table",
9234
8910
po::value<bool>(&srv_file_per_table)->default_value(false)->zero_tokens(),
9235
8911
"Stores each InnoDB table to an .ibd file in the database dir.");
9236
8912
context("file-format",
9237
po::value<string>(&innobase_file_format_name)->default_value("Antelope"),
8913
po::value<string>()->default_value("Antelope"),
9238
8914
"File format to use for new tables in .ibd files.");
9239
context("file-format-max",
9240
po::value<string>(&innobase_file_format_max)->default_value("Antelope"),
8915
context("file-format-check",
8916
po::value<string>()->default_value("on"),
9241
8917
"The highest file format in the tablespace.");
9242
context("file-format-check",
9243
po::value<bool>(&innobase_file_format_check)->default_value(true)->zero_tokens(),
9244
"Whether to perform system file format check.");
9245
8918
context("flush-log-at-trx-commit",
9246
po::value<trinary_constraint>(&innodb_flush_log_at_trx_commit)->default_value(1),
8919
po::value<unsigned long>(&srv_flush_log_at_trx_commit)->default_value(1),
9247
8920
"Set to 0 (write and flush once per second), 1 (write and flush at each commit) or 2 (write at commit, flush once per second).");
9248
8921
context("flush-method",
9249
8922
po::value<string>(),
9250
8923
"With which method to flush data.");
8924
#ifdef UNIV_LOG_ARCHIVE
8925
context("log-arch-dir",
8926
po::value<string>(),
8927
"Where full logs should be archived.");
8928
context("log-archive",
8929
po::value<bool>(&innobase_log_archive)->default_value(false)->zero_tokens(),
8930
"Set to 1 if you want to have logs archived.");
8931
#endif /* UNIV_LOG_ARCHIVE */
9251
8932
context("log-group-home-dir",
9252
8933
po::value<string>(),
9253
8934
"Path to InnoDB log files.");
9254
8935
context("max-dirty-pages-pct",
9255
po::value<max_dirty_pages_constraint>(&innodb_max_dirty_pages_pct)->default_value(75),
8936
po::value<unsigned long>(&srv_max_buf_pool_modified_pct)->default_value(75),
9256
8937
"Percentage of dirty pages allowed in bufferpool.");
9257
context("disable-adaptive-flushing",
9258
"Do not attempt flushing dirty pages to avoid IO bursts at checkpoints.");
8938
context("adaptive-flushing",
8939
po::value<bool>(&srv_adaptive_flushing)->default_value(true)->zero_tokens(),
8940
"Attempt flushing dirty pages to avoid IO bursts at checkpoints.");
9259
8941
context("max-purge-lag",
9260
po::value<uint64_constraint>(&innodb_max_purge_lag)->default_value(0),
8942
po::value<unsigned long>(&srv_max_purge_lag)->default_value(0),
9261
8943
"Desired maximum length of the purge queue (0 = no limit)");
9262
8944
context("status-file",
9263
8945
po::value<bool>(&innobase_create_status_file)->default_value(false)->zero_tokens(),
9264
8946
"Enable SHOW INNODB STATUS output in the innodb_status.<pid> file");
9265
context("disable-stats-on-metadata",
9266
"Disable statistics gathering for metadata commands such as SHOW TABLE STATUS (on by default)");
8947
context("stats-on-metadata",
8948
po::value<bool>(&innobase_stats_on_metadata)->default_value(true)->zero_tokens(),
8949
"Enable statistics gathering for metadata commands such as SHOW TABLE STATUS (on by default)");
9267
8950
context("stats-sample-pages",
9268
po::value<uint64_nonzero_constraint>(&innodb_stats_sample_pages)->default_value(8),
8951
po::value<uint64_t>(&srv_stats_sample_pages)->default_value(8),
9269
8952
"The number of index pages to sample when calculating statistics (default 8)");
9270
context("disable-adaptive-hash-index",
8953
context("adaptive-hash-index",
8954
po::value<bool>(&btr_search_enabled)->default_value(true)->zero_tokens(),
9271
8955
"Enable InnoDB adaptive hash index (enabled by default)");
9272
8956
context("replication-delay",
9273
po::value<uint64_constraint>(&innodb_replication_delay)->default_value(0),
8957
po::value<unsigned long>(&srv_replication_delay)->default_value(0),
9274
8958
"Replication thread delay (ms) on the slave server if innodb_thread_concurrency is reached (0 by default)");
9275
8959
context("additional-mem-pool-size",
9276
po::value<additional_mem_pool_constraint>(&innobase_additional_mem_pool_size)->default_value(8*1024*1024L),
8960
po::value<long>(&innobase_additional_mem_pool_size)->default_value(8*1024*1024L),
9277
8961
"Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.");
9278
8962
context("autoextend-increment",
9279
po::value<autoextend_constraint>(&innodb_auto_extend_increment)->default_value(8L),
8963
po::value<uint32_t>(&srv_auto_extend_increment)->default_value(8L),
9280
8964
"Data file autoextend increment in megabytes");
9281
8965
context("buffer-pool-size",
9282
po::value<buffer_pool_constraint>(&innobase_buffer_pool_size)->default_value(128*1024*1024L),
8966
po::value<int64_t>(&innobase_buffer_pool_size)->default_value(128*1024*1024L),
9283
8967
"The size of the memory buffer InnoDB uses to cache data and indexes of its tables.");
9284
context("buffer-pool-instances",
9285
po::value<buffer_pool_instances_constraint>(&innobase_buffer_pool_instances)->default_value(1),
9286
"Number of buffer pool instances, set to higher value on high-end machines to increase scalability");
9288
8968
context("commit-concurrency",
9289
po::value<concurrency_constraint>(&innobase_commit_concurrency)->default_value(0),
8969
po::value<unsigned long>(&innobase_commit_concurrency)->default_value(0),
9290
8970
"Helps in performance tuning in heavily concurrent environments.");
9291
8971
context("concurrency-tickets",
9292
po::value<uint32_nonzero_constraint>(&innodb_concurrency_tickets)->default_value(500L),
8972
po::value<unsigned long>(&srv_n_free_tickets_to_enter)->default_value(500L),
9293
8973
"Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got the ticket");
8974
context("file-io-threads",
8975
po::value<long>(&innobase_file_io_threads)->default_value(4),
8976
"Number of file I/O threads in InnoDB.");
9294
8977
context("read-io-threads",
9295
po::value<io_threads_constraint>(&innobase_read_io_threads)->default_value(4),
8978
po::value<unsigned long>(&innobase_read_io_threads)->default_value(4),
9296
8979
"Number of background read I/O threads in InnoDB.");
9297
8980
context("write-io-threads",
9298
po::value<io_threads_constraint>(&innobase_write_io_threads)->default_value(4),
8981
po::value<unsigned long>(&innobase_write_io_threads)->default_value(4),
9299
8982
"Number of background write I/O threads in InnoDB.");
9300
8983
context("force-recovery",
9301
po::value<force_recovery_constraint>(&innobase_force_recovery)->default_value(0),
8984
po::value<long>(&innobase_force_recovery)->default_value(0),
9302
8985
"Helps to save your data in case the disk image of the database becomes corrupt.");
9303
8986
context("log-buffer-size",
9304
po::value<log_buffer_constraint>(&innobase_log_buffer_size)->default_value(8*1024*1024L),
8987
po::value<long>(&innobase_log_buffer_size)->default_value(8*1024*1024L),
9305
8988
"The size of the buffer which InnoDB uses to write log to the log files on disk.");
9306
8989
context("log-file-size",
9307
po::value<log_file_constraint>(&innobase_log_file_size)->default_value(20*1024*1024L),
8990
po::value<int64_t>(&innobase_log_file_size)->default_value(20*1024*1024L),
9308
8991
"The size of the buffer which InnoDB uses to write log to the log files on disk.");
9309
8992
context("log-files-in-group",
9310
po::value<log_files_in_group_constraint>(&innobase_log_files_in_group)->default_value(2),
8993
po::value<long>(&innobase_log_files_in_group)->default_value(2),
9311
8994
"Number of log files in the log group. InnoDB writes to the files in a circular fashion.");
9312
8995
context("mirrored-log-groups",
9313
po::value<mirrored_log_groups_constraint>(&innobase_mirrored_log_groups)->default_value(1),
8996
po::value<long>(&innobase_mirrored_log_groups)->default_value(1),
9314
8997
"Number of identical copies of log groups we keep for the database. Currently this should be set to 1.");
9315
8998
context("open-files",
9316
po::value<open_files_constraint>(&innobase_open_files)->default_value(300L),
8999
po::value<long>(&innobase_open_files)->default_value(300L),
9317
9000
"How many files at the maximum InnoDB keeps open at the same time.");
9318
9001
context("sync-spin-loops",
9319
po::value<uint32_constraint>(&innodb_sync_spin_loops)->default_value(30L),
9002
po::value<unsigned long>(&srv_n_spin_wait_rounds)->default_value(30L),
9320
9003
"Count of spin-loop rounds in InnoDB mutexes (30 by default)");
9321
9004
context("spin-wait-delay",
9322
po::value<uint32_constraint>(&innodb_spin_wait_delay)->default_value(6L),
9005
po::value<unsigned long>(&srv_spin_wait_delay)->default_value(6L),
9323
9006
"Maximum delay between polling for a spin lock (6 by default)");
9324
9007
context("thread-concurrency",
9325
po::value<concurrency_constraint>(&innobase_thread_concurrency)->default_value(0),
9008
po::value<unsigned long>(&srv_thread_concurrency)->default_value(0),
9326
9009
"Helps in performance tuning in heavily concurrent environments. Sets the maximum number of threads allowed inside InnoDB. Value 0 will disable the thread throttling.");
9327
9010
context("thread-sleep-delay",
9328
po::value<uint32_constraint>(&innodb_thread_sleep_delay)->default_value(10000L),
9011
po::value<unsigned long>(&srv_thread_sleep_delay)->default_value(10000L),
9329
9012
"Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0 disable a sleep");
9330
9013
context("data-file-path",
9331
9014
po::value<string>(),
added
removed
plugin/innobase/handler/ha_innodb.cc
