160
167
#endif /* MYSQL_DYNAMIC_PLUGIN && __WIN__ */
162
169
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;
170
static plugin::TableFunction* status_table_function_ptr= NULL;
171
static plugin::TableFunction* cmp_tool= NULL;
172
static plugin::TableFunction* cmp_reset_tool= NULL;
173
static plugin::TableFunction* cmp_mem_tool= NULL;
174
static plugin::TableFunction* cmp_mem_reset_tool= NULL;
175
static plugin::TableFunction* innodb_trx_tool= NULL;
176
static plugin::TableFunction* innodb_locks_tool= NULL;
177
static plugin::TableFunction* innodb_lock_waits_tool= NULL;
179
static const long AUTOINC_OLD_STYLE_LOCKING = 0;
180
static const long AUTOINC_NEW_STYLE_LOCKING = 1;
181
static const long AUTOINC_NO_LOCKING = 2;
183
static long innobase_mirrored_log_groups, innobase_log_files_in_group,
184
innobase_log_buffer_size,
185
innobase_additional_mem_pool_size, innobase_file_io_threads,
186
innobase_force_recovery, innobase_open_files,
187
innobase_autoinc_lock_mode;
188
static ulong innobase_commit_concurrency = 0;
189
static ulong innobase_read_io_threads;
190
static ulong innobase_write_io_threads;
193
* @TODO: Turn this into size_t as soon as we have a Variable<size_t>
195
static int64_t innobase_buffer_pool_size, innobase_log_file_size;
220
197
/* The default values for the following char* start-up parameters
221
198
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;
200
static char* innobase_data_home_dir = NULL;
201
static char* innobase_data_file_path = NULL;
202
static char* innobase_log_group_home_dir = NULL;
203
static char* innobase_file_format_name = NULL;
204
static char* innobase_change_buffering = NULL;
206
/* Note: This variable can be set to on/off and any of the supported
207
file formats in the configuration file, but can only be set to any
208
of the supported file formats during runtime. */
209
static char* innobase_file_format_check = NULL;
211
/* The following has a misleading name: starting from 4.0.5, this also
213
static char* innobase_unix_file_flush_method = NULL;
234
215
/* 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;
218
static ulong innobase_fast_shutdown = 1;
219
#ifdef UNIV_LOG_ARCHIVE
220
static my_bool innobase_log_archive = FALSE;
221
static char* innobase_log_arch_dir = NULL;
222
#endif /* UNIV_LOG_ARCHIVE */
253
223
static my_bool innobase_use_doublewrite = TRUE;
254
224
static my_bool innobase_use_checksums = TRUE;
255
225
static my_bool innobase_rollback_on_timeout = FALSE;
256
226
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;
227
static my_bool innobase_stats_on_metadata = TRUE;
263
229
static char* internal_innobase_data_file_path = NULL;
231
static char* innodb_version_str = (char*) INNODB_VERSION_STR;
265
233
/* The following counter is used to convey information to InnoDB
266
234
about server activity: in selects it is not sensible to call
267
235
srv_active_wake_master_thread after each fetch or search, we only do
2256
2081
srv_print_verbose_log = true;
2258
2083
/* Store the default charset-collation number of this MySQL
2261
2086
data_mysql_default_charset_coll = (ulint)default_charset_info->number;
2089
innobase_commit_concurrency_init_default();
2263
2091
/* Since we in this module access directly the fields of a trx
2264
struct, and due to different headers and flags it might happen that
2265
mutex_t has a different size in this module and in InnoDB
2266
modules, we check at run time that the size is the same in
2267
these compilation modules. */
2092
struct, and due to different headers and flags it might happen that
2093
mutex_t has a different size in this module and in InnoDB
2094
modules, we check at run time that the size is the same in
2095
these compilation modules. */
2269
2097
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
2099
if (err != DB_SUCCESS) {
2279
2100
goto mem_free_and_error;
2283
innobase_old_blocks_pct = buf_LRU_old_ratio_update(innobase_old_blocks_pct.get(),
2286
2103
innobase_open_tables = hash_create(200);
2104
pthread_mutex_init(&innobase_share_mutex, MY_MUTEX_INIT_FAST);
2105
pthread_mutex_init(&prepare_commit_mutex, MY_MUTEX_INIT_FAST);
2106
pthread_mutex_init(&commit_threads_m, MY_MUTEX_INIT_FAST);
2107
pthread_mutex_init(&commit_cond_m, MY_MUTEX_INIT_FAST);
2108
pthread_cond_init(&commit_cond, NULL);
2287
2109
innodb_inited= 1;
2289
actuall_engine_ptr->dropTemporarySchema();
2291
context.add(new InnodbStatusTool);
2111
status_table_function_ptr= new InnodbStatusTool;
2293
2113
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());
2323
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));
2115
context.add(status_table_function_ptr);
2117
cmp_tool= new(std::nothrow)CmpTool(false);
2118
context.add(cmp_tool);
2120
cmp_reset_tool= new(std::nothrow)CmpTool(true);
2121
context.add(cmp_reset_tool);
2123
cmp_mem_tool= new(std::nothrow)CmpmemTool(false);
2124
context.add(cmp_mem_tool);
2126
cmp_mem_reset_tool= new(std::nothrow)CmpmemTool(true);
2127
context.add(cmp_mem_reset_tool);
2129
innodb_trx_tool= new(std::nothrow)InnodbTrxTool("INNODB_TRX");
2130
context.add(innodb_trx_tool);
2132
innodb_locks_tool= new(std::nothrow)InnodbTrxTool("INNODB_LOCKS");
2133
context.add(innodb_locks_tool);
2135
innodb_lock_waits_tool= new(std::nothrow)InnodbTrxTool("INNODB_LOCK_WAITS");
2136
context.add(innodb_lock_waits_tool);
2414
2138
/* 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);
2139
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]);
2618
/*****************************************************************//**
2619
Normalizes a table name string. A normalized name consists of the
2620
database name catenated to '/' and table name. An example:
2621
test/mytable. On Windows normalization puts both the database name and the
2622
table name always to lower case. */
2625
normalize_table_name(
2626
/*=================*/
2627
char* norm_name, /*!< out: normalized name as a
2628
null-terminated string */
2629
const char* name) /*!< in: table name string */
2631
const char* name_ptr;
2635
/* Scan name from the end */
2637
ptr = strchr(name, '\0')-1;
2639
while (ptr >= name && *ptr != '\\' && *ptr != '/') {
2649
while (ptr >= name && *ptr != '\\' && *ptr != '/') {
2655
memcpy(norm_name, db_ptr, strlen(name) + 1 - (db_ptr - name));
2657
norm_name[name_ptr - db_ptr - 1] = '/';
2660
innobase_casedn_str(norm_name);
3129
2664
/********************************************************************//**
3130
2665
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. */
2666
ha_innobase::open(). Therefore there's no need for a covering lock.
2667
@return DB_SUCCESS or error code */
3134
2670
ha_innobase::innobase_initialize_autoinc()
3135
2671
/*======================================*/
2673
dict_index_t* index;
3137
2674
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. */
2675
const char* col_name;
2678
col_name = table->found_next_number_field->field_name;
2679
index = innobase_get_index(table->s->next_number_index);
2681
/* Execute SELECT MAX(col_name) FROM TABLE; */
2682
error = row_search_max_autoinc(index, col_name, &auto_inc);
2687
/* At the this stage we don't know the increment
2688
or the offset, so use default inrement of 1. */
2692
case DB_RECORD_NOT_FOUND:
3148
2693
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. */
2694
fprintf(stderr, " InnoDB: MySQL and InnoDB data "
2695
"dictionaries are out of sync.\n"
2696
"InnoDB: Unable to find the AUTOINC column %s in the "
2697
"InnoDB table %s.\n"
2698
"InnoDB: We set the next AUTOINC column value to the "
2699
"maximum possible value,\n"
2700
"InnoDB: in effect disabling the AUTOINC next value "
2702
"InnoDB: You can either set the next AUTOINC value "
2703
"explicitly using ALTER TABLE\n"
2704
"InnoDB: or fix the data dictionary by recreating "
2706
col_name, index->table->name);
2708
auto_inc = 0xFFFFFFFFFFFFFFFFULL;
3222
2715
dict_table_autoinc_initialize(prebuilt->table, auto_inc);
3225
2720
/*****************************************************************//**
9093
8108
/************************************************************//**
8109
Validate the file format check value, is it one of "on" or "off",
8110
as a side effect it sets the srv_check_file_format_at_startup variable.
8111
@return true if config value one of "on" or "off" */
8114
innobase_file_format_check_on_off(
8115
/*==============================*/
8116
const char* format_check) /*!< in: parameter value */
8120
if (!innobase_strcasecmp(format_check, "off")) {
8122
/* Set the value to disable checking. */
8123
srv_check_file_format_at_startup = DICT_TF_FORMAT_MAX + 1;
8125
} else if (!innobase_strcasecmp(format_check, "on")) {
8127
/* Set the value to the lowest supported format. */
8128
srv_check_file_format_at_startup = DICT_TF_FORMAT_51;
8136
/************************************************************//**
9094
8137
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 */
8138
sets the srv_check_file_format_at_startup variable.
8139
@return true if valid config value */
9099
innobase_file_format_validate_and_set(
8142
innobase_file_format_check_validate(
9100
8143
/*================================*/
9101
const char* format_max) /*!< in: parameter value */
8144
const char* format_check) /*!< in: parameter value */
9103
8146
uint format_id;
9105
format_id = innobase_file_format_name_lookup(format_max);
8149
format_id = innobase_file_format_name_lookup(format_check);
9107
8151
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)."));
8152
srv_check_file_format_at_startup = format_id;
8160
/*************************************************************//**
8161
Check if it is a valid file format. This function is registered as
8162
a callback with MySQL.
8163
@return 0 for valid file format */
8166
innodb_file_format_name_validate(
8167
/*=============================*/
8168
Session* , /*!< in: thread handle */
8169
drizzle_sys_var* , /*!< in: pointer to system
8171
void* save, /*!< out: immediate result
8172
for update function */
8173
drizzle_value* value) /*!< in: incoming string */
8175
const char* file_format_input;
8176
char buff[STRING_BUFFER_USUAL_SIZE];
8177
int len = sizeof(buff);
8180
ut_a(value != NULL);
8182
file_format_input = value->val_str(value, buff, &len);
8184
if (file_format_input != NULL) {
8187
format_id = innobase_file_format_name_lookup(
8190
if (format_id <= DICT_TF_FORMAT_MAX) {
8192
*static_cast<const char**>(save) = file_format_input;
8197
*static_cast<const char**>(save) = NULL;
8201
/****************************************************************//**
8202
Update the system variable innodb_file_format using the "saved"
8203
value. This function is registered as a callback with MySQL. */
8206
innodb_file_format_name_update(
8207
/*===========================*/
8208
Session* , /*!< in: thread handle */
8209
drizzle_sys_var* , /*!< in: pointer to
8211
void* var_ptr, /*!< out: where the
8212
formal string goes */
8213
const void* save) /*!< in: immediate result
8214
from check function */
8216
const char* format_name;
8218
ut_a(var_ptr != NULL);
8221
format_name = *static_cast<const char*const*>(save);
8226
format_id = innobase_file_format_name_lookup(format_name);
8228
if (format_id <= DICT_TF_FORMAT_MAX) {
8229
srv_file_format = format_id;
8233
*static_cast<const char**>(var_ptr)
8234
= trx_sys_file_format_id_to_name(srv_file_format);
8237
/*************************************************************//**
8238
Check if valid argument to innodb_file_format_check. This
8239
function is registered as a callback with MySQL.
8240
@return 0 for valid file format */
8243
innodb_file_format_check_validate(
8244
/*==============================*/
8245
Session* , /*!< in: thread handle */
8246
drizzle_sys_var* , /*!< in: pointer to system
8248
void* save, /*!< out: immediate result
8249
for update function */
8250
drizzle_value* value) /*!< in: incoming string */
8252
const char* file_format_input;
8253
char buff[STRING_BUFFER_USUAL_SIZE];
8254
int len = sizeof(buff);
8257
ut_a(value != NULL);
8259
file_format_input = value->val_str(value, buff, &len);
8261
if (file_format_input != NULL) {
8263
/* Check if user set on/off, we want to print a suitable
8264
message if they did so. */
8266
if (innobase_file_format_check_on_off(file_format_input)) {
8267
errmsg_printf(ERRMSG_LVL_WARN,
8268
"InnoDB: invalid innodb_file_format_check "
8269
"value; on/off can only be set at startup or "
8270
"in the configuration file");
8271
} else if (innobase_file_format_check_validate(
8272
file_format_input)) {
8274
*static_cast<const char**>(save) = file_format_input;
8279
errmsg_printf(ERRMSG_LVL_WARN,
8280
"InnoDB: invalid innodb_file_format_check "
8281
"value; can be any format up to %s "
8282
"or its equivalent numeric id",
8283
trx_sys_file_format_id_to_name(
8284
DICT_TF_FORMAT_MAX));
8288
*static_cast<const char**>(save) = NULL;
8292
/****************************************************************//**
8293
Update the system variable innodb_file_format_check using the "saved"
8294
value. This function is registered as a callback with MySQL. */
8297
innodb_file_format_check_update(
8298
/*============================*/
8299
Session* session, /*!< in: thread handle */
8300
drizzle_sys_var* , /*!< in: pointer to
8302
void* var_ptr, /*!< out: where the
8303
formal string goes */
8304
const void* save) /*!< in: immediate result
8305
from check function */
8307
const char* format_name_in;
8308
const char** format_name_out;
8312
ut_a(var_ptr != NULL);
8314
format_name_in = *static_cast<const char*const*>(save);
8316
if (!format_name_in) {
8321
format_id = innobase_file_format_name_lookup(format_name_in);
8323
if (format_id > DICT_TF_FORMAT_MAX) {
8324
/* DEFAULT is "on", which is invalid at runtime. */
8325
push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
8327
"Ignoring SET innodb_file_format=%s",
8332
format_name_out = static_cast<const char**>(var_ptr);
8334
/* Update the max format id in the system tablespace. */
8335
if (trx_sys_file_format_max_set(format_id, format_name_out)) {
8336
ut_print_timestamp(stderr);
8338
" [Info] InnoDB: the file format in the system "
8339
"tablespace is now set to %s.\n", *format_name_out);
8343
/****************************************************************//**
8344
Update the system variable innodb_adaptive_hash_index using the "saved"
8345
value. This function is registered as a callback with MySQL. */
8348
innodb_adaptive_hash_index_update(
8349
/*==============================*/
8350
Session* , /*!< in: thread handle */
8351
drizzle_sys_var* , /*!< in: pointer to
8353
void* , /*!< out: where the
8354
formal string goes */
8355
const void* save) /*!< in: immediate result
8356
from check function */
8358
if (*(bool*) save) {
8359
btr_search_enable();
8361
btr_search_disable();
8365
/*************************************************************//**
8366
Check if it is a valid value of innodb_change_buffering. This function is
8367
registered as a callback with MySQL.
8368
@return 0 for valid innodb_change_buffering */
8371
innodb_change_buffering_validate(
8372
/*=============================*/
8373
Session* , /*!< in: thread handle */
8374
drizzle_sys_var* , /*!< in: pointer to system
8376
void* save, /*!< out: immediate result
8377
for update function */
8378
drizzle_value* value) /*!< in: incoming string */
8380
const char* change_buffering_input;
8381
char buff[STRING_BUFFER_USUAL_SIZE];
8382
int len = sizeof(buff);
8385
ut_a(value != NULL);
8387
change_buffering_input = value->val_str(value, buff, &len);
8389
if (change_buffering_input != NULL) {
8392
for (use = 0; use < UT_ARR_SIZE(innobase_change_buffering_values);
8394
if (!innobase_strcasecmp(
8395
change_buffering_input,
8396
innobase_change_buffering_values[use])) {
8397
*(ibuf_use_t*) save = (ibuf_use_t) use;
8406
/****************************************************************//**
8407
Update the system variable innodb_change_buffering using the "saved"
8408
value. This function is registered as a callback with MySQL. */
8411
innodb_change_buffering_update(
8412
/*===========================*/
8413
Session* , /*!< in: thread handle */
8414
drizzle_sys_var* , /*!< in: pointer to
8416
void* var_ptr, /*!< out: where the
8417
formal string goes */
8418
const void* save) /*!< in: immediate result
8419
from check function */
8421
ut_a(var_ptr != NULL);
8423
ut_a((*(ibuf_use_t*) save) < IBUF_USE_COUNT);
8425
ibuf_use = *(const ibuf_use_t*) save;
8427
*(const char**) var_ptr = innobase_change_buffering_values[ibuf_use];
8430
/* plugin options */
8431
static DRIZZLE_SYSVAR_BOOL(checksums, innobase_use_checksums,
8432
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8433
"Enable InnoDB checksums validation (enabled by default). "
8434
"Disable with --skip-innodb-checksums.",
8437
static DRIZZLE_SYSVAR_STR(data_home_dir, innobase_data_home_dir,
8438
PLUGIN_VAR_READONLY,
8439
"The common part for InnoDB table spaces.",
8442
static DRIZZLE_SYSVAR_BOOL(doublewrite, innobase_use_doublewrite,
8443
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8444
"Enable InnoDB doublewrite buffer (enabled by default). "
8445
"Disable with --skip-innodb-doublewrite.",
8448
static DRIZZLE_SYSVAR_ULONG(io_capacity, srv_io_capacity,
8449
PLUGIN_VAR_RQCMDARG,
8450
"Number of IOPs the server can do. Tunes the background IO rate",
8451
NULL, NULL, 200, 100, ~0L, 0);
8453
static DRIZZLE_SYSVAR_ULONG(fast_shutdown, innobase_fast_shutdown,
8454
PLUGIN_VAR_OPCMDARG,
8455
"Speeds up the shutdown process of the InnoDB storage engine. Possible "
8456
"values are 0, 1 (faster)"
8457
" or 2 (fastest - crash-like)"
8459
NULL, NULL, 1, 0, 2, 0);
8461
static DRIZZLE_SYSVAR_BOOL(file_per_table, srv_file_per_table,
8462
PLUGIN_VAR_NOCMDARG,
8463
"Stores each InnoDB table to an .ibd file in the database dir.",
8466
static DRIZZLE_SYSVAR_STR(file_format, innobase_file_format_name,
8467
PLUGIN_VAR_RQCMDARG,
8468
"File format to use for new tables in .ibd files.",
8469
innodb_file_format_name_validate,
8470
innodb_file_format_name_update, "Antelope");
8472
static DRIZZLE_SYSVAR_STR(file_format_check, innobase_file_format_check,
8473
PLUGIN_VAR_OPCMDARG,
8474
"The highest file format in the tablespace.",
8475
innodb_file_format_check_validate,
8476
innodb_file_format_check_update,
8479
static DRIZZLE_SYSVAR_ULONG(flush_log_at_trx_commit, srv_flush_log_at_trx_commit,
8480
PLUGIN_VAR_OPCMDARG,
8481
"Set to 0 (write and flush once per second),"
8482
" 1 (write and flush at each commit)"
8483
" or 2 (write at commit, flush once per second).",
8484
NULL, NULL, 1, 0, 2, 0);
8486
static DRIZZLE_SYSVAR_STR(flush_method, innobase_unix_file_flush_method,
8487
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8488
"With which method to flush data.", NULL, NULL, NULL);
8490
#ifdef UNIV_LOG_ARCHIVE
8491
static DRIZZLE_SYSVAR_STR(log_arch_dir, innobase_log_arch_dir,
8492
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8493
"Where full logs should be archived.", NULL, NULL, NULL);
8495
static DRIZZLE_SYSVAR_BOOL(log_archive, innobase_log_archive,
8496
PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
8497
"Set to 1 if you want to have logs archived.", NULL, NULL, FALSE);
8498
#endif /* UNIV_LOG_ARCHIVE */
8500
static DRIZZLE_SYSVAR_STR(log_group_home_dir, innobase_log_group_home_dir,
8501
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8502
"Path to InnoDB log files.", NULL, NULL, NULL);
8504
static DRIZZLE_SYSVAR_ULONG(max_dirty_pages_pct, srv_max_buf_pool_modified_pct,
8505
PLUGIN_VAR_RQCMDARG,
8506
"Percentage of dirty pages allowed in bufferpool.",
8507
NULL, NULL, 75, 0, 99, 0);
8509
static DRIZZLE_SYSVAR_BOOL(adaptive_flushing, srv_adaptive_flushing,
8510
PLUGIN_VAR_NOCMDARG,
8511
"Attempt flushing dirty pages to avoid IO bursts at checkpoints.",
8514
static DRIZZLE_SYSVAR_ULONG(max_purge_lag, srv_max_purge_lag,
8515
PLUGIN_VAR_RQCMDARG,
8516
"Desired maximum length of the purge queue (0 = no limit)",
8517
NULL, NULL, 0, 0, ~0L, 0);
8519
static DRIZZLE_SYSVAR_BOOL(rollback_on_timeout, innobase_rollback_on_timeout,
8520
PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_READONLY,
8521
"Roll back the complete transaction on lock wait timeout, for 4.x compatibility (disabled by default)",
8524
static DRIZZLE_SYSVAR_BOOL(status_file, innobase_create_status_file,
8525
PLUGIN_VAR_OPCMDARG | PLUGIN_VAR_NOSYSVAR,
8526
"Enable SHOW INNODB STATUS output in the innodb_status.<pid> file",
8529
static DRIZZLE_SYSVAR_BOOL(stats_on_metadata, innobase_stats_on_metadata,
8530
PLUGIN_VAR_OPCMDARG,
8531
"Enable statistics gathering for metadata commands such as SHOW TABLE STATUS (on by default)",
8534
static DRIZZLE_SYSVAR_ULONGLONG(stats_sample_pages, srv_stats_sample_pages,
8535
PLUGIN_VAR_RQCMDARG,
8536
"The number of index pages to sample when calculating statistics (default 8)",
8537
NULL, NULL, 8, 1, ~0ULL, 0);
8539
static DRIZZLE_SYSVAR_BOOL(adaptive_hash_index, btr_search_enabled,
8540
PLUGIN_VAR_OPCMDARG,
8541
"Enable InnoDB adaptive hash index (enabled by default). "
8542
"Disable with --skip-innodb-adaptive-hash-index.",
8543
NULL, innodb_adaptive_hash_index_update, TRUE);
8545
static DRIZZLE_SYSVAR_ULONG(replication_delay, srv_replication_delay,
8546
PLUGIN_VAR_RQCMDARG,
8547
"Replication thread delay (ms) on the slave server if "
8548
"innodb_thread_concurrency is reached (0 by default)",
8549
NULL, NULL, 0, 0, ~0UL, 0);
8551
static DRIZZLE_SYSVAR_LONG(additional_mem_pool_size, innobase_additional_mem_pool_size,
8552
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8553
"Size of a memory pool InnoDB uses to store data dictionary information and other internal data structures.",
8554
NULL, NULL, 8*1024*1024L, 512*1024L, LONG_MAX, 1024);
8556
static DRIZZLE_SYSVAR_UINT(autoextend_increment, srv_auto_extend_increment,
8557
PLUGIN_VAR_RQCMDARG,
8558
"Data file autoextend increment in megabytes",
8559
NULL, NULL, 8L, 1L, 1000L, 0);
8561
static DRIZZLE_SYSVAR_LONGLONG(buffer_pool_size, innobase_buffer_pool_size,
8562
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8563
"The size of the memory buffer InnoDB uses to cache data and indexes of its tables.",
8564
NULL, NULL, 128*1024*1024L, 5*1024*1024L, INT64_MAX, 1024*1024L);
8566
static DRIZZLE_SYSVAR_ULONG(commit_concurrency, innobase_commit_concurrency,
8567
PLUGIN_VAR_RQCMDARG,
8568
"Helps in performance tuning in heavily concurrent environments.",
8569
innobase_commit_concurrency_validate, NULL, 0, 0, 1000, 0);
8571
static DRIZZLE_SYSVAR_ULONG(concurrency_tickets, srv_n_free_tickets_to_enter,
8572
PLUGIN_VAR_RQCMDARG,
8573
"Number of times a thread is allowed to enter InnoDB within the same SQL query after it has once got the ticket",
8574
NULL, NULL, 500L, 1L, ~0L, 0);
8576
static DRIZZLE_SYSVAR_LONG(file_io_threads, innobase_file_io_threads,
8577
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8578
"Number of file I/O threads in InnoDB.",
8579
NULL, NULL, 4, 4, 64, 0);
8581
static DRIZZLE_SYSVAR_ULONG(read_io_threads, innobase_read_io_threads,
8582
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8583
"Number of background read I/O threads in InnoDB.",
8584
NULL, NULL, 4, 1, 64, 0);
8586
static DRIZZLE_SYSVAR_ULONG(write_io_threads, innobase_write_io_threads,
8587
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8588
"Number of background write I/O threads in InnoDB.",
8589
NULL, NULL, 4, 1, 64, 0);
8591
static DRIZZLE_SYSVAR_LONG(force_recovery, innobase_force_recovery,
8592
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8593
"Helps to save your data in case the disk image of the database becomes corrupt.",
8594
NULL, NULL, 0, 0, 6, 0);
8596
static DRIZZLE_SYSVAR_LONG(log_buffer_size, innobase_log_buffer_size,
8597
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8598
"The size of the buffer which InnoDB uses to write log to the log files on disk.",
8599
NULL, NULL, 8*1024*1024L, 256*1024L, LONG_MAX, 1024);
8601
static DRIZZLE_SYSVAR_LONGLONG(log_file_size, innobase_log_file_size,
8602
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8603
"Size of each log file in a log group.",
8604
NULL, NULL, 5*1024*1024L, 1*1024*1024L, INT64_MAX, 1024*1024L);
8606
static DRIZZLE_SYSVAR_LONG(log_files_in_group, innobase_log_files_in_group,
8607
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8608
"Number of log files in the log group. InnoDB writes to the files in a circular fashion. Value 3 is recommended here.",
8609
NULL, NULL, 2, 2, 100, 0);
8611
static DRIZZLE_SYSVAR_LONG(mirrored_log_groups, innobase_mirrored_log_groups,
8612
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8613
"Number of identical copies of log groups we keep for the database. Currently this should be set to 1.",
8614
NULL, NULL, 1, 1, 10, 0);
8616
static DRIZZLE_SYSVAR_LONG(open_files, innobase_open_files,
8617
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8618
"How many files at the maximum InnoDB keeps open at the same time.",
8619
NULL, NULL, 300L, 10L, LONG_MAX, 0);
8621
static DRIZZLE_SYSVAR_ULONG(sync_spin_loops, srv_n_spin_wait_rounds,
8622
PLUGIN_VAR_RQCMDARG,
8623
"Count of spin-loop rounds in InnoDB mutexes (30 by default)",
8624
NULL, NULL, 30L, 0L, ~0L, 0);
8626
static DRIZZLE_SYSVAR_ULONG(spin_wait_delay, srv_spin_wait_delay,
8627
PLUGIN_VAR_OPCMDARG,
8628
"Maximum delay between polling for a spin lock (6 by default)",
8629
NULL, NULL, 6L, 0L, ~0L, 0);
8631
static DRIZZLE_SYSVAR_ULONG(thread_concurrency, srv_thread_concurrency,
8632
PLUGIN_VAR_RQCMDARG,
8633
"Helps in performance tuning in heavily concurrent environments. Sets the maximum number of threads allowed inside InnoDB. Value 0 will disable the thread throttling.",
8634
NULL, NULL, 0, 0, 1000, 0);
8636
static DRIZZLE_SYSVAR_ULONG(thread_sleep_delay, srv_thread_sleep_delay,
8637
PLUGIN_VAR_RQCMDARG,
8638
"Time of innodb thread sleeping before joining InnoDB queue (usec). Value 0 disable a sleep",
8639
NULL, NULL, 10000L, 0L, ~0L, 0);
8641
static DRIZZLE_SYSVAR_STR(data_file_path, innobase_data_file_path,
8642
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8643
"Path to individual files and their sizes.",
8646
static DRIZZLE_SYSVAR_LONG(autoinc_lock_mode, innobase_autoinc_lock_mode,
8647
PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
8648
"The AUTOINC lock modes supported by InnoDB: "
8649
"0 => Old style AUTOINC locking (for backward"
8651
"1 => New style AUTOINC locking "
8652
"2 => No AUTOINC locking (unsafe for SBR)",
8654
AUTOINC_NO_LOCKING, /* Default setting */
8655
AUTOINC_OLD_STYLE_LOCKING, /* Minimum value */
8656
AUTOINC_NO_LOCKING, 0); /* Maximum value */
8658
static DRIZZLE_SYSVAR_STR(version, innodb_version_str,
8659
PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_READONLY,
8660
"InnoDB version", NULL, NULL, INNODB_VERSION_STR);
8662
static DRIZZLE_SYSVAR_BOOL(use_sys_malloc, srv_use_sys_malloc,
8663
PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
8664
"Use OS memory allocator instead of InnoDB's internal memory allocator",
8667
static DRIZZLE_SYSVAR_STR(change_buffering, innobase_change_buffering,
8668
PLUGIN_VAR_RQCMDARG,
8669
"Buffer changes to reduce random access: "
8670
"OFF, ON, inserting, deleting, changing, or purging.",
8671
innodb_change_buffering_validate,
8672
innodb_change_buffering_update, NULL);
8674
static DRIZZLE_SYSVAR_ULONG(read_ahead_threshold, srv_read_ahead_threshold,
8675
PLUGIN_VAR_RQCMDARG,
8676
"Number of pages that must be accessed sequentially for InnoDB to"
8677
"trigger a readahead.",
8678
NULL, NULL, 56, 0, 64, 0);
8680
static drizzle_sys_var* innobase_system_variables[]= {
8681
DRIZZLE_SYSVAR(additional_mem_pool_size),
8682
DRIZZLE_SYSVAR(autoextend_increment),
8683
DRIZZLE_SYSVAR(buffer_pool_size),
8684
DRIZZLE_SYSVAR(checksums),
8685
DRIZZLE_SYSVAR(commit_concurrency),
8686
DRIZZLE_SYSVAR(concurrency_tickets),
8687
DRIZZLE_SYSVAR(data_file_path),
8688
DRIZZLE_SYSVAR(data_home_dir),
8689
DRIZZLE_SYSVAR(doublewrite),
8690
DRIZZLE_SYSVAR(fast_shutdown),
8691
DRIZZLE_SYSVAR(file_io_threads),
8692
DRIZZLE_SYSVAR(read_io_threads),
8693
DRIZZLE_SYSVAR(write_io_threads),
8694
DRIZZLE_SYSVAR(file_per_table),
8695
DRIZZLE_SYSVAR(file_format),
8696
DRIZZLE_SYSVAR(file_format_check),
8697
DRIZZLE_SYSVAR(flush_log_at_trx_commit),
8698
DRIZZLE_SYSVAR(flush_method),
8699
DRIZZLE_SYSVAR(force_recovery),
8700
DRIZZLE_SYSVAR(lock_wait_timeout),
8701
#ifdef UNIV_LOG_ARCHIVE
8702
DRIZZLE_SYSVAR(log_arch_dir),
8703
DRIZZLE_SYSVAR(log_archive),
8704
#endif /* UNIV_LOG_ARCHIVE */
8705
DRIZZLE_SYSVAR(log_buffer_size),
8706
DRIZZLE_SYSVAR(log_file_size),
8707
DRIZZLE_SYSVAR(log_files_in_group),
8708
DRIZZLE_SYSVAR(log_group_home_dir),
8709
DRIZZLE_SYSVAR(max_dirty_pages_pct),
8710
DRIZZLE_SYSVAR(max_purge_lag),
8711
DRIZZLE_SYSVAR(adaptive_flushing),
8712
DRIZZLE_SYSVAR(mirrored_log_groups),
8713
DRIZZLE_SYSVAR(open_files),
8714
DRIZZLE_SYSVAR(rollback_on_timeout),
8715
DRIZZLE_SYSVAR(stats_on_metadata),
8716
DRIZZLE_SYSVAR(stats_sample_pages),
8717
DRIZZLE_SYSVAR(adaptive_hash_index),
8718
DRIZZLE_SYSVAR(replication_delay),
8719
DRIZZLE_SYSVAR(status_file),
8720
DRIZZLE_SYSVAR(strict_mode),
8721
DRIZZLE_SYSVAR(support_xa),
8722
DRIZZLE_SYSVAR(sync_spin_loops),
8723
DRIZZLE_SYSVAR(spin_wait_delay),
8724
DRIZZLE_SYSVAR(table_locks),
8725
DRIZZLE_SYSVAR(thread_concurrency),
8726
DRIZZLE_SYSVAR(thread_sleep_delay),
8727
DRIZZLE_SYSVAR(autoinc_lock_mode),
8728
DRIZZLE_SYSVAR(version),
8729
DRIZZLE_SYSVAR(use_sys_malloc),
8730
DRIZZLE_SYSVAR(change_buffering),
8731
DRIZZLE_SYSVAR(read_ahead_threshold),
8732
DRIZZLE_SYSVAR(io_capacity),
9277
8736
DRIZZLE_DECLARE_PLUGIN
added
removed
plugin/innobase/handler/ha_innodb.cc
