160
169
#endif /* MYSQL_DYNAMIC_PLUGIN && __WIN__ */
162
171
static plugin::XaStorageEngine* innodb_engine_ptr= NULL;
164
typedef constrained_check<uint32_t, UINT32_MAX, 10> open_files_constraint;
165
static open_files_constraint innobase_open_files;
166
typedef constrained_check<uint32_t, 10, 1> mirrored_log_groups_constraint;
167
static mirrored_log_groups_constraint innobase_mirrored_log_groups;
168
typedef constrained_check<uint32_t, 100, 2> log_files_in_group_constraint;
169
static log_files_in_group_constraint innobase_log_files_in_group;
170
typedef constrained_check<uint32_t, 6, 0> force_recovery_constraint;
171
force_recovery_constraint innobase_force_recovery;
172
typedef constrained_check<size_t, SIZE_MAX, 256*1024, 1024> log_buffer_constraint;
173
static log_buffer_constraint innobase_log_buffer_size;
174
typedef constrained_check<size_t, SIZE_MAX, 512*1024, 1024> additional_mem_pool_constraint;
175
static additional_mem_pool_constraint innobase_additional_mem_pool_size;
176
typedef constrained_check<unsigned int, 1000, 1> autoextend_constraint;
177
static autoextend_constraint innodb_auto_extend_increment;
178
typedef constrained_check<size_t, SIZE_MAX, 5242880, 1048576> buffer_pool_constraint;
179
static buffer_pool_constraint innobase_buffer_pool_size;
180
typedef constrained_check<uint32_t, MAX_BUFFER_POOLS, 1> buffer_pool_instances_constraint;
181
static buffer_pool_instances_constraint innobase_buffer_pool_instances;
182
typedef constrained_check<uint32_t, UINT32_MAX, 100> io_capacity_constraint;
183
static io_capacity_constraint innodb_io_capacity;
184
typedef constrained_check<uint32_t, 5000, 1> purge_batch_constraint;
185
static purge_batch_constraint innodb_purge_batch_size;
186
typedef constrained_check<uint32_t, 1, 0> purge_threads_constraint;
187
static purge_threads_constraint innodb_n_purge_threads;
188
typedef constrained_check<uint32_t, 2, 0> trinary_constraint;
189
static trinary_constraint innodb_flush_log_at_trx_commit;
190
typedef constrained_check<unsigned int, 99, 0> max_dirty_pages_constraint;
191
static max_dirty_pages_constraint innodb_max_dirty_pages_pct;
192
static uint64_constraint innodb_max_purge_lag;
193
static uint64_nonzero_constraint innodb_stats_sample_pages;
194
typedef constrained_check<uint32_t, 64, 1> io_threads_constraint;
195
static io_threads_constraint innobase_read_io_threads;
196
static io_threads_constraint innobase_write_io_threads;
198
typedef constrained_check<uint32_t, 1000, 0> concurrency_constraint;
199
static concurrency_constraint innobase_commit_concurrency;
200
static concurrency_constraint innobase_thread_concurrency;
201
static uint32_nonzero_constraint innodb_concurrency_tickets;
203
typedef constrained_check<int64_t, INT64_MAX, 1024*1024, 1024*1024> log_file_constraint;
204
static log_file_constraint innobase_log_file_size;
206
static uint64_constraint innodb_replication_delay;
208
/** Percentage of the buffer pool to reserve for 'old' blocks.
209
Connected to buf_LRU_old_ratio. */
210
typedef constrained_check<uint32_t, 95, 5> old_blocks_constraint;
211
static old_blocks_constraint innobase_old_blocks_pct;
213
static uint32_constraint innodb_sync_spin_loops;
214
static uint32_constraint innodb_spin_wait_delay;
215
static uint32_constraint innodb_thread_sleep_delay;
217
typedef constrained_check<uint32_t, 64, 0> read_ahead_threshold_constraint;
218
static read_ahead_threshold_constraint innodb_read_ahead_threshold;
172
static plugin::TableFunction* status_table_function_ptr= NULL;
173
static plugin::TableFunction* cmp_tool= NULL;
174
static plugin::TableFunction* cmp_reset_tool= NULL;
175
static plugin::TableFunction* cmp_mem_tool= NULL;
176
static plugin::TableFunction* cmp_mem_reset_tool= NULL;
177
static plugin::TableFunction* innodb_trx_tool= NULL;
178
static plugin::TableFunction* innodb_locks_tool= NULL;
179
static plugin::TableFunction* innodb_lock_waits_tool= NULL;
181
static long innobase_mirrored_log_groups, innobase_log_files_in_group,
182
innobase_log_buffer_size,
183
innobase_additional_mem_pool_size, innobase_file_io_threads,
184
innobase_force_recovery, innobase_open_files;
185
static ulong innobase_commit_concurrency = 0;
186
static ulong innobase_read_io_threads;
187
static ulong innobase_write_io_threads;
190
* @TODO: Turn this into size_t as soon as we have a Variable<size_t>
192
static int64_t innobase_buffer_pool_size, innobase_log_file_size;
220
194
/* The default values for the following char* start-up parameters
221
195
are determined in innobase_init below: */
223
std::string innobase_data_home_dir;
224
std::string innobase_data_file_path;
225
std::string innobase_log_group_home_dir;
226
static string innobase_file_format_name;
227
static string innobase_change_buffering;
229
/* The highest file format being used in the database. The value can be
230
set by user, however, it will be adjusted to the newer file format if
231
a table of such format is created/opened. */
232
static string innobase_file_format_max;
197
static char* innobase_data_home_dir = NULL;
198
static char* innobase_data_file_path = NULL;
199
static char* innobase_log_group_home_dir = NULL;
200
static char* innobase_file_format_name = NULL;
201
static char* innobase_change_buffering = NULL;
203
/* Note: This variable can be set to on/off and any of the supported
204
file formats in the configuration file, but can only be set to any
205
of the supported file formats during runtime. */
206
static char* innobase_file_format_check = NULL;
208
/* The following has a misleading name: starting from 4.0.5, this also
210
static char* innobase_unix_file_flush_method = NULL;
234
212
/* Below we have boolean-valued start-up parameters, and their default
237
typedef constrained_check<uint32_t, 2, 0> trinary_constraint;
238
static trinary_constraint innobase_fast_shutdown;
240
/* "innobase_file_format_check" decides whether we would continue
241
booting the server if the file format stamped on the system
242
table space exceeds the maximum file format supported
243
by the server. Can be set during server startup at command
244
line or configure file, and a read only variable after
247
/* If a new file format is introduced, the file format
248
name needs to be updated accordingly. Please refer to
249
file_format_name_map[] defined in trx0sys.c for the next
252
static my_bool innobase_file_format_check = TRUE;
215
static ulong innobase_fast_shutdown = 1;
216
#ifdef UNIV_LOG_ARCHIVE
217
static my_bool innobase_log_archive = FALSE;
218
static char* innobase_log_arch_dir = NULL;
219
#endif /* UNIV_LOG_ARCHIVE */
253
220
static my_bool innobase_use_doublewrite = TRUE;
254
221
static my_bool innobase_use_checksums = TRUE;
255
222
static my_bool innobase_rollback_on_timeout = FALSE;
256
223
static my_bool innobase_create_status_file = FALSE;
257
static bool innobase_use_replication_log;
258
static bool support_xa;
259
static bool strict_mode;
260
typedef constrained_check<uint32_t, 1024*1024*1024, 1> lock_wait_constraint;
261
static lock_wait_constraint lock_wait_timeout;
224
static my_bool innobase_stats_on_metadata = TRUE;
263
226
static char* internal_innobase_data_file_path = NULL;
228
static char* innodb_version_str = (char*) INNODB_VERSION_STR;
265
230
/* The following counter is used to convey information to InnoDB
266
231
about server activity: in selects it is not sensible to call
267
232
srv_active_wake_master_thread after each fetch or search, we only do
2269
2091
err = innobase_start_or_create_for_mysql();
2271
if (err != DB_SUCCESS)
2273
goto mem_free_and_error;
2276
err = dict_create_sys_replication_log();
2278
2093
if (err != DB_SUCCESS) {
2279
2094
goto mem_free_and_error;
2283
innobase_old_blocks_pct = buf_LRU_old_ratio_update(innobase_old_blocks_pct.get(),
2286
2097
innobase_open_tables = hash_create(200);
2098
pthread_mutex_init(&innobase_share_mutex, MY_MUTEX_INIT_FAST);
2099
pthread_mutex_init(&prepare_commit_mutex, MY_MUTEX_INIT_FAST);
2100
pthread_mutex_init(&commit_threads_m, MY_MUTEX_INIT_FAST);
2101
pthread_mutex_init(&commit_cond_m, MY_MUTEX_INIT_FAST);
2102
pthread_cond_init(&commit_cond, NULL);
2287
2103
innodb_inited= 1;
2289
2105
actuall_engine_ptr->dropTemporarySchema();
2291
context.add(new InnodbStatusTool);
2107
status_table_function_ptr= new InnodbStatusTool;
2293
2109
context.add(innodb_engine_ptr);
2295
context.add(new(std::nothrow)CmpTool(false));
2297
context.add(new(std::nothrow)CmpTool(true));
2299
context.add(new(std::nothrow)CmpmemTool(false));
2301
context.add(new(std::nothrow)CmpmemTool(true));
2303
context.add(new(std::nothrow)InnodbTrxTool("INNODB_TRX"));
2305
context.add(new(std::nothrow)InnodbTrxTool("INNODB_LOCKS"));
2307
context.add(new(std::nothrow)InnodbTrxTool("INNODB_LOCK_WAITS"));
2309
context.add(new(std::nothrow)InnodbSysTablesTool());
2311
context.add(new(std::nothrow)InnodbSysTableStatsTool());
2313
context.add(new(std::nothrow)InnodbSysIndexesTool());
2315
context.add(new(std::nothrow)InnodbSysColumnsTool());
2317
context.add(new(std::nothrow)InnodbSysFieldsTool());
2319
context.add(new(std::nothrow)InnodbSysForeignTool());
2321
context.add(new(std::nothrow)InnodbSysForeignColsTool());
2111
context.add(status_table_function_ptr);
2113
cmp_tool= new(std::nothrow)CmpTool(false);
2114
context.add(cmp_tool);
2116
cmp_reset_tool= new(std::nothrow)CmpTool(true);
2117
context.add(cmp_reset_tool);
2119
cmp_mem_tool= new(std::nothrow)CmpmemTool(false);
2120
context.add(cmp_mem_tool);
2122
cmp_mem_reset_tool= new(std::nothrow)CmpmemTool(true);
2123
context.add(cmp_mem_reset_tool);
2125
innodb_trx_tool= new(std::nothrow)InnodbTrxTool("INNODB_TRX");
2126
context.add(innodb_trx_tool);
2128
innodb_locks_tool= new(std::nothrow)InnodbTrxTool("INNODB_LOCKS");
2129
context.add(innodb_locks_tool);
2131
innodb_lock_waits_tool= new(std::nothrow)InnodbTrxTool("INNODB_LOCK_WAITS");
2132
context.add(innodb_lock_waits_tool);
2323
2134
context.add(new(std::nothrow)InnodbInternalTables());
2324
context.add(new(std::nothrow)InnodbReplicationTable());
2326
if (innobase_use_replication_log)
2328
ReplicationLog *replication_logger= new(std::nothrow)ReplicationLog();
2329
context.add(replication_logger);
2330
ReplicationLog::setup(replication_logger);
2333
context.registerVariable(new sys_var_const_string_val("data-home-dir", innobase_data_home_dir));
2334
context.registerVariable(new sys_var_const_string_val("flush-method",
2335
vm.count("flush-method") ? vm["flush-method"].as<string>() : ""));
2336
context.registerVariable(new sys_var_const_string_val("log-group-home-dir", innobase_log_group_home_dir));
2337
context.registerVariable(new sys_var_const_string_val("data-file-path", innobase_data_file_path));
2338
context.registerVariable(new sys_var_const_string_val("version", vm["version"].as<string>()));
2341
context.registerVariable(new sys_var_bool_ptr_readonly("replication_log", &innobase_use_replication_log));
2342
context.registerVariable(new sys_var_bool_ptr_readonly("checksums", &innobase_use_checksums));
2343
context.registerVariable(new sys_var_bool_ptr_readonly("doublewrite", &innobase_use_doublewrite));
2344
context.registerVariable(new sys_var_bool_ptr("file-per-table", &srv_file_per_table));
2345
context.registerVariable(new sys_var_bool_ptr_readonly("file-format-check", &innobase_file_format_check));
2346
context.registerVariable(new sys_var_bool_ptr("adaptive-flushing", &srv_adaptive_flushing));
2347
context.registerVariable(new sys_var_bool_ptr("status-file", &innobase_create_status_file));
2348
context.registerVariable(new sys_var_bool_ptr_readonly("use-sys-malloc", &srv_use_sys_malloc));
2349
context.registerVariable(new sys_var_bool_ptr_readonly("use-native-aio", &srv_use_native_aio));
2351
context.registerVariable(new sys_var_bool_ptr("support-xa", &support_xa));
2352
context.registerVariable(new sys_var_bool_ptr("strict_mode", &strict_mode));
2353
context.registerVariable(new sys_var_constrained_value<uint32_t>("lock_wait_timeout", lock_wait_timeout));
2355
context.registerVariable(new sys_var_constrained_value_readonly<size_t>("additional_mem_pool_size",innobase_additional_mem_pool_size));
2356
context.registerVariable(new sys_var_constrained_value<uint32_t>("autoextend_increment",
2357
innodb_auto_extend_increment,
2358
auto_extend_update));
2359
context.registerVariable(new sys_var_constrained_value<uint32_t>("io_capacity",
2361
io_capacity_update));
2362
context.registerVariable(new sys_var_constrained_value<uint32_t>("purge_batch_size",
2363
innodb_purge_batch_size,
2364
purge_batch_update));
2365
context.registerVariable(new sys_var_constrained_value<uint32_t>("purge_threads",
2366
innodb_n_purge_threads,
2367
purge_threads_update));
2368
context.registerVariable(new sys_var_constrained_value<uint32_t>("fast_shutdown", innobase_fast_shutdown));
2369
context.registerVariable(new sys_var_std_string("file_format",
2370
innobase_file_format_name,
2371
innodb_file_format_name_validate));
2372
context.registerVariable(new sys_var_std_string("change_buffering",
2373
innobase_change_buffering,
2374
innodb_change_buffering_validate));
2375
context.registerVariable(new sys_var_std_string("file_format_max",
2376
innobase_file_format_max,
2377
innodb_file_format_max_validate));
2378
context.registerVariable(new sys_var_constrained_value_readonly<size_t>("buffer_pool_size", innobase_buffer_pool_size));
2379
context.registerVariable(new sys_var_constrained_value_readonly<int64_t>("log_file_size", innobase_log_file_size));
2380
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("flush_log_at_trx_commit",
2381
innodb_flush_log_at_trx_commit));
2382
context.registerVariable(new sys_var_constrained_value_readonly<unsigned int>("max_dirty_pages_pct",
2383
innodb_max_dirty_pages_pct));
2384
context.registerVariable(new sys_var_constrained_value_readonly<uint64_t>("max_purge_lag", innodb_max_purge_lag));
2385
context.registerVariable(new sys_var_constrained_value_readonly<uint64_t>("stats_sample_pages", innodb_stats_sample_pages));
2386
context.registerVariable(new sys_var_bool_ptr("adaptive_hash_index", &btr_search_enabled, innodb_adaptive_hash_index_update));
2388
context.registerVariable(new sys_var_constrained_value<uint32_t>("commit_concurrency",
2389
innobase_commit_concurrency,
2390
innodb_commit_concurrency_validate));
2391
context.registerVariable(new sys_var_constrained_value<uint32_t>("concurrency_tickets",
2392
innodb_concurrency_tickets));
2393
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("read_io_threads", innobase_read_io_threads));
2394
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("write_io_threads", innobase_write_io_threads));
2395
context.registerVariable(new sys_var_constrained_value_readonly<uint64_t>("replication_delay", innodb_replication_delay));
2396
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("force_recovery", innobase_force_recovery));
2397
context.registerVariable(new sys_var_constrained_value_readonly<size_t>("log_buffer_size", innobase_log_buffer_size));
2398
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("log_files_in_group", innobase_log_files_in_group));
2399
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("mirrored_log_groups", innobase_mirrored_log_groups));
2400
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("open_files", innobase_open_files));
2401
context.registerVariable(new sys_var_constrained_value<uint32_t>("old_blocks_pct",
2402
innobase_old_blocks_pct,
2403
innodb_old_blocks_pct_update));
2404
context.registerVariable(new sys_var_uint32_t_ptr("old_blocks_time", &buf_LRU_old_threshold_ms));
2405
context.registerVariable(new sys_var_constrained_value<uint32_t>("sync_spin_loops", innodb_sync_spin_loops, innodb_sync_spin_loops_update));
2406
context.registerVariable(new sys_var_constrained_value<uint32_t>("spin_wait_delay", innodb_spin_wait_delay, innodb_spin_wait_delay_update));
2407
context.registerVariable(new sys_var_constrained_value<uint32_t>("thread_sleep_delay", innodb_thread_sleep_delay, innodb_thread_sleep_delay_update));
2408
context.registerVariable(new sys_var_constrained_value<uint32_t>("thread_concurrency",
2409
innobase_thread_concurrency,
2410
innodb_thread_concurrency_update));
2411
context.registerVariable(new sys_var_constrained_value<uint32_t>("read_ahead_threshold",
2412
innodb_read_ahead_threshold,
2413
innodb_read_ahead_threshold_update));
2414
2136
/* Get the current high water mark format. */
2415
innobase_file_format_max = trx_sys_file_format_max_get();
2416
btr_search_fully_disabled = (!btr_search_enabled);
2137
innobase_file_format_check = (char*) trx_sys_file_format_max_get();
2879
/********************************************************************//**
2880
Get the upper limit of the MySQL integral and floating-point type.
2881
@return maximum allowed value for the field */
2884
innobase_get_int_col_max_value(
2885
/*===========================*/
2886
const Field* field) /*!< in: MySQL field */
2888
uint64_t max_value = 0;
2890
switch(field->key_type()) {
2892
case HA_KEYTYPE_BINARY:
2893
max_value = 0xFFULL;
2896
case HA_KEYTYPE_ULONG_INT:
2897
max_value = 0xFFFFFFFFULL;
2899
case HA_KEYTYPE_LONG_INT:
2900
max_value = 0x7FFFFFFFULL;
2903
case HA_KEYTYPE_ULONGLONG:
2904
max_value = 0xFFFFFFFFFFFFFFFFULL;
2906
case HA_KEYTYPE_LONGLONG:
2907
max_value = 0x7FFFFFFFFFFFFFFFULL;
2909
case HA_KEYTYPE_DOUBLE:
2910
/* We use the maximum as per IEEE754-2008 standard, 2^53 */
2911
max_value = 0x20000000000000ULL;
2920
/*******************************************************************//**
2921
This function checks whether the index column information
2922
is consistent between KEY info from mysql and that from innodb index.
2923
@return TRUE if all column types match. */
2926
innobase_match_index_columns(
2927
/*=========================*/
2928
const KeyInfo* key_info, /*!< in: Index info
2930
const dict_index_t* index_info) /*!< in: Index info
2933
const KeyPartInfo* key_part;
2934
const KeyPartInfo* key_end;
2935
const dict_field_t* innodb_idx_fld;
2936
const dict_field_t* innodb_idx_fld_end;
2938
/* Check whether user defined index column count matches */
2939
if (key_info->key_parts != index_info->n_user_defined_cols) {
2943
key_part = key_info->key_part;
2944
key_end = key_part + key_info->key_parts;
2945
innodb_idx_fld = index_info->fields;
2946
innodb_idx_fld_end = index_info->fields + index_info->n_fields;
2948
/* Check each index column's datatype. We do not check
2949
column name because there exists case that index
2950
column name got modified in mysql but such change does not
2951
propagate to InnoDB.
2952
One hidden assumption here is that the index column sequences
2953
are matched up between those in mysql and Innodb. */
2954
for (; key_part != key_end; ++key_part) {
2957
ulint mtype = innodb_idx_fld->col->mtype;
2959
/* Need to translate to InnoDB column type before
2961
col_type = get_innobase_type_from_mysql_type(&is_unsigned,
2964
/* Ignore Innodb specific system columns. */
2965
while (mtype == DATA_SYS) {
2968
if (innodb_idx_fld >= innodb_idx_fld_end) {
2973
if (col_type != mtype) {
2974
/* Column Type mismatches */
2984
/*******************************************************************//**
2985
This function builds a translation table in INNOBASE_SHARE
2986
structure for fast index location with mysql array number from its
2987
table->key_info structure. This also provides the necessary translation
2988
between the key order in mysql key_info and Innodb ib_table->indexes if
2989
they are not fully matched with each other.
2990
Note we do not have any mutex protecting the translation table
2991
building based on the assumption that there is no concurrent
2992
index creation/drop and DMLs that requires index lookup. All table
2993
handle will be closed before the index creation/drop.
2994
@return TRUE if index translation table built successfully */
2997
innobase_build_index_translation(
2998
/*=============================*/
2999
const Table* table, /*!< in: table in MySQL data
3001
dict_table_t* ib_table, /*!< in: table in Innodb data
3003
INNOBASE_SHARE* share) /*!< in/out: share structure
3004
where index translation table
3005
will be constructed in. */
3007
ulint mysql_num_index;
3009
dict_index_t** index_mapping;
3012
mutex_enter(&dict_sys->mutex);
3014
mysql_num_index = table->getShare()->keys;
3015
ib_num_index = UT_LIST_GET_LEN(ib_table->indexes);
3017
index_mapping = share->idx_trans_tbl.index_mapping;
3019
/* If there exists inconsistency between MySQL and InnoDB dictionary
3020
(metadata) information, the number of index defined in MySQL
3021
could exceed that in InnoDB, do not build index translation
3022
table in such case */
3023
if (UNIV_UNLIKELY(ib_num_index < mysql_num_index)) {
3028
/* If index entry count is non-zero, nothing has
3029
changed since last update, directly return TRUE */
3030
if (share->idx_trans_tbl.index_count) {
3031
/* Index entry count should still match mysql_num_index */
3032
ut_a(share->idx_trans_tbl.index_count == mysql_num_index);
3036
/* The number of index increased, rebuild the mapping table */
3037
if (mysql_num_index > share->idx_trans_tbl.array_size) {
3038
index_mapping = (dict_index_t**) realloc(index_mapping,
3040
sizeof(*index_mapping));
3042
if (!index_mapping) {
3043
/* Report an error if index_mapping continues to be
3044
NULL and mysql_num_index is a non-zero value */
3045
errmsg_printf(error::ERROR, "InnoDB: fail to allocate memory for "
3046
"index translation table. Number of Index:%lu, array size:%lu",
3048
share->idx_trans_tbl.array_size);
3053
share->idx_trans_tbl.array_size = mysql_num_index;
3056
/* For each index in the mysql key_info array, fetch its
3057
corresponding InnoDB index pointer into index_mapping
3059
for (ulint count = 0; count < mysql_num_index; count++) {
3061
/* Fetch index pointers into index_mapping according to mysql
3063
index_mapping[count] = dict_table_get_index_on_name(
3064
ib_table, table->key_info[count].name);
3066
if (!index_mapping[count]) {
3067
errmsg_printf(error::ERROR, "Cannot find index %s in InnoDB index dictionary.",
3068
table->key_info[count].name);
3073
/* Double check fetched index has the same
3074
column info as those in mysql key_info. */
3075
if (!innobase_match_index_columns(&table->key_info[count], index_mapping[count])) {
3076
errmsg_printf(error::ERROR, "Found index %s whose column info does not match that of MySQL.",
3077
table->key_info[count].name);
3083
/* Successfully built the translation table */
3084
share->idx_trans_tbl.index_count = mysql_num_index;
3088
/* Build translation table failed. */
3089
free(index_mapping);
3091
share->idx_trans_tbl.array_size = 0;
3092
share->idx_trans_tbl.index_count = 0;
3093
index_mapping = NULL;
3096
share->idx_trans_tbl.index_mapping = index_mapping;
3098
mutex_exit(&dict_sys->mutex);
3103
/*******************************************************************//**
3104
This function uses index translation table to quickly locate the
3105
requested index structure.
3106
Note we do not have mutex protection for the index translatoin table
3107
access, it is based on the assumption that there is no concurrent
3108
translation table rebuild (fter create/drop index) and DMLs that
3109
require index lookup.
3110
@return dict_index_t structure for requested index. NULL if
3111
fail to locate the index structure. */
3114
innobase_index_lookup(
3115
/*==================*/
3116
INNOBASE_SHARE* share, /*!< in: share structure for index
3117
translation table. */
3118
uint keynr) /*!< in: index number for the requested
3121
if (!share->idx_trans_tbl.index_mapping
3122
|| keynr >= share->idx_trans_tbl.index_count) {
3126
return(share->idx_trans_tbl.index_mapping[keynr]);
2616
/*****************************************************************//**
2617
Normalizes a table name string. A normalized name consists of the
2618
database name catenated to '/' and table name. An example:
2619
test/mytable. On Windows normalization puts both the database name and the
2620
table name always to lower case. */
2623
normalize_table_name(
2624
/*=================*/
2625
char* norm_name, /*!< out: normalized name as a
2626
null-terminated string */
2627
const char* name) /*!< in: table name string */
2629
const char* name_ptr;
2633
/* Scan name from the end */
2635
ptr = strchr(name, '\0')-1;
2637
while (ptr >= name && *ptr != '\\' && *ptr != '/') {
2647
while (ptr >= name && *ptr != '\\' && *ptr != '/') {
2653
memcpy(norm_name, db_ptr, strlen(name) + 1 - (db_ptr - name));
2655
norm_name[name_ptr - db_ptr - 1] = '/';
2658
innobase_casedn_str(norm_name);
3129
2662
/********************************************************************//**
3130
2663
Set the autoinc column max value. This should only be called once from
3131
ha_innobase::open(). Therefore there's no need for a covering lock. */
2664
ha_innobase::open(). Therefore there's no need for a covering lock.
2665
@return DB_SUCCESS or error code */
3134
2668
ha_innobase::innobase_initialize_autoinc()
3135
2669
/*======================================*/
2671
dict_index_t* index;
3137
2672
uint64_t auto_inc;
3138
const Field* field = getTable()->found_next_number_field;
3140
if (field != NULL) {
3141
auto_inc = innobase_get_int_col_max_value(field);
3143
/* We have no idea what's been passed in to us as the
3144
autoinc column. We set it to the 0, effectively disabling
3145
updates to the table. */
2673
const char* col_name;
2676
col_name = table->found_next_number_field->field_name;
2677
index = innobase_get_index(table->getShare()->next_number_index);
2679
/* Execute SELECT MAX(col_name) FROM TABLE; */
2680
error = row_search_max_autoinc(index, col_name, &auto_inc);
2685
/* At the this stage we don't know the increment
2686
or the offset, so use default inrement of 1. */
2690
case DB_RECORD_NOT_FOUND:
3148
2691
ut_print_timestamp(stderr);
3149
errmsg_printf(error::ERROR, "InnoDB: Unable to determine the AUTOINC column name");
3152
if (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE) {
3153
/* If the recovery level is set so high that writes
3154
are disabled we force the AUTOINC counter to 0
3155
value effectively disabling writes to the table.
3156
Secondly, we avoid reading the table in case the read
3157
results in failure due to a corrupted table/index.
3159
We will not return an error to the client, so that the
3160
tables can be dumped with minimal hassle. If an error
3161
were returned in this case, the first attempt to read
3162
the table would fail and subsequent SELECTs would succeed. */
3164
} else if (field == NULL) {
3165
/* This is a far more serious error, best to avoid
3166
opening the table and return failure. */
3167
my_error(ER_AUTOINC_READ_FAILED, MYF(0));
3169
dict_index_t* index;
3170
const char* col_name;
3171
uint64_t read_auto_inc;
3174
update_session(getTable()->in_use);
3175
col_name = field->field_name;
3177
ut_a(prebuilt->trx == session_to_trx(user_session));
3179
index = innobase_get_index(getTable()->getShare()->next_number_index);
3181
/* Execute SELECT MAX(col_name) FROM TABLE; */
3182
err = row_search_max_autoinc(index, col_name, &read_auto_inc);
3186
uint64_t col_max_value;
3188
col_max_value = innobase_get_int_col_max_value(field);
3190
/* At the this stage we do not know the increment
3191
nor the offset, so use a default increment of 1. */
3193
auto_inc = innobase_next_autoinc(read_auto_inc, 1, 1, col_max_value);
3197
case DB_RECORD_NOT_FOUND:
3198
ut_print_timestamp(stderr);
3199
errmsg_printf(error::ERROR, "InnoDB: MySQL and InnoDB data dictionaries are out of sync.\n"
3200
"InnoDB: Unable to find the AUTOINC column %s in the InnoDB table %s.\n"
3201
"InnoDB: We set the next AUTOINC column value to 0,\n"
3202
"InnoDB: in effect disabling the AUTOINC next value generation.\n"
3203
"InnoDB: You can either set the next AUTOINC value explicitly using ALTER TABLE\n"
3204
"InnoDB: or fix the data dictionary by recreating the table.\n",
3205
col_name, index->table->name);
3207
/* This will disable the AUTOINC generation. */
3210
/* We want the open to succeed, so that the user can
3211
take corrective action. ie. reads should succeed but
3212
updates should fail. */
3216
/* row_search_max_autoinc() should only return
3217
one of DB_SUCCESS or DB_RECORD_NOT_FOUND. */
2692
fprintf(stderr, " InnoDB: MySQL and InnoDB data "
2693
"dictionaries are out of sync.\n"
2694
"InnoDB: Unable to find the AUTOINC column %s in the "
2695
"InnoDB table %s.\n"
2696
"InnoDB: We set the next AUTOINC column value to the "
2697
"maximum possible value,\n"
2698
"InnoDB: in effect disabling the AUTOINC next value "
2700
"InnoDB: You can either set the next AUTOINC value "
2701
"explicitly using ALTER TABLE\n"
2702
"InnoDB: or fix the data dictionary by recreating "
2704
col_name, index->table->name);
2706
auto_inc = 0xFFFFFFFFFFFFFFFFULL;
3222
2713
dict_table_autoinc_initialize(prebuilt->table, auto_inc);
3225
2718
/*****************************************************************//**
9093
8076
/************************************************************//**
8077
Validate the file format check value, is it one of "on" or "off",
8078
as a side effect it sets the srv_check_file_format_at_startup variable.
8079
@return true if config value one of "on" or "off" */
8082
innobase_file_format_check_on_off(
8083
/*==============================*/
8084
const char* format_check) /*!< in: parameter value */
8088
if (!innobase_strcasecmp(format_check, "off")) {
8090
/* Set the value to disable checking. */
8091
srv_check_file_format_at_startup = DICT_TF_FORMAT_MAX + 1;
8093
} else if (!innobase_strcasecmp(format_check, "on")) {
8095
/* Set the value to the lowest supported format. */
8096
srv_check_file_format_at_startup = DICT_TF_FORMAT_51;
8104
/************************************************************//**
9094
8105
Validate the file format check config parameters, as a side effect it
9095
sets the srv_max_file_format_at_startup variable.
9096
@return the format_id if valid config value, otherwise, return -1 */
8106
sets the srv_check_file_format_at_startup variable.
8107
@return true if valid config value */
9099
innobase_file_format_validate_and_set(
8110
innobase_file_format_check_validate(
9100
8111
/*================================*/
9101
const char* format_max) /*!< in: parameter value */
8112
const char* format_check) /*!< in: parameter value */
9103
8114
uint format_id;
9105
format_id = innobase_file_format_name_lookup(format_max);
8117
format_id = innobase_file_format_name_lookup(format_check);
9107
8119
if (format_id < DICT_TF_FORMAT_MAX + 1) {
9108
srv_max_file_format_at_startup = format_id;
9109
return((int) format_id);
9117
static void init_options(drizzled::module::option_context &context)
9119
context("disable-checksums",
9120
"Disable InnoDB checksums validation.");
9121
context("data-home-dir",
9122
po::value<string>(),
9123
"The common part for InnoDB table spaces.");
9124
context("disable-doublewrite",
9125
"Disable InnoDB doublewrite buffer.");
9126
context("io-capacity",
9127
po::value<io_capacity_constraint>(&innodb_io_capacity)->default_value(200),
9128
"Number of IOPs the server can do. Tunes the background IO rate");
9129
context("fast-shutdown",
9130
po::value<trinary_constraint>(&innobase_fast_shutdown)->default_value(1),
9131
"Speeds up the shutdown process of the InnoDB storage engine. Possible values are 0, 1 (faster) or 2 (fastest - crash-like).");
9132
context("purge-batch-size",
9133
po::value<purge_batch_constraint>(&innodb_purge_batch_size)->default_value(20),
9134
"Number of UNDO logs to purge in one batch from the history list. "
9136
context("purge-threads",
9137
po::value<purge_threads_constraint>(&innodb_n_purge_threads)->default_value(0),
9138
"Purge threads can be either 0 or 1. Defalut is 0.");
9139
context("file-per-table",
9140
po::value<bool>(&srv_file_per_table)->default_value(false)->zero_tokens(),
9141
"Stores each InnoDB table to an .ibd file in the database dir.");
9142
context("file-format-max",
9143
po::value<string>(&innobase_file_format_max)->default_value("Antelope"),
9144
"The highest file format in the tablespace.");
9145
context("file-format-check",
9146
po::value<bool>(&innobase_file_format_check)->default_value(true)->zero_tokens(),
9147
"Whether to perform system file format check.");
9148
context("file-format",
9149
po::value<string>(&innobase_file_format_name)->default_value("Antelope"),
9150
"File format to use for new tables in .ibd files.");
9151
context("flush-log-at-trx-commit",
9152
po::value<trinary_constraint>(&innodb_flush_log_at_trx_commit)->default_value(1),
9153
"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).");
9154
context("flush-method",
9155
po::value<string>(),
9156
"With which method to flush data.");
9157
context("log-group-home-dir",
9158
po::value<string>(),
9159
"Path to InnoDB log files.");
9160
context("max-dirty-pages-pct",
9161
po::value<max_dirty_pages_constraint>(&innodb_max_dirty_pages_pct)->default_value(75),
9162
"Percentage of dirty pages allowed in bufferpool.");
9163
context("disable-adaptive-flushing",
9164
"Do not attempt flushing dirty pages to avoid IO bursts at checkpoints.");
9165
context("max-purge-lag",
9166
po::value<uint64_constraint>(&innodb_max_purge_lag)->default_value(0),
9167
"Desired maximum length of the purge queue (0 = no limit)");
9168
context("status-file",
9169
po::value<bool>(&innobase_create_status_file)->default_value(false)->zero_tokens(),
9170
"Enable SHOW INNODB STATUS output in the innodb_status.<pid> file");
9171
context("disable-stats-on-metadata",
9172
"Disable statistics gathering for metadata commands such as SHOW TABLE STATUS (on by default)");
9173
context("stats-sample-pages",
9174
po::value<uint64_nonzero_constraint>(&innodb_stats_sample_pages)->default_value(8),
9175
"The number of index pages to sample when calculating statistics (default 8)");
9176
context("disable-adaptive-hash-index",
9177
"Enable InnoDB adaptive hash index (enabled by default)");
9178
context("replication-delay",
9179
po::value<uint64_constraint>(&innodb_replication_delay)->default_value(0),
9180
"Replication thread delay (ms) on the slave server if innodb_thread_concurrency is reached (0 by default)");
9181
context("additional-mem-pool-size",
9182
po::value<additional_mem_pool_constraint>(&innobase_additional_mem_pool_size)->default_value(8*1024*1024L),
9183
"Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.");
9184
context("autoextend-increment",
9185
po::value<autoextend_constraint>(&innodb_auto_extend_increment)->default_value(64L),
9186
"Data file autoextend increment in megabytes");
9187
context("buffer-pool-size",
9188
po::value<buffer_pool_constraint>(&innobase_buffer_pool_size)->default_value(128*1024*1024L),
9189
"The size of the memory buffer InnoDB uses to cache data and indexes of its tables.");
9190
context("buffer-pool-instances",
9191
po::value<buffer_pool_instances_constraint>(&innobase_buffer_pool_instances)->default_value(1),
9192
"Number of buffer pool instances, set to higher value on high-end machines to increase scalability");
9194
context("commit-concurrency",
9195
po::value<concurrency_constraint>(&innobase_commit_concurrency)->default_value(0),
9196
"Helps in performance tuning in heavily concurrent environments.");
9197
context("concurrency-tickets",
9198
po::value<uint32_nonzero_constraint>(&innodb_concurrency_tickets)->default_value(500L),
9199
"Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got the ticket");
9200
context("read-io-threads",
9201
po::value<io_threads_constraint>(&innobase_read_io_threads)->default_value(4),
9202
"Number of background read I/O threads in InnoDB.");
9203
context("write-io-threads",
9204
po::value<io_threads_constraint>(&innobase_write_io_threads)->default_value(4),
9205
"Number of background write I/O threads in InnoDB.");
9206
context("force-recovery",
9207
po::value<force_recovery_constraint>(&innobase_force_recovery)->default_value(0),
9208
"Helps to save your data in case the disk image of the database becomes corrupt.");
9209
context("log-buffer-size",
9210
po::value<log_buffer_constraint>(&innobase_log_buffer_size)->default_value(8*1024*1024L),
9211
"The size of the buffer which InnoDB uses to write log to the log files on disk.");
9212
context("log-file-size",
9213
po::value<log_file_constraint>(&innobase_log_file_size)->default_value(20*1024*1024L),
9214
"The size of the buffer which InnoDB uses to write log to the log files on disk.");
9215
context("log-files-in-group",
9216
po::value<log_files_in_group_constraint>(&innobase_log_files_in_group)->default_value(2),
9217
"Number of log files in the log group. InnoDB writes to the files in a circular fashion.");
9218
context("mirrored-log-groups",
9219
po::value<mirrored_log_groups_constraint>(&innobase_mirrored_log_groups)->default_value(1),
9220
"Number of identical copies of log groups we keep for the database. Currently this should be set to 1.");
9221
context("open-files",
9222
po::value<open_files_constraint>(&innobase_open_files)->default_value(300L),
9223
"How many files at the maximum InnoDB keeps open at the same time.");
9224
context("sync-spin-loops",
9225
po::value<uint32_constraint>(&innodb_sync_spin_loops)->default_value(30L),
9226
"Count of spin-loop rounds in InnoDB mutexes (30 by default)");
9227
context("spin-wait-delay",
9228
po::value<uint32_constraint>(&innodb_spin_wait_delay)->default_value(6L),
9229
"Maximum delay between polling for a spin lock (6 by default)");
9230
context("thread-concurrency",
9231
po::value<concurrency_constraint>(&innobase_thread_concurrency)->default_value(0),
9232
"Helps in performance tuning in heavily concurrent environments. Sets the maximum number of threads allowed inside InnoDB. Value 0 will disable the thread throttling.");
9233
context("thread-sleep-delay",
9234
po::value<uint32_constraint>(&innodb_thread_sleep_delay)->default_value(10000L),
9235
"Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0 disable a sleep");
9236
context("data-file-path",
9237
po::value<string>(),
9238
"Path to individual files and their sizes.");
9240
po::value<string>()->default_value(INNODB_VERSION_STR),
9242
context("use-internal-malloc",
9243
"Use InnoDB's internal memory allocator instal of the OS memory allocator.");
9244
context("disable-native-aio",
9245
_("Do not use Native AIO library for IO, even if available"));
9246
context("change-buffering",
9247
po::value<string>(&innobase_change_buffering),
9248
"Buffer changes to reduce random access: OFF, ON, inserting, deleting, changing, or purging.");
9249
context("read-ahead-threshold",
9250
po::value<read_ahead_threshold_constraint>(&innodb_read_ahead_threshold)->default_value(56),
9251
"Number of pages that must be accessed sequentially for InnoDB to trigger a readahead.");
9252
context("disable-xa",
9253
"Disable InnoDB support for the XA two-phase commit");
9254
context("disable-table-locks",
9255
"Disable InnoDB locking in LOCK TABLES");
9256
context("strict-mode",
9257
po::value<bool>(&strict_mode)->default_value(false)->zero_tokens(),
9258
"Use strict mode when evaluating create options.");
9259
context("replication-log",
9260
po::value<bool>(&innobase_use_replication_log)->default_value(false),
9261
_("Enable internal replication log."));
9262
context("lock-wait-timeout",
9263
po::value<lock_wait_constraint>(&lock_wait_timeout)->default_value(50),
9264
_("Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back. Values above 100000000 disable the timeout."));
9265
context("old-blocks-pct",
9266
po::value<old_blocks_constraint>(&innobase_old_blocks_pct)->default_value(100 * 3 / 8),
9267
_("Percentage of the buffer pool to reserve for 'old' blocks."));
9268
context("old-blocks-time",
9269
po::value<uint32_t>(&buf_LRU_old_threshold_ms)->default_value(0),
9270
_("ove blocks to the 'new' end of the buffer pool if the first access"
9271
" was at least this many milliseconds ago."
9272
" The timeout is disabled if 0 (the default)."));
8120
srv_check_file_format_at_startup = format_id;
8128
/*************************************************************//**
8129
Check if it is a valid file format. This function is registered as
8130
a callback with MySQL.
8131
@return 0 for valid file format */
8134
innodb_file_format_name_validate(
8135
/*=============================*/
8136
Session* , /*!< in: thread handle */
8137
drizzle_sys_var* , /*!< in: pointer to system
8139
void* save, /*!< out: immediate result
8140
for update function */
8141
drizzle_value* value) /*!< in: incoming string */
8143
const char* file_format_input;
8144
char buff[STRING_BUFFER_USUAL_SIZE];
8145
int len = sizeof(buff);
8148
ut_a(value != NULL);
8150
file_format_input = value->val_str(value, buff, &len);
8152
if (file_format_input != NULL) {
8155
format_id = innobase_file_format_name_lookup(
8158
if (format_id <= DICT_TF_FORMAT_MAX) {
8160
*static_cast<const char**>(save) = file_format_input;
8165
*static_cast<const char**>(save) = NULL;
8169
/****************************************************************//**
8170
Update the system variable innodb_file_format using the "saved"
8171
value. This function is registered as a callback with MySQL. */
8174
innodb_file_format_name_update(
8175
/*===========================*/
8176
Session* , /*!< in: thread handle */
8177
drizzle_sys_var* , /*!< in: pointer to
8179
void* var_ptr, /*!< out: where the
8180
formal string goes */
8181
const void* save) /*!< in: immediate result
8182
from check function */
8184
const char* format_name;
8186
ut_a(var_ptr != NULL);
8189
format_name = *static_cast<const char*const*>(save);
8194
format_id = innobase_file_format_name_lookup(format_name);
8196
if (format_id <= DICT_TF_FORMAT_MAX) {
8197
srv_file_format = format_id;
8201
*static_cast<const char**>(var_ptr)
8202
= trx_sys_file_format_id_to_name(srv_file_format);
8205
/*************************************************************//**
8206
Check if valid argument to innodb_file_format_check. This
8207
function is registered as a callback with MySQL.
8208
@return 0 for valid file format */
8211
innodb_file_format_check_validate(
8212
/*==============================*/
8213
Session* , /*!< in: thread handle */
8214
drizzle_sys_var* , /*!< in: pointer to system
8216
void* save, /*!< out: immediate result
8217
for update function */
8218
drizzle_value* value) /*!< in: incoming string */
8220
const char* file_format_input;
8221
char buff[STRING_BUFFER_USUAL_SIZE];
8222
int len = sizeof(buff);
8225
ut_a(value != NULL);
8227
file_format_input = value->val_str(value, buff, &len);
8229
if (file_format_input != NULL) {
8231
/* Check if user set on/off, we want to print a suitable
8232
message if they did so. */
8234
if (innobase_file_format_check_on_off(file_format_input)) {
8235
errmsg_printf(ERRMSG_LVL_WARN,
8236
"InnoDB: invalid innodb_file_format_check "
8237
"value; on/off can only be set at startup or "
8238
"in the configuration file");
8239
} else if (innobase_file_format_check_validate(
8240
file_format_input)) {
8242
*static_cast<const char**>(save) = file_format_input;
8247
errmsg_printf(ERRMSG_LVL_WARN,
8248
"InnoDB: invalid innodb_file_format_check "
8249
"value; can be any format up to %s "
8250
"or its equivalent numeric id",
8251
trx_sys_file_format_id_to_name(
8252
DICT_TF_FORMAT_MAX));
8256
*static_cast<const char**>(save) = NULL;
8260
/****************************************************************//**
8261
Update the system variable innodb_file_format_check using the "saved"
8262
value. This function is registered as a callback with MySQL. */
8265
innodb_file_format_check_update(
8266
/*============================*/
8267
Session* session, /*!< in: thread handle */
8268
drizzle_sys_var* , /*!< in: pointer to
8270
void* var_ptr, /*!< out: where the
8271
formal string goes */
8272
const void* save) /*!< in: immediate result
8273
from check function */
8275
const char* format_name_in;
8276
const char** format_name_out;
8280
ut_a(var_ptr != NULL);
8282
format_name_in = *static_cast<const char*const*>(save);
8284
if (!format_name_in) {
8289
format_id = innobase_file_format_name_lookup(format_name_in);
8291
if (format_id > DICT_TF_FORMAT_MAX) {
8292
/* DEFAULT is "on", which is invalid at runtime. */
8293
push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
8295
"Ignoring SET innodb_file_format=%s",
8300
format_name_out = static_cast<const char**>(var_ptr);
8302
/* Update the max format id in the system tablespace. */
8303
if (trx_sys_file_format_max_set(format_id, format_name_out)) {
8304
ut_print_timestamp(stderr);
8306
" [Info] InnoDB: the file format in the system "
8307
"tablespace is now set to %s.\n", *format_name_out);
8311
/****************************************************************//**
8312
Update the system variable innodb_adaptive_hash_index using the "saved"
8313
value. This function is registered as a callback with MySQL. */
8316
innodb_adaptive_hash_index_update(
8317
/*==============================*/
8318
Session* , /*!< in: thread handle */
8319
drizzle_sys_var* , /*!< in: pointer to
8321
void* , /*!< out: where the
8322
formal string goes */
8323
const void* save) /*!< in: immediate result
8324
from check function */
8326
if (*(bool*) save) {
8327
btr_search_enable();
8329
btr_search_disable();
8333
/*************************************************************//**
8334
Check if it is a valid value of innodb_change_buffering. This function is
8335
registered as a callback with MySQL.
8336
@return 0 for valid innodb_change_buffering */
8339
innodb_change_buffering_validate(
8340
/*=============================*/
8341
Session* , /*!< in: thread handle */
8342
drizzle_sys_var* , /*!< in: pointer to system
8344
void* save, /*!< out: immediate result
8345
for update function */
8346
drizzle_value* value) /*!< in: incoming string */
8348
const char* change_buffering_input;
8349
char buff[STRING_BUFFER_USUAL_SIZE];
8350
int len = sizeof(buff);
8353
ut_a(value != NULL);
8355
change_buffering_input = value->val_str(value, buff, &len);
8357
if (change_buffering_input != NULL) {
8360
for (use = 0; use < UT_ARR_SIZE(innobase_change_buffering_values);
8362
if (!innobase_strcasecmp(
8363
change_buffering_input,
8364
innobase_change_buffering_values[use])) {
8365
*(ibuf_use_t*) save = (ibuf_use_t) use;
8374
/****************************************************************//**
8375
Update the system variable innodb_change_buffering using the "saved"
8376
value. This function is registered as a callback with MySQL. */
8379
innodb_change_buffering_update(
8380
/*===========================*/
8381
Session* , /*!< in: thread handle */
8382
drizzle_sys_var* , /*!< in: pointer to
8384
void* var_ptr, /*!< out: where the
8385
formal string goes */
8386
const void* save) /*!< in: immediate result
8387
from check function */
8389
ut_a(var_ptr != NULL);
8391
ut_a((*(ibuf_use_t*) save) < IBUF_USE_COUNT);
8393
ibuf_use = *(const ibuf_use_t*) save;
8395
*(const char**) var_ptr = innobase_change_buffering_values[ibuf_use];
8398
/* plugin options */
8399
static DRIZZLE_SYSVAR_BOOL(checksums, innobase_use_checksums,
8400
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8401
"Enable InnoDB checksums validation (enabled by default). "
8402
"Disable with --skip-innodb-checksums.",
8405
static DRIZZLE_SYSVAR_STR(data_home_dir, innobase_data_home_dir,
8406
PLUGIN_VAR_READONLY,
8407
"The common part for InnoDB table spaces.",
8410
static DRIZZLE_SYSVAR_BOOL(doublewrite, innobase_use_doublewrite,
8411
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8412
"Enable InnoDB doublewrite buffer (enabled by default). "
8413
"Disable with --skip-innodb-doublewrite.",
8416
static DRIZZLE_SYSVAR_ULONG(io_capacity, srv_io_capacity,
8417
PLUGIN_VAR_RQCMDARG,
8418
"Number of IOPs the server can do. Tunes the background IO rate",
8419
NULL, NULL, 200, 100, ~0L, 0);
8421
static DRIZZLE_SYSVAR_ULONG(fast_shutdown, innobase_fast_shutdown,
8422
PLUGIN_VAR_OPCMDARG,
8423
"Speeds up the shutdown process of the InnoDB storage engine. Possible "
8424
"values are 0, 1 (faster)"
8425
" or 2 (fastest - crash-like)"
8427
NULL, NULL, 1, 0, 2, 0);
8429
static DRIZZLE_SYSVAR_BOOL(file_per_table, srv_file_per_table,
8430
PLUGIN_VAR_NOCMDARG,
8431
"Stores each InnoDB table to an .ibd file in the database dir.",
8434
static DRIZZLE_SYSVAR_STR(file_format, innobase_file_format_name,
8435
PLUGIN_VAR_RQCMDARG,
8436
"File format to use for new tables in .ibd files.",
8437
innodb_file_format_name_validate,
8438
innodb_file_format_name_update, "Antelope");
8440
static DRIZZLE_SYSVAR_STR(file_format_check, innobase_file_format_check,
8441
PLUGIN_VAR_OPCMDARG,
8442
"The highest file format in the tablespace.",
8443
innodb_file_format_check_validate,
8444
innodb_file_format_check_update,
8447
static DRIZZLE_SYSVAR_ULONG(flush_log_at_trx_commit, srv_flush_log_at_trx_commit,
8448
PLUGIN_VAR_OPCMDARG,
8449
"Set to 0 (write and flush once per second),"
8450
" 1 (write and flush at each commit)"
8451
" or 2 (write at commit, flush once per second).",
8452
NULL, NULL, 1, 0, 2, 0);
8454
static DRIZZLE_SYSVAR_STR(flush_method, innobase_unix_file_flush_method,
8455
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8456
"With which method to flush data.", NULL, NULL, NULL);
8458
#ifdef UNIV_LOG_ARCHIVE
8459
static DRIZZLE_SYSVAR_STR(log_arch_dir, innobase_log_arch_dir,
8460
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8461
"Where full logs should be archived.", NULL, NULL, NULL);
8463
static DRIZZLE_SYSVAR_BOOL(log_archive, innobase_log_archive,
8464
PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
8465
"Set to 1 if you want to have logs archived.", NULL, NULL, FALSE);
8466
#endif /* UNIV_LOG_ARCHIVE */
8468
static DRIZZLE_SYSVAR_STR(log_group_home_dir, innobase_log_group_home_dir,
8469
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8470
"Path to InnoDB log files.", NULL, NULL, NULL);
8472
static DRIZZLE_SYSVAR_ULONG(max_dirty_pages_pct, srv_max_buf_pool_modified_pct,
8473
PLUGIN_VAR_RQCMDARG,
8474
"Percentage of dirty pages allowed in bufferpool.",
8475
NULL, NULL, 75, 0, 99, 0);
8477
static DRIZZLE_SYSVAR_BOOL(adaptive_flushing, srv_adaptive_flushing,
8478
PLUGIN_VAR_NOCMDARG,
8479
"Attempt flushing dirty pages to avoid IO bursts at checkpoints.",
8482
static DRIZZLE_SYSVAR_ULONG(max_purge_lag, srv_max_purge_lag,
8483
PLUGIN_VAR_RQCMDARG,
8484
"Desired maximum length of the purge queue (0 = no limit)",
8485
NULL, NULL, 0, 0, ~0L, 0);
8487
static DRIZZLE_SYSVAR_BOOL(status_file, innobase_create_status_file,
8488
PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_NOSYSVAR,
8489
"Enable SHOW INNODB STATUS output in the innodb_status.<pid> file",
8492
static DRIZZLE_SYSVAR_BOOL(stats_on_metadata, innobase_stats_on_metadata,
8493
PLUGIN_VAR_OPCMDARG,
8494
"Enable statistics gathering for metadata commands such as SHOW TABLE STATUS (on by default)",
8497
static DRIZZLE_SYSVAR_ULONGLONG(stats_sample_pages, srv_stats_sample_pages,
8498
PLUGIN_VAR_RQCMDARG,
8499
"The number of index pages to sample when calculating statistics (default 8)",
8500
NULL, NULL, 8, 1, ~0ULL, 0);
8502
static DRIZZLE_SYSVAR_BOOL(adaptive_hash_index, btr_search_enabled,
8503
PLUGIN_VAR_OPCMDARG,
8504
"Enable InnoDB adaptive hash index (enabled by default). "
8505
"Disable with --skip-innodb-adaptive-hash-index.",
8506
NULL, innodb_adaptive_hash_index_update, TRUE);
8508
static DRIZZLE_SYSVAR_ULONG(replication_delay, srv_replication_delay,
8509
PLUGIN_VAR_RQCMDARG,
8510
"Replication thread delay (ms) on the slave server if "
8511
"innodb_thread_concurrency is reached (0 by default)",
8512
NULL, NULL, 0, 0, ~0UL, 0);
8514
static DRIZZLE_SYSVAR_LONG(additional_mem_pool_size, innobase_additional_mem_pool_size,
8515
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8516
"Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.",
8517
NULL, NULL, 8*1024*1024L, 512*1024L, LONG_MAX, 1024);
8519
static DRIZZLE_SYSVAR_UINT(autoextend_increment, srv_auto_extend_increment,
8520
PLUGIN_VAR_RQCMDARG,
8521
"Data file autoextend increment in megabytes",
8522
NULL, NULL, 8L, 1L, 1000L, 0);
8524
static DRIZZLE_SYSVAR_LONGLONG(buffer_pool_size, innobase_buffer_pool_size,
8525
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8526
"The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",
8527
NULL, NULL, 128*1024*1024L, 5*1024*1024L, INT64_MAX, 1024*1024L);
8529
static DRIZZLE_SYSVAR_ULONG(commit_concurrency, innobase_commit_concurrency,
8530
PLUGIN_VAR_RQCMDARG,
8531
"Helps in performance tuning in heavily concurrent environments.",
8532
innobase_commit_concurrency_validate, NULL, 0, 0, 1000, 0);
8534
static DRIZZLE_SYSVAR_ULONG(concurrency_tickets, srv_n_free_tickets_to_enter,
8535
PLUGIN_VAR_RQCMDARG,
8536
"Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got the ticket",
8537
NULL, NULL, 500L, 1L, ~0L, 0);
8539
static DRIZZLE_SYSVAR_LONG(file_io_threads, innobase_file_io_threads,
8540
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8541
"Number of file I/O threads in InnoDB.",
8542
NULL, NULL, 4, 4, 64, 0);
8544
static DRIZZLE_SYSVAR_ULONG(read_io_threads, innobase_read_io_threads,
8545
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8546
"Number of background read I/O threads in InnoDB.",
8547
NULL, NULL, 4, 1, 64, 0);
8549
static DRIZZLE_SYSVAR_ULONG(write_io_threads, innobase_write_io_threads,
8550
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8551
"Number of background write I/O threads in InnoDB.",
8552
NULL, NULL, 4, 1, 64, 0);
8554
static DRIZZLE_SYSVAR_LONG(force_recovery, innobase_force_recovery,
8555
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8556
"Helps to save your data in case the disk image of the database becomes corrupt.",
8557
NULL, NULL, 0, 0, 6, 0);
8559
static DRIZZLE_SYSVAR_LONG(log_buffer_size, innobase_log_buffer_size,
8560
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8561
"The size of the buffer which InnoDB uses to write log to the log files on disk.",
8562
NULL, NULL, 8*1024*1024L, 256*1024L, LONG_MAX, 1024);
8564
static DRIZZLE_SYSVAR_LONGLONG(log_file_size, innobase_log_file_size,
8565
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8566
"Size of each log file in a log group.",
8567
NULL, NULL, 20*1024*1024L, 1*1024*1024L, INT64_MAX, 1024*1024L);
8569
static DRIZZLE_SYSVAR_LONG(log_files_in_group, innobase_log_files_in_group,
8570
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8571
"Number of log files in the log group. InnoDB writes to the files in a circular fashion. Value 3 is recommended here.",
8572
NULL, NULL, 2, 2, 100, 0);
8574
static DRIZZLE_SYSVAR_LONG(mirrored_log_groups, innobase_mirrored_log_groups,
8575
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8576
"Number of identical copies of log groups we keep for the database. Currently this should be set to 1.",
8577
NULL, NULL, 1, 1, 10, 0);
8579
static DRIZZLE_SYSVAR_LONG(open_files, innobase_open_files,
8580
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8581
"How many files at the maximum InnoDB keeps open at the same time.",
8582
NULL, NULL, 300L, 10L, LONG_MAX, 0);
8584
static DRIZZLE_SYSVAR_ULONG(sync_spin_loops, srv_n_spin_wait_rounds,
8585
PLUGIN_VAR_RQCMDARG,
8586
"Count of spin-loop rounds in InnoDB mutexes (30 by default)",
8587
NULL, NULL, 30L, 0L, ~0L, 0);
8589
static DRIZZLE_SYSVAR_ULONG(spin_wait_delay, srv_spin_wait_delay,
8590
PLUGIN_VAR_OPCMDARG,
8591
"Maximum delay between polling for a spin lock (6 by default)",
8592
NULL, NULL, 6L, 0L, ~0L, 0);
8594
static DRIZZLE_SYSVAR_ULONG(thread_concurrency, srv_thread_concurrency,
8595
PLUGIN_VAR_RQCMDARG,
8596
"Helps in performance tuning in heavily concurrent environments. Sets the maximum number of threads allowed inside InnoDB. Value 0 will disable the thread throttling.",
8597
NULL, NULL, 0, 0, 1000, 0);
8599
static DRIZZLE_SYSVAR_ULONG(thread_sleep_delay, srv_thread_sleep_delay,
8600
PLUGIN_VAR_RQCMDARG,
8601
"Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0 disable a sleep",
8602
NULL, NULL, 10000L, 0L, ~0L, 0);
8604
static DRIZZLE_SYSVAR_STR(data_file_path, innobase_data_file_path,
8605
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8606
"Path to individual files and their sizes.",
8609
static DRIZZLE_SYSVAR_STR(version, innodb_version_str,
8610
PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_READONLY,
8611
"InnoDB version", NULL, NULL, INNODB_VERSION_STR);
8613
static DRIZZLE_SYSVAR_BOOL(use_sys_malloc, srv_use_sys_malloc,
8614
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8615
"Use OS memory allocator instead of InnoDB's internal memory allocator",
8618
static DRIZZLE_SYSVAR_STR(change_buffering, innobase_change_buffering,
8619
PLUGIN_VAR_RQCMDARG,
8620
"Buffer changes to reduce random access: "
8621
"OFF, ON, inserting, deleting, changing, or purging.",
8622
innodb_change_buffering_validate,
8623
innodb_change_buffering_update, NULL);
8625
static DRIZZLE_SYSVAR_ULONG(read_ahead_threshold, srv_read_ahead_threshold,
8626
PLUGIN_VAR_RQCMDARG,
8627
"Number of pages that must be accessed sequentially for InnoDB to"
8628
"trigger a readahead.",
8629
NULL, NULL, 56, 0, 64, 0);
8631
static drizzle_sys_var* innobase_system_variables[]= {
8632
DRIZZLE_SYSVAR(additional_mem_pool_size),
8633
DRIZZLE_SYSVAR(autoextend_increment),
8634
DRIZZLE_SYSVAR(buffer_pool_size),
8635
DRIZZLE_SYSVAR(checksums),
8636
DRIZZLE_SYSVAR(commit_concurrency),
8637
DRIZZLE_SYSVAR(concurrency_tickets),
8638
DRIZZLE_SYSVAR(data_file_path),
8639
DRIZZLE_SYSVAR(data_home_dir),
8640
DRIZZLE_SYSVAR(doublewrite),
8641
DRIZZLE_SYSVAR(fast_shutdown),
8642
DRIZZLE_SYSVAR(file_io_threads),
8643
DRIZZLE_SYSVAR(read_io_threads),
8644
DRIZZLE_SYSVAR(write_io_threads),
8645
DRIZZLE_SYSVAR(file_per_table),
8646
DRIZZLE_SYSVAR(file_format),
8647
DRIZZLE_SYSVAR(file_format_check),
8648
DRIZZLE_SYSVAR(flush_log_at_trx_commit),
8649
DRIZZLE_SYSVAR(flush_method),
8650
DRIZZLE_SYSVAR(force_recovery),
8651
DRIZZLE_SYSVAR(lock_wait_timeout),
8652
#ifdef UNIV_LOG_ARCHIVE
8653
DRIZZLE_SYSVAR(log_arch_dir),
8654
DRIZZLE_SYSVAR(log_archive),
8655
#endif /* UNIV_LOG_ARCHIVE */
8656
DRIZZLE_SYSVAR(log_buffer_size),
8657
DRIZZLE_SYSVAR(log_file_size),
8658
DRIZZLE_SYSVAR(log_files_in_group),
8659
DRIZZLE_SYSVAR(log_group_home_dir),
8660
DRIZZLE_SYSVAR(max_dirty_pages_pct),
8661
DRIZZLE_SYSVAR(max_purge_lag),
8662
DRIZZLE_SYSVAR(adaptive_flushing),
8663
DRIZZLE_SYSVAR(mirrored_log_groups),
8664
DRIZZLE_SYSVAR(open_files),
8665
DRIZZLE_SYSVAR(stats_on_metadata),
8666
DRIZZLE_SYSVAR(stats_sample_pages),
8667
DRIZZLE_SYSVAR(adaptive_hash_index),
8668
DRIZZLE_SYSVAR(replication_delay),
8669
DRIZZLE_SYSVAR(status_file),
8670
DRIZZLE_SYSVAR(strict_mode),
8671
DRIZZLE_SYSVAR(support_xa),
8672
DRIZZLE_SYSVAR(sync_spin_loops),
8673
DRIZZLE_SYSVAR(spin_wait_delay),
8674
DRIZZLE_SYSVAR(table_locks),
8675
DRIZZLE_SYSVAR(thread_concurrency),
8676
DRIZZLE_SYSVAR(thread_sleep_delay),
8677
DRIZZLE_SYSVAR(version),
8678
DRIZZLE_SYSVAR(use_sys_malloc),
8679
DRIZZLE_SYSVAR(change_buffering),
8680
DRIZZLE_SYSVAR(read_ahead_threshold),
8681
DRIZZLE_SYSVAR(io_capacity),
9277
8685
DRIZZLE_DECLARE_PLUGIN
added
removed
plugin/innobase/handler/ha_innodb.cc
