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
2090
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
2092
if (err != DB_SUCCESS) {
2279
2093
goto mem_free_and_error;
2283
innobase_old_blocks_pct = buf_LRU_old_ratio_update(innobase_old_blocks_pct.get(),
2286
2096
innobase_open_tables = hash_create(200);
2097
pthread_mutex_init(&innobase_share_mutex, MY_MUTEX_INIT_FAST);
2098
pthread_mutex_init(&prepare_commit_mutex, MY_MUTEX_INIT_FAST);
2099
pthread_mutex_init(&commit_threads_m, MY_MUTEX_INIT_FAST);
2100
pthread_mutex_init(&commit_cond_m, MY_MUTEX_INIT_FAST);
2101
pthread_cond_init(&commit_cond, NULL);
2287
2102
innodb_inited= 1;
2289
2104
actuall_engine_ptr->dropTemporarySchema();
2291
context.add(new InnodbStatusTool);
2106
status_table_function_ptr= new InnodbStatusTool;
2293
2108
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());
2110
context.add(status_table_function_ptr);
2112
cmp_tool= new(std::nothrow)CmpTool(false);
2113
context.add(cmp_tool);
2115
cmp_reset_tool= new(std::nothrow)CmpTool(true);
2116
context.add(cmp_reset_tool);
2118
cmp_mem_tool= new(std::nothrow)CmpmemTool(false);
2119
context.add(cmp_mem_tool);
2121
cmp_mem_reset_tool= new(std::nothrow)CmpmemTool(true);
2122
context.add(cmp_mem_reset_tool);
2124
innodb_trx_tool= new(std::nothrow)InnodbTrxTool("INNODB_TRX");
2125
context.add(innodb_trx_tool);
2127
innodb_locks_tool= new(std::nothrow)InnodbTrxTool("INNODB_LOCKS");
2128
context.add(innodb_locks_tool);
2130
innodb_lock_waits_tool= new(std::nothrow)InnodbTrxTool("INNODB_LOCK_WAITS");
2131
context.add(innodb_lock_waits_tool);
2323
2133
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
2135
/* 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);
2136
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]);
2578
/*****************************************************************//**
2579
Normalizes a table name string. A normalized name consists of the
2580
database name catenated to '/' and table name. An example:
2581
test/mytable. On Windows normalization puts both the database name and the
2582
table name always to lower case. */
2585
normalize_table_name(
2586
/*=================*/
2587
char* norm_name, /*!< out: normalized name as a
2588
null-terminated string */
2589
const char* name) /*!< in: table name string */
2591
const char* name_ptr;
2595
/* Scan name from the end */
2597
ptr = strchr(name, '\0')-1;
2599
while (ptr >= name && *ptr != '\\' && *ptr != '/') {
2609
while (ptr >= name && *ptr != '\\' && *ptr != '/') {
2615
memcpy(norm_name, db_ptr, strlen(name) + 1 - (db_ptr - name));
2617
norm_name[name_ptr - db_ptr - 1] = '/';
2620
innobase_casedn_str(norm_name);
3129
2624
/********************************************************************//**
3130
2625
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. */
2626
ha_innobase::open(). Therefore there's no need for a covering lock.
2627
@return DB_SUCCESS or error code */
3134
2630
ha_innobase::innobase_initialize_autoinc()
3135
2631
/*======================================*/
2633
dict_index_t* index;
3137
2634
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. */
2635
const char* col_name;
2638
col_name = table->found_next_number_field->field_name;
2639
index = innobase_get_index(table->getShare()->next_number_index);
2641
/* Execute SELECT MAX(col_name) FROM TABLE; */
2642
error = row_search_max_autoinc(index, col_name, &auto_inc);
2647
/* At the this stage we don't know the increment
2648
or the offset, so use default inrement of 1. */
2652
case DB_RECORD_NOT_FOUND:
3148
2653
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. */
2654
fprintf(stderr, " InnoDB: MySQL and InnoDB data "
2655
"dictionaries are out of sync.\n"
2656
"InnoDB: Unable to find the AUTOINC column %s in the "
2657
"InnoDB table %s.\n"
2658
"InnoDB: We set the next AUTOINC column value to the "
2659
"maximum possible value,\n"
2660
"InnoDB: in effect disabling the AUTOINC next value "
2662
"InnoDB: You can either set the next AUTOINC value "
2663
"explicitly using ALTER TABLE\n"
2664
"InnoDB: or fix the data dictionary by recreating "
2666
col_name, index->table->name);
2668
auto_inc = 0xFFFFFFFFFFFFFFFFULL;
3222
2675
dict_table_autoinc_initialize(prebuilt->table, auto_inc);
3225
2680
/*****************************************************************//**
9093
8030
/************************************************************//**
8031
Validate the file format check value, is it one of "on" or "off",
8032
as a side effect it sets the srv_check_file_format_at_startup variable.
8033
@return true if config value one of "on" or "off" */
8036
innobase_file_format_check_on_off(
8037
/*==============================*/
8038
const char* format_check) /*!< in: parameter value */
8042
if (!innobase_strcasecmp(format_check, "off")) {
8044
/* Set the value to disable checking. */
8045
srv_check_file_format_at_startup = DICT_TF_FORMAT_MAX + 1;
8047
} else if (!innobase_strcasecmp(format_check, "on")) {
8049
/* Set the value to the lowest supported format. */
8050
srv_check_file_format_at_startup = DICT_TF_FORMAT_51;
8058
/************************************************************//**
9094
8059
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 */
8060
sets the srv_check_file_format_at_startup variable.
8061
@return true if valid config value */
9099
innobase_file_format_validate_and_set(
8064
innobase_file_format_check_validate(
9100
8065
/*================================*/
9101
const char* format_max) /*!< in: parameter value */
8066
const char* format_check) /*!< in: parameter value */
9103
8068
uint format_id;
9105
format_id = innobase_file_format_name_lookup(format_max);
8071
format_id = innobase_file_format_name_lookup(format_check);
9107
8073
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)."));
8074
srv_check_file_format_at_startup = format_id;
8082
/*************************************************************//**
8083
Check if it is a valid file format. This function is registered as
8084
a callback with MySQL.
8085
@return 0 for valid file format */
8088
innodb_file_format_name_validate(
8089
/*=============================*/
8090
Session* , /*!< in: thread handle */
8091
drizzle_sys_var* , /*!< in: pointer to system
8093
void* save, /*!< out: immediate result
8094
for update function */
8095
drizzle_value* value) /*!< in: incoming string */
8097
const char* file_format_input;
8098
char buff[STRING_BUFFER_USUAL_SIZE];
8099
int len = sizeof(buff);
8102
ut_a(value != NULL);
8104
file_format_input = value->val_str(value, buff, &len);
8106
if (file_format_input != NULL) {
8109
format_id = innobase_file_format_name_lookup(
8112
if (format_id <= DICT_TF_FORMAT_MAX) {
8114
*static_cast<const char**>(save) = file_format_input;
8119
*static_cast<const char**>(save) = NULL;
8123
/****************************************************************//**
8124
Update the system variable innodb_file_format using the "saved"
8125
value. This function is registered as a callback with MySQL. */
8128
innodb_file_format_name_update(
8129
/*===========================*/
8130
Session* , /*!< in: thread handle */
8131
drizzle_sys_var* , /*!< in: pointer to
8133
void* var_ptr, /*!< out: where the
8134
formal string goes */
8135
const void* save) /*!< in: immediate result
8136
from check function */
8138
const char* format_name;
8140
ut_a(var_ptr != NULL);
8143
format_name = *static_cast<const char*const*>(save);
8148
format_id = innobase_file_format_name_lookup(format_name);
8150
if (format_id <= DICT_TF_FORMAT_MAX) {
8151
srv_file_format = format_id;
8155
*static_cast<const char**>(var_ptr)
8156
= trx_sys_file_format_id_to_name(srv_file_format);
8159
/*************************************************************//**
8160
Check if valid argument to innodb_file_format_check. This
8161
function is registered as a callback with MySQL.
8162
@return 0 for valid file format */
8165
innodb_file_format_check_validate(
8166
/*==============================*/
8167
Session* , /*!< in: thread handle */
8168
drizzle_sys_var* , /*!< in: pointer to system
8170
void* save, /*!< out: immediate result
8171
for update function */
8172
drizzle_value* value) /*!< in: incoming string */
8174
const char* file_format_input;
8175
char buff[STRING_BUFFER_USUAL_SIZE];
8176
int len = sizeof(buff);
8179
ut_a(value != NULL);
8181
file_format_input = value->val_str(value, buff, &len);
8183
if (file_format_input != NULL) {
8185
/* Check if user set on/off, we want to print a suitable
8186
message if they did so. */
8188
if (innobase_file_format_check_on_off(file_format_input)) {
8189
errmsg_printf(ERRMSG_LVL_WARN,
8190
"InnoDB: invalid innodb_file_format_check "
8191
"value; on/off can only be set at startup or "
8192
"in the configuration file");
8193
} else if (innobase_file_format_check_validate(
8194
file_format_input)) {
8196
*static_cast<const char**>(save) = file_format_input;
8201
errmsg_printf(ERRMSG_LVL_WARN,
8202
"InnoDB: invalid innodb_file_format_check "
8203
"value; can be any format up to %s "
8204
"or its equivalent numeric id",
8205
trx_sys_file_format_id_to_name(
8206
DICT_TF_FORMAT_MAX));
8210
*static_cast<const char**>(save) = NULL;
8214
/****************************************************************//**
8215
Update the system variable innodb_file_format_check using the "saved"
8216
value. This function is registered as a callback with MySQL. */
8219
innodb_file_format_check_update(
8220
/*============================*/
8221
Session* session, /*!< in: thread handle */
8222
drizzle_sys_var* , /*!< in: pointer to
8224
void* var_ptr, /*!< out: where the
8225
formal string goes */
8226
const void* save) /*!< in: immediate result
8227
from check function */
8229
const char* format_name_in;
8230
const char** format_name_out;
8234
ut_a(var_ptr != NULL);
8236
format_name_in = *static_cast<const char*const*>(save);
8238
if (!format_name_in) {
8243
format_id = innobase_file_format_name_lookup(format_name_in);
8245
if (format_id > DICT_TF_FORMAT_MAX) {
8246
/* DEFAULT is "on", which is invalid at runtime. */
8247
push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
8249
"Ignoring SET innodb_file_format=%s",
8254
format_name_out = static_cast<const char**>(var_ptr);
8256
/* Update the max format id in the system tablespace. */
8257
if (trx_sys_file_format_max_set(format_id, format_name_out)) {
8258
ut_print_timestamp(stderr);
8260
" [Info] InnoDB: the file format in the system "
8261
"tablespace is now set to %s.\n", *format_name_out);
8265
/****************************************************************//**
8266
Update the system variable innodb_adaptive_hash_index using the "saved"
8267
value. This function is registered as a callback with MySQL. */
8270
innodb_adaptive_hash_index_update(
8271
/*==============================*/
8272
Session* , /*!< in: thread handle */
8273
drizzle_sys_var* , /*!< in: pointer to
8275
void* , /*!< out: where the
8276
formal string goes */
8277
const void* save) /*!< in: immediate result
8278
from check function */
8280
if (*(bool*) save) {
8281
btr_search_enable();
8283
btr_search_disable();
8287
/*************************************************************//**
8288
Check if it is a valid value of innodb_change_buffering. This function is
8289
registered as a callback with MySQL.
8290
@return 0 for valid innodb_change_buffering */
8293
innodb_change_buffering_validate(
8294
/*=============================*/
8295
Session* , /*!< in: thread handle */
8296
drizzle_sys_var* , /*!< in: pointer to system
8298
void* save, /*!< out: immediate result
8299
for update function */
8300
drizzle_value* value) /*!< in: incoming string */
8302
const char* change_buffering_input;
8303
char buff[STRING_BUFFER_USUAL_SIZE];
8304
int len = sizeof(buff);
8307
ut_a(value != NULL);
8309
change_buffering_input = value->val_str(value, buff, &len);
8311
if (change_buffering_input != NULL) {
8314
for (use = 0; use < UT_ARR_SIZE(innobase_change_buffering_values);
8316
if (!innobase_strcasecmp(
8317
change_buffering_input,
8318
innobase_change_buffering_values[use])) {
8319
*(ibuf_use_t*) save = (ibuf_use_t) use;
8328
/****************************************************************//**
8329
Update the system variable innodb_change_buffering using the "saved"
8330
value. This function is registered as a callback with MySQL. */
8333
innodb_change_buffering_update(
8334
/*===========================*/
8335
Session* , /*!< in: thread handle */
8336
drizzle_sys_var* , /*!< in: pointer to
8338
void* var_ptr, /*!< out: where the
8339
formal string goes */
8340
const void* save) /*!< in: immediate result
8341
from check function */
8343
ut_a(var_ptr != NULL);
8345
ut_a((*(ibuf_use_t*) save) < IBUF_USE_COUNT);
8347
ibuf_use = *(const ibuf_use_t*) save;
8349
*(const char**) var_ptr = innobase_change_buffering_values[ibuf_use];
8352
/* plugin options */
8353
static DRIZZLE_SYSVAR_BOOL(checksums, innobase_use_checksums,
8354
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8355
"Enable InnoDB checksums validation (enabled by default). "
8356
"Disable with --skip-innodb-checksums.",
8359
static DRIZZLE_SYSVAR_STR(data_home_dir, innobase_data_home_dir,
8360
PLUGIN_VAR_READONLY,
8361
"The common part for InnoDB table spaces.",
8364
static DRIZZLE_SYSVAR_BOOL(doublewrite, innobase_use_doublewrite,
8365
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8366
"Enable InnoDB doublewrite buffer (enabled by default). "
8367
"Disable with --skip-innodb-doublewrite.",
8370
static DRIZZLE_SYSVAR_ULONG(io_capacity, srv_io_capacity,
8371
PLUGIN_VAR_RQCMDARG,
8372
"Number of IOPs the server can do. Tunes the background IO rate",
8373
NULL, NULL, 200, 100, ~0L, 0);
8375
static DRIZZLE_SYSVAR_ULONG(fast_shutdown, innobase_fast_shutdown,
8376
PLUGIN_VAR_OPCMDARG,
8377
"Speeds up the shutdown process of the InnoDB storage engine. Possible "
8378
"values are 0, 1 (faster)"
8379
" or 2 (fastest - crash-like)"
8381
NULL, NULL, 1, 0, 2, 0);
8383
static DRIZZLE_SYSVAR_BOOL(file_per_table, srv_file_per_table,
8384
PLUGIN_VAR_NOCMDARG,
8385
"Stores each InnoDB table to an .ibd file in the database dir.",
8388
static DRIZZLE_SYSVAR_STR(file_format, innobase_file_format_name,
8389
PLUGIN_VAR_RQCMDARG,
8390
"File format to use for new tables in .ibd files.",
8391
innodb_file_format_name_validate,
8392
innodb_file_format_name_update, "Antelope");
8394
static DRIZZLE_SYSVAR_STR(file_format_check, innobase_file_format_check,
8395
PLUGIN_VAR_OPCMDARG,
8396
"The highest file format in the tablespace.",
8397
innodb_file_format_check_validate,
8398
innodb_file_format_check_update,
8401
static DRIZZLE_SYSVAR_ULONG(flush_log_at_trx_commit, srv_flush_log_at_trx_commit,
8402
PLUGIN_VAR_OPCMDARG,
8403
"Set to 0 (write and flush once per second),"
8404
" 1 (write and flush at each commit)"
8405
" or 2 (write at commit, flush once per second).",
8406
NULL, NULL, 1, 0, 2, 0);
8408
static DRIZZLE_SYSVAR_STR(flush_method, innobase_unix_file_flush_method,
8409
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8410
"With which method to flush data.", NULL, NULL, NULL);
8412
#ifdef UNIV_LOG_ARCHIVE
8413
static DRIZZLE_SYSVAR_STR(log_arch_dir, innobase_log_arch_dir,
8414
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8415
"Where full logs should be archived.", NULL, NULL, NULL);
8417
static DRIZZLE_SYSVAR_BOOL(log_archive, innobase_log_archive,
8418
PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
8419
"Set to 1 if you want to have logs archived.", NULL, NULL, FALSE);
8420
#endif /* UNIV_LOG_ARCHIVE */
8422
static DRIZZLE_SYSVAR_STR(log_group_home_dir, innobase_log_group_home_dir,
8423
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8424
"Path to InnoDB log files.", NULL, NULL, NULL);
8426
static DRIZZLE_SYSVAR_ULONG(max_dirty_pages_pct, srv_max_buf_pool_modified_pct,
8427
PLUGIN_VAR_RQCMDARG,
8428
"Percentage of dirty pages allowed in bufferpool.",
8429
NULL, NULL, 75, 0, 99, 0);
8431
static DRIZZLE_SYSVAR_BOOL(adaptive_flushing, srv_adaptive_flushing,
8432
PLUGIN_VAR_NOCMDARG,
8433
"Attempt flushing dirty pages to avoid IO bursts at checkpoints.",
8436
static DRIZZLE_SYSVAR_ULONG(max_purge_lag, srv_max_purge_lag,
8437
PLUGIN_VAR_RQCMDARG,
8438
"Desired maximum length of the purge queue (0 = no limit)",
8439
NULL, NULL, 0, 0, ~0L, 0);
8441
static DRIZZLE_SYSVAR_BOOL(status_file, innobase_create_status_file,
8442
PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_NOSYSVAR,
8443
"Enable SHOW INNODB STATUS output in the innodb_status.<pid> file",
8446
static DRIZZLE_SYSVAR_BOOL(stats_on_metadata, innobase_stats_on_metadata,
8447
PLUGIN_VAR_OPCMDARG,
8448
"Enable statistics gathering for metadata commands such as SHOW TABLE STATUS (on by default)",
8451
static DRIZZLE_SYSVAR_ULONGLONG(stats_sample_pages, srv_stats_sample_pages,
8452
PLUGIN_VAR_RQCMDARG,
8453
"The number of index pages to sample when calculating statistics (default 8)",
8454
NULL, NULL, 8, 1, ~0ULL, 0);
8456
static DRIZZLE_SYSVAR_BOOL(adaptive_hash_index, btr_search_enabled,
8457
PLUGIN_VAR_OPCMDARG,
8458
"Enable InnoDB adaptive hash index (enabled by default). "
8459
"Disable with --skip-innodb-adaptive-hash-index.",
8460
NULL, innodb_adaptive_hash_index_update, TRUE);
8462
static DRIZZLE_SYSVAR_ULONG(replication_delay, srv_replication_delay,
8463
PLUGIN_VAR_RQCMDARG,
8464
"Replication thread delay (ms) on the slave server if "
8465
"innodb_thread_concurrency is reached (0 by default)",
8466
NULL, NULL, 0, 0, ~0UL, 0);
8468
static DRIZZLE_SYSVAR_LONG(additional_mem_pool_size, innobase_additional_mem_pool_size,
8469
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8470
"Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.",
8471
NULL, NULL, 8*1024*1024L, 512*1024L, LONG_MAX, 1024);
8473
static DRIZZLE_SYSVAR_UINT(autoextend_increment, srv_auto_extend_increment,
8474
PLUGIN_VAR_RQCMDARG,
8475
"Data file autoextend increment in megabytes",
8476
NULL, NULL, 8L, 1L, 1000L, 0);
8478
static DRIZZLE_SYSVAR_LONGLONG(buffer_pool_size, innobase_buffer_pool_size,
8479
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8480
"The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",
8481
NULL, NULL, 128*1024*1024L, 5*1024*1024L, INT64_MAX, 1024*1024L);
8483
static DRIZZLE_SYSVAR_ULONG(commit_concurrency, innobase_commit_concurrency,
8484
PLUGIN_VAR_RQCMDARG,
8485
"Helps in performance tuning in heavily concurrent environments.",
8486
innobase_commit_concurrency_validate, NULL, 0, 0, 1000, 0);
8488
static DRIZZLE_SYSVAR_ULONG(concurrency_tickets, srv_n_free_tickets_to_enter,
8489
PLUGIN_VAR_RQCMDARG,
8490
"Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got the ticket",
8491
NULL, NULL, 500L, 1L, ~0L, 0);
8493
static DRIZZLE_SYSVAR_LONG(file_io_threads, innobase_file_io_threads,
8494
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8495
"Number of file I/O threads in InnoDB.",
8496
NULL, NULL, 4, 4, 64, 0);
8498
static DRIZZLE_SYSVAR_ULONG(read_io_threads, innobase_read_io_threads,
8499
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8500
"Number of background read I/O threads in InnoDB.",
8501
NULL, NULL, 4, 1, 64, 0);
8503
static DRIZZLE_SYSVAR_ULONG(write_io_threads, innobase_write_io_threads,
8504
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8505
"Number of background write I/O threads in InnoDB.",
8506
NULL, NULL, 4, 1, 64, 0);
8508
static DRIZZLE_SYSVAR_LONG(force_recovery, innobase_force_recovery,
8509
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8510
"Helps to save your data in case the disk image of the database becomes corrupt.",
8511
NULL, NULL, 0, 0, 6, 0);
8513
static DRIZZLE_SYSVAR_LONG(log_buffer_size, innobase_log_buffer_size,
8514
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8515
"The size of the buffer which InnoDB uses to write log to the log files on disk.",
8516
NULL, NULL, 8*1024*1024L, 256*1024L, LONG_MAX, 1024);
8518
static DRIZZLE_SYSVAR_LONGLONG(log_file_size, innobase_log_file_size,
8519
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8520
"Size of each log file in a log group.",
8521
NULL, NULL, 20*1024*1024L, 1*1024*1024L, INT64_MAX, 1024*1024L);
8523
static DRIZZLE_SYSVAR_LONG(log_files_in_group, innobase_log_files_in_group,
8524
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8525
"Number of log files in the log group. InnoDB writes to the files in a circular fashion. Value 3 is recommended here.",
8526
NULL, NULL, 2, 2, 100, 0);
8528
static DRIZZLE_SYSVAR_LONG(mirrored_log_groups, innobase_mirrored_log_groups,
8529
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8530
"Number of identical copies of log groups we keep for the database. Currently this should be set to 1.",
8531
NULL, NULL, 1, 1, 10, 0);
8533
static DRIZZLE_SYSVAR_LONG(open_files, innobase_open_files,
8534
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8535
"How many files at the maximum InnoDB keeps open at the same time.",
8536
NULL, NULL, 300L, 10L, LONG_MAX, 0);
8538
static DRIZZLE_SYSVAR_ULONG(sync_spin_loops, srv_n_spin_wait_rounds,
8539
PLUGIN_VAR_RQCMDARG,
8540
"Count of spin-loop rounds in InnoDB mutexes (30 by default)",
8541
NULL, NULL, 30L, 0L, ~0L, 0);
8543
static DRIZZLE_SYSVAR_ULONG(spin_wait_delay, srv_spin_wait_delay,
8544
PLUGIN_VAR_OPCMDARG,
8545
"Maximum delay between polling for a spin lock (6 by default)",
8546
NULL, NULL, 6L, 0L, ~0L, 0);
8548
static DRIZZLE_SYSVAR_ULONG(thread_concurrency, srv_thread_concurrency,
8549
PLUGIN_VAR_RQCMDARG,
8550
"Helps in performance tuning in heavily concurrent environments. Sets the maximum number of threads allowed inside InnoDB. Value 0 will disable the thread throttling.",
8551
NULL, NULL, 0, 0, 1000, 0);
8553
static DRIZZLE_SYSVAR_ULONG(thread_sleep_delay, srv_thread_sleep_delay,
8554
PLUGIN_VAR_RQCMDARG,
8555
"Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0 disable a sleep",
8556
NULL, NULL, 10000L, 0L, ~0L, 0);
8558
static DRIZZLE_SYSVAR_STR(data_file_path, innobase_data_file_path,
8559
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8560
"Path to individual files and their sizes.",
8563
static DRIZZLE_SYSVAR_STR(version, innodb_version_str,
8564
PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_READONLY,
8565
"InnoDB version", NULL, NULL, INNODB_VERSION_STR);
8567
static DRIZZLE_SYSVAR_BOOL(use_sys_malloc, srv_use_sys_malloc,
8568
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8569
"Use OS memory allocator instead of InnoDB's internal memory allocator",
8572
static DRIZZLE_SYSVAR_STR(change_buffering, innobase_change_buffering,
8573
PLUGIN_VAR_RQCMDARG,
8574
"Buffer changes to reduce random access: "
8575
"OFF, ON, inserting, deleting, changing, or purging.",
8576
innodb_change_buffering_validate,
8577
innodb_change_buffering_update, NULL);
8579
static DRIZZLE_SYSVAR_ULONG(read_ahead_threshold, srv_read_ahead_threshold,
8580
PLUGIN_VAR_RQCMDARG,
8581
"Number of pages that must be accessed sequentially for InnoDB to"
8582
"trigger a readahead.",
8583
NULL, NULL, 56, 0, 64, 0);
8585
static drizzle_sys_var* innobase_system_variables[]= {
8586
DRIZZLE_SYSVAR(additional_mem_pool_size),
8587
DRIZZLE_SYSVAR(autoextend_increment),
8588
DRIZZLE_SYSVAR(buffer_pool_size),
8589
DRIZZLE_SYSVAR(checksums),
8590
DRIZZLE_SYSVAR(commit_concurrency),
8591
DRIZZLE_SYSVAR(concurrency_tickets),
8592
DRIZZLE_SYSVAR(data_file_path),
8593
DRIZZLE_SYSVAR(data_home_dir),
8594
DRIZZLE_SYSVAR(doublewrite),
8595
DRIZZLE_SYSVAR(fast_shutdown),
8596
DRIZZLE_SYSVAR(file_io_threads),
8597
DRIZZLE_SYSVAR(read_io_threads),
8598
DRIZZLE_SYSVAR(write_io_threads),
8599
DRIZZLE_SYSVAR(file_per_table),
8600
DRIZZLE_SYSVAR(file_format),
8601
DRIZZLE_SYSVAR(file_format_check),
8602
DRIZZLE_SYSVAR(flush_log_at_trx_commit),
8603
DRIZZLE_SYSVAR(flush_method),
8604
DRIZZLE_SYSVAR(force_recovery),
8605
DRIZZLE_SYSVAR(lock_wait_timeout),
8606
#ifdef UNIV_LOG_ARCHIVE
8607
DRIZZLE_SYSVAR(log_arch_dir),
8608
DRIZZLE_SYSVAR(log_archive),
8609
#endif /* UNIV_LOG_ARCHIVE */
8610
DRIZZLE_SYSVAR(log_buffer_size),
8611
DRIZZLE_SYSVAR(log_file_size),
8612
DRIZZLE_SYSVAR(log_files_in_group),
8613
DRIZZLE_SYSVAR(log_group_home_dir),
8614
DRIZZLE_SYSVAR(max_dirty_pages_pct),
8615
DRIZZLE_SYSVAR(max_purge_lag),
8616
DRIZZLE_SYSVAR(adaptive_flushing),
8617
DRIZZLE_SYSVAR(mirrored_log_groups),
8618
DRIZZLE_SYSVAR(open_files),
8619
DRIZZLE_SYSVAR(stats_on_metadata),
8620
DRIZZLE_SYSVAR(stats_sample_pages),
8621
DRIZZLE_SYSVAR(adaptive_hash_index),
8622
DRIZZLE_SYSVAR(replication_delay),
8623
DRIZZLE_SYSVAR(status_file),
8624
DRIZZLE_SYSVAR(strict_mode),
8625
DRIZZLE_SYSVAR(support_xa),
8626
DRIZZLE_SYSVAR(sync_spin_loops),
8627
DRIZZLE_SYSVAR(spin_wait_delay),
8628
DRIZZLE_SYSVAR(table_locks),
8629
DRIZZLE_SYSVAR(thread_concurrency),
8630
DRIZZLE_SYSVAR(thread_sleep_delay),
8631
DRIZZLE_SYSVAR(version),
8632
DRIZZLE_SYSVAR(use_sys_malloc),
8633
DRIZZLE_SYSVAR(change_buffering),
8634
DRIZZLE_SYSVAR(read_ahead_threshold),
8635
DRIZZLE_SYSVAR(io_capacity),
9277
8639
DRIZZLE_DECLARE_PLUGIN
added
removed
plugin/innobase/handler/ha_innodb.cc
