diff --git a/src/share/system_variable/ob_sys_var_class_type.h b/src/share/system_variable/ob_sys_var_class_type.h index ff5112f820..830a942d8d 100644 --- a/src/share/system_variable/ob_sys_var_class_type.h +++ b/src/share/system_variable/ob_sys_var_class_type.h @@ -286,6 +286,59 @@ enum ObSysVarClassType SYS_VAR_CARDINALITY_ESTIMATION_MODEL = 10178, SYS_VAR_QUERY_REWRITE_ENABLED = 10179, SYS_VAR_QUERY_REWRITE_INTEGRITY = 10180, + SYS_VAR_FLUSH = 10181, + SYS_VAR_FLUSH_TIME = 10182, + SYS_VAR_INNODB_ADAPTIVE_FLUSHING = 10183, + SYS_VAR_INNODB_ADAPTIVE_FLUSHING_LWM = 10184, + SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX = 10185, + SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX_PARTS = 10186, + SYS_VAR_INNODB_ADAPTIVE_MAX_SLEEP_DELAY = 10187, + SYS_VAR_INNODB_AUTOEXTEND_INCREMENT = 10188, + SYS_VAR_INNODB_BACKGROUND_DROP_LIST_EMPTY = 10189, + SYS_VAR_INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN = 10190, + SYS_VAR_INNODB_BUFFER_POOL_DUMP_NOW = 10191, + SYS_VAR_INNODB_BUFFER_POOL_DUMP_PCT = 10192, + SYS_VAR_INNODB_BUFFER_POOL_FILENAME = 10193, + SYS_VAR_INNODB_BUFFER_POOL_LOAD_ABORT = 10194, + SYS_VAR_INNODB_BUFFER_POOL_LOAD_NOW = 10195, + SYS_VAR_INNODB_BUFFER_POOL_SIZE = 10196, + SYS_VAR_INNODB_CHANGE_BUFFER_MAX_SIZE = 10197, + SYS_VAR_INNODB_CHANGE_BUFFERING = 10198, + SYS_VAR_INNODB_CHECKSUM_ALGORITHM = 10199, + SYS_VAR_INNODB_CMP_PER_INDEX_ENABLED = 10200, + SYS_VAR_INNODB_COMMIT_CONCURRENCY = 10201, + SYS_VAR_INNODB_COMPRESSION_FAILURE_THRESHOLD_PCT = 10202, + SYS_VAR_INNODB_COMPRESSION_LEVEL = 10203, + SYS_VAR_INNODB_COMPRESSION_PAD_PCT_MAX = 10204, + SYS_VAR_INNODB_CONCURRENCY_TICKETS = 10205, + SYS_VAR_INNODB_DEFAULT_ROW_FORMAT = 10206, + SYS_VAR_INNODB_DISABLE_SORT_FILE_CACHE = 10207, + SYS_VAR_INNODB_FILE_FORMAT = 10208, + SYS_VAR_INNODB_FILE_FORMAT_MAX = 10209, + SYS_VAR_INNODB_FILE_PER_TABLE = 10210, + SYS_VAR_INNODB_FILL_FACTOR = 10211, + SYS_VAR_INNODB_FLUSH_NEIGHBORS = 10212, + SYS_VAR_INNODB_FLUSH_SYNC = 10213, + SYS_VAR_INNODB_FLUSHING_AVG_LOOPS = 10214, + SYS_VAR_INNODB_LRU_SCAN_DEPTH = 10215, + SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT = 10216, + SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT_LWM = 10217, + SYS_VAR_INNODB_MAX_PURGE_LAG = 10218, + SYS_VAR_INNODB_MAX_PURGE_LAG_DELAY = 10219, + SYS_VAR_HAVE_SYMLINK = 10220, + SYS_VAR_IGNORE_BUILTIN_INNODB = 10221, + SYS_VAR_INNODB_BUFFER_POOL_CHUNK_SIZE = 10222, + SYS_VAR_INNODB_BUFFER_POOL_INSTANCES = 10223, + SYS_VAR_INNODB_BUFFER_POOL_LOAD_AT_STARTUP = 10224, + SYS_VAR_INNODB_CHECKSUMS = 10225, + SYS_VAR_INNODB_DOUBLEWRITE = 10226, + SYS_VAR_INNODB_FILE_FORMAT_CHECK = 10227, + SYS_VAR_INNODB_FLUSH_METHOD = 10228, + SYS_VAR_INNODB_FORCE_LOAD_CORRUPTED = 10229, + SYS_VAR_INNODB_PAGE_SIZE = 10230, + SYS_VAR_INNODB_VERSION = 10231, + SYS_VAR_MYISAM_MMAP_SIZE = 10232, + SYS_VAR_TABLE_OPEN_CACHE_INSTANCES = 10233, }; } diff --git a/src/share/system_variable/ob_system_variable_alias.h b/src/share/system_variable/ob_system_variable_alias.h index 0a8386d915..7c55d31c6a 100644 --- a/src/share/system_variable/ob_system_variable_alias.h +++ b/src/share/system_variable/ob_system_variable_alias.h @@ -281,6 +281,59 @@ namespace share static const char* const OB_SV_CARDINALITY_ESTIMATION_MODEL = "cardinality_estimation_model"; static const char* const OB_SV_QUERY_REWRITE_ENABLED = "query_rewrite_enabled"; static const char* const OB_SV_QUERY_REWRITE_INTEGRITY = "query_rewrite_integrity"; + static const char* const OB_SV_FLUSH = "flush"; + static const char* const OB_SV_FLUSH_TIME = "flush_time"; + static const char* const OB_SV_INNODB_ADAPTIVE_FLUSHING = "innodb_adaptive_flushing"; + static const char* const OB_SV_INNODB_ADAPTIVE_FLUSHING_LWM = "innodb_adaptive_flushing_lwm"; + static const char* const OB_SV_INNODB_ADAPTIVE_HASH_INDEX = "innodb_adaptive_hash_index"; + static const char* const OB_SV_INNODB_ADAPTIVE_HASH_INDEX_PARTS = "innodb_adaptive_hash_index_parts"; + static const char* const OB_SV_INNODB_ADAPTIVE_MAX_SLEEP_DELAY = "innodb_adaptive_max_sleep_delay"; + static const char* const OB_SV_INNODB_AUTOEXTEND_INCREMENT = "innodb_autoextend_increment"; + static const char* const OB_SV_INNODB_BACKGROUND_DROP_LIST_EMPTY = "innodb_background_drop_list_empty"; + static const char* const OB_SV_INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN = "innodb_buffer_pool_dump_at_shutdown"; + static const char* const OB_SV_INNODB_BUFFER_POOL_DUMP_NOW = "innodb_buffer_pool_dump_now"; + static const char* const OB_SV_INNODB_BUFFER_POOL_DUMP_PCT = "innodb_buffer_pool_dump_pct"; + static const char* const OB_SV_INNODB_BUFFER_POOL_FILENAME = "innodb_buffer_pool_filename"; + static const char* const OB_SV_INNODB_BUFFER_POOL_LOAD_ABORT = "innodb_buffer_pool_load_abort"; + static const char* const OB_SV_INNODB_BUFFER_POOL_LOAD_NOW = "innodb_buffer_pool_load_now"; + static const char* const OB_SV_INNODB_BUFFER_POOL_SIZE = "innodb_buffer_pool_size"; + static const char* const OB_SV_INNODB_CHANGE_BUFFER_MAX_SIZE = "innodb_change_buffer_max_size"; + static const char* const OB_SV_INNODB_CHANGE_BUFFERING = "innodb_change_buffering"; + static const char* const OB_SV_INNODB_CHECKSUM_ALGORITHM = "innodb_checksum_algorithm"; + static const char* const OB_SV_INNODB_CMP_PER_INDEX_ENABLED = "innodb_cmp_per_index_enabled"; + static const char* const OB_SV_INNODB_COMMIT_CONCURRENCY = "innodb_commit_concurrency"; + static const char* const OB_SV_INNODB_COMPRESSION_FAILURE_THRESHOLD_PCT = "innodb_compression_failure_threshold_pct"; + static const char* const OB_SV_INNODB_COMPRESSION_LEVEL = "innodb_compression_level"; + static const char* const OB_SV_INNODB_COMPRESSION_PAD_PCT_MAX = "innodb_compression_pad_pct_max"; + static const char* const OB_SV_INNODB_CONCURRENCY_TICKETS = "innodb_concurrency_tickets"; + static const char* const OB_SV_INNODB_DEFAULT_ROW_FORMAT = "innodb_default_row_format"; + static const char* const OB_SV_INNODB_DISABLE_SORT_FILE_CACHE = "innodb_disable_sort_file_cache"; + static const char* const OB_SV_INNODB_FILE_FORMAT = "innodb_file_format"; + static const char* const OB_SV_INNODB_FILE_FORMAT_MAX = "innodb_file_format_max"; + static const char* const OB_SV_INNODB_FILE_PER_TABLE = "innodb_file_per_table"; + static const char* const OB_SV_INNODB_FILL_FACTOR = "innodb_fill_factor"; + static const char* const OB_SV_INNODB_FLUSH_NEIGHBORS = "innodb_flush_neighbors"; + static const char* const OB_SV_INNODB_FLUSH_SYNC = "innodb_flush_sync"; + static const char* const OB_SV_INNODB_FLUSHING_AVG_LOOPS = "innodb_flushing_avg_loops"; + static const char* const OB_SV_INNODB_LRU_SCAN_DEPTH = "innodb_lru_scan_depth"; + static const char* const OB_SV_INNODB_MAX_DIRTY_PAGES_PCT = "innodb_max_dirty_pages_pct"; + static const char* const OB_SV_INNODB_MAX_DIRTY_PAGES_PCT_LWM = "innodb_max_dirty_pages_pct_lwm"; + static const char* const OB_SV_INNODB_MAX_PURGE_LAG = "innodb_max_purge_lag"; + static const char* const OB_SV_INNODB_MAX_PURGE_LAG_DELAY = "innodb_max_purge_lag_delay"; + static const char* const OB_SV_HAVE_SYMLINK = "have_symlink"; + static const char* const OB_SV_IGNORE_BUILTIN_INNODB = "ignore_builtin_innodb"; + static const char* const OB_SV_INNODB_BUFFER_POOL_CHUNK_SIZE = "innodb_buffer_pool_chunk_size"; + static const char* const OB_SV_INNODB_BUFFER_POOL_INSTANCES = "innodb_buffer_pool_instances"; + static const char* const OB_SV_INNODB_BUFFER_POOL_LOAD_AT_STARTUP = "innodb_buffer_pool_load_at_startup"; + static const char* const OB_SV_INNODB_CHECKSUMS = "innodb_checksums"; + static const char* const OB_SV_INNODB_DOUBLEWRITE = "innodb_doublewrite"; + static const char* const OB_SV_INNODB_FILE_FORMAT_CHECK = "innodb_file_format_check"; + static const char* const OB_SV_INNODB_FLUSH_METHOD = "innodb_flush_method"; + static const char* const OB_SV_INNODB_FORCE_LOAD_CORRUPTED = "innodb_force_load_corrupted"; + static const char* const OB_SV_INNODB_PAGE_SIZE = "innodb_page_size"; + static const char* const OB_SV_INNODB_VERSION = "innodb_version"; + static const char* const OB_SV_MYISAM_MMAP_SIZE = "myisam_mmap_size"; + static const char* const OB_SV_TABLE_OPEN_CACHE_INSTANCES = "table_open_cache_instances"; } } diff --git a/src/share/system_variable/ob_system_variable_factory.cpp b/src/share/system_variable/ob_system_variable_factory.cpp index eebfa354d2..b012573ee7 100644 --- a/src/share/system_variable/ob_system_variable_factory.cpp +++ b/src/share/system_variable/ob_system_variable_factory.cpp @@ -160,6 +160,163 @@ const char *ObSysVarQueryRewriteIntegrity::QUERY_REWRITE_INTEGRITY_NAMES[] = { "STALE_TOLERATED", 0 }; +const char *ObSysVarFlush::FLUSH_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbAdaptiveFlushing::INNODB_ADAPTIVE_FLUSHING_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbAdaptiveHashIndex::INNODB_ADAPTIVE_HASH_INDEX_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbBackgroundDropListEmpty::INNODB_BACKGROUND_DROP_LIST_EMPTY_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbBufferPoolDumpAtShutdown::INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbBufferPoolDumpNow::INNODB_BUFFER_POOL_DUMP_NOW_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbBufferPoolLoadAbort::INNODB_BUFFER_POOL_LOAD_ABORT_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbBufferPoolLoadNow::INNODB_BUFFER_POOL_LOAD_NOW_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbChangeBuffering::INNODB_CHANGE_BUFFERING_NAMES[] = { + "none", + "inserts", + "deletes", + "changes", + "purges", + "all", + 0 +}; +const char *ObSysVarInnodbChecksumAlgorithm::INNODB_CHECKSUM_ALGORITHM_NAMES[] = { + "crc32", + "strict_crc32", + "innodb", + "strict_innodb", + "none", + "strict_none", + 0 +}; +const char *ObSysVarInnodbCmpPerIndexEnabled::INNODB_CMP_PER_INDEX_ENABLED_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbDefaultRowFormat::INNODB_DEFAULT_ROW_FORMAT_NAMES[] = { + "REDUNDANT", + "COMPACT", + "DYNAMIC", + 0 +}; +const char *ObSysVarInnodbDisableSortFileCache::INNODB_DISABLE_SORT_FILE_CACHE_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbFileFormat::INNODB_FILE_FORMAT_NAMES[] = { + "Antelope", + "Barracuda", + 0 +}; +const char *ObSysVarInnodbFileFormatMax::INNODB_FILE_FORMAT_MAX_NAMES[] = { + "Antelope", + "Barracuda", + 0 +}; +const char *ObSysVarInnodbFilePerTable::INNODB_FILE_PER_TABLE_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbFlushNeighbors::INNODB_FLUSH_NEIGHBORS_NAMES[] = { + "0", + "1", + "2", + 0 +}; +const char *ObSysVarInnodbFlushSync::INNODB_FLUSH_SYNC_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarHaveSymlink::HAVE_SYMLINK_NAMES[] = { + "NO", + "YES", + 0 +}; +const char *ObSysVarIgnoreBuiltinInnodb::IGNORE_BUILTIN_INNODB_NAMES[] = { + "NO", + "YES", + 0 +}; +const char *ObSysVarInnodbBufferPoolLoadAtStartup::INNODB_BUFFER_POOL_LOAD_AT_STARTUP_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbChecksums::INNODB_CHECKSUMS_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbDoublewrite::INNODB_DOUBLEWRITE_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbFileFormatCheck::INNODB_FILE_FORMAT_CHECK_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbFlushMethod::INNODB_FLUSH_METHOD_NAMES[] = { + "null", + "fsync", + "O_DSYNC", + "littlesync", + "nosync", + "O_DIRECT", + "O_DIRECT_NO_FSYNC", + 0 +}; +const char *ObSysVarInnodbForceLoadCorrupted::INNODB_FORCE_LOAD_CORRUPTED_NAMES[] = { + "OFF", + "ON", + 0 +}; +const char *ObSysVarInnodbPageSize::INNODB_PAGE_SIZE_NAMES[] = { + "4096", + "8192", + "16384", + "32768", + "65536", + 0 +}; +const char *ObSysVarInnodbVersion::INNODB_VERSION_NAMES[] = { + "5.7.38", + 0 +}; const char *ObSysVarFactory::SYS_VAR_NAMES_SORTED_BY_NAME[] = { "_aggregation_optimization_settings", @@ -235,6 +392,8 @@ const char *ObSysVarFactory::SYS_VAR_NAMES_SORTED_BY_NAME[] = { "error_count", "error_on_overlap_time", "explicit_defaults_for_timestamp", + "flush", + "flush_time", "foreign_key_checks", "general_log", "group_concat_max_len", @@ -242,20 +401,69 @@ const char *ObSysVarFactory::SYS_VAR_NAMES_SORTED_BY_NAME[] = { "have_profiling", "have_query_cache", "have_ssl", + "have_symlink", "hostname", "identity", + "ignore_builtin_innodb", "init_connect", + "innodb_adaptive_flushing", + "innodb_adaptive_flushing_lwm", + "innodb_adaptive_hash_index", + "innodb_adaptive_hash_index_parts", + "innodb_adaptive_max_sleep_delay", + "innodb_autoextend_increment", + "innodb_background_drop_list_empty", + "innodb_buffer_pool_chunk_size", + "innodb_buffer_pool_dump_at_shutdown", + "innodb_buffer_pool_dump_now", + "innodb_buffer_pool_dump_pct", + "innodb_buffer_pool_filename", + "innodb_buffer_pool_instances", + "innodb_buffer_pool_load_abort", + "innodb_buffer_pool_load_at_startup", + "innodb_buffer_pool_load_now", + "innodb_buffer_pool_size", + "innodb_change_buffer_max_size", + "innodb_change_buffering", "innodb_change_buffering_debug", + "innodb_checksum_algorithm", + "innodb_checksums", + "innodb_cmp_per_index_enabled", + "innodb_commit_concurrency", "innodb_compress_debug", + "innodb_compression_failure_threshold_pct", + "innodb_compression_level", + "innodb_compression_pad_pct_max", + "innodb_concurrency_tickets", + "innodb_default_row_format", "innodb_disable_resize_buffer_pool_debug", + "innodb_disable_sort_file_cache", + "innodb_doublewrite", "innodb_fil_make_page_dirty_debug", + "innodb_file_format", + "innodb_file_format_check", + "innodb_file_format_max", + "innodb_file_per_table", + "innodb_fill_factor", + "innodb_flush_method", + "innodb_flush_neighbors", + "innodb_flush_sync", + "innodb_flushing_avg_loops", + "innodb_force_load_corrupted", "innodb_limit_optimistic_insert_debug", + "innodb_lru_scan_depth", + "innodb_max_dirty_pages_pct", + "innodb_max_dirty_pages_pct_lwm", + "innodb_max_purge_lag", + "innodb_max_purge_lag_delay", "innodb_merge_threshold_set_all_debug", + "innodb_page_size", "innodb_saved_page_number_debug", "innodb_stats_persistent", "innodb_strict_mode", "innodb_trx_purge_view_update_only_debug", "innodb_trx_rseg_n_slots_debug", + "innodb_version", "interactive_timeout", "is_result_accurate", "last_insert_id", @@ -273,6 +481,7 @@ const char *ObSysVarFactory::SYS_VAR_NAMES_SORTED_BY_NAME[] = { "max_execution_time", "max_sp_recursion_depth", "max_user_connections", + "myisam_mmap_size", "ncharacter_set_connection", "net_buffer_length", "net_read_timeout", @@ -403,6 +612,7 @@ const char *ObSysVarFactory::SYS_VAR_NAMES_SORTED_BY_NAME[] = { "ssl_key", "stored_program_cache", "system_time_zone", + "table_open_cache_instances", "time_format", "time_zone", "timestamp", @@ -503,6 +713,8 @@ const ObSysVarClassType ObSysVarFactory::SYS_VAR_IDS_SORTED_BY_NAME[] = { SYS_VAR_ERROR_COUNT, SYS_VAR_ERROR_ON_OVERLAP_TIME, SYS_VAR_EXPLICIT_DEFAULTS_FOR_TIMESTAMP, + SYS_VAR_FLUSH, + SYS_VAR_FLUSH_TIME, SYS_VAR_FOREIGN_KEY_CHECKS, SYS_VAR_GENERAL_LOG, SYS_VAR_GROUP_CONCAT_MAX_LEN, @@ -510,20 +722,69 @@ const ObSysVarClassType ObSysVarFactory::SYS_VAR_IDS_SORTED_BY_NAME[] = { SYS_VAR_HAVE_PROFILING, SYS_VAR_HAVE_QUERY_CACHE, SYS_VAR_HAVE_SSL, + SYS_VAR_HAVE_SYMLINK, SYS_VAR_HOSTNAME, SYS_VAR_IDENTITY, + SYS_VAR_IGNORE_BUILTIN_INNODB, SYS_VAR_INIT_CONNECT, + SYS_VAR_INNODB_ADAPTIVE_FLUSHING, + SYS_VAR_INNODB_ADAPTIVE_FLUSHING_LWM, + SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX, + SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX_PARTS, + SYS_VAR_INNODB_ADAPTIVE_MAX_SLEEP_DELAY, + SYS_VAR_INNODB_AUTOEXTEND_INCREMENT, + SYS_VAR_INNODB_BACKGROUND_DROP_LIST_EMPTY, + SYS_VAR_INNODB_BUFFER_POOL_CHUNK_SIZE, + SYS_VAR_INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN, + SYS_VAR_INNODB_BUFFER_POOL_DUMP_NOW, + SYS_VAR_INNODB_BUFFER_POOL_DUMP_PCT, + SYS_VAR_INNODB_BUFFER_POOL_FILENAME, + SYS_VAR_INNODB_BUFFER_POOL_INSTANCES, + SYS_VAR_INNODB_BUFFER_POOL_LOAD_ABORT, + SYS_VAR_INNODB_BUFFER_POOL_LOAD_AT_STARTUP, + SYS_VAR_INNODB_BUFFER_POOL_LOAD_NOW, + SYS_VAR_INNODB_BUFFER_POOL_SIZE, + SYS_VAR_INNODB_CHANGE_BUFFER_MAX_SIZE, + SYS_VAR_INNODB_CHANGE_BUFFERING, SYS_VAR_INNODB_CHANGE_BUFFERING_DEBUG, + SYS_VAR_INNODB_CHECKSUM_ALGORITHM, + SYS_VAR_INNODB_CHECKSUMS, + SYS_VAR_INNODB_CMP_PER_INDEX_ENABLED, + SYS_VAR_INNODB_COMMIT_CONCURRENCY, SYS_VAR_INNODB_COMPRESS_DEBUG, + SYS_VAR_INNODB_COMPRESSION_FAILURE_THRESHOLD_PCT, + SYS_VAR_INNODB_COMPRESSION_LEVEL, + SYS_VAR_INNODB_COMPRESSION_PAD_PCT_MAX, + SYS_VAR_INNODB_CONCURRENCY_TICKETS, + SYS_VAR_INNODB_DEFAULT_ROW_FORMAT, SYS_VAR_INNODB_DISABLE_RESIZE_BUFFER_POOL_DEBUG, + SYS_VAR_INNODB_DISABLE_SORT_FILE_CACHE, + SYS_VAR_INNODB_DOUBLEWRITE, SYS_VAR_INNODB_FIL_MAKE_PAGE_DIRTY_DEBUG, + SYS_VAR_INNODB_FILE_FORMAT, + SYS_VAR_INNODB_FILE_FORMAT_CHECK, + SYS_VAR_INNODB_FILE_FORMAT_MAX, + SYS_VAR_INNODB_FILE_PER_TABLE, + SYS_VAR_INNODB_FILL_FACTOR, + SYS_VAR_INNODB_FLUSH_METHOD, + SYS_VAR_INNODB_FLUSH_NEIGHBORS, + SYS_VAR_INNODB_FLUSH_SYNC, + SYS_VAR_INNODB_FLUSHING_AVG_LOOPS, + SYS_VAR_INNODB_FORCE_LOAD_CORRUPTED, SYS_VAR_INNODB_LIMIT_OPTIMISTIC_INSERT_DEBUG, + SYS_VAR_INNODB_LRU_SCAN_DEPTH, + SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT, + SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT_LWM, + SYS_VAR_INNODB_MAX_PURGE_LAG, + SYS_VAR_INNODB_MAX_PURGE_LAG_DELAY, SYS_VAR_INNODB_MERGE_THRESHOLD_SET_ALL_DEBUG, + SYS_VAR_INNODB_PAGE_SIZE, SYS_VAR_INNODB_SAVED_PAGE_NUMBER_DEBUG, SYS_VAR_INNODB_STATS_PERSISTENT, SYS_VAR_INNODB_STRICT_MODE, SYS_VAR_INNODB_TRX_PURGE_VIEW_UPDATE_ONLY_DEBUG, SYS_VAR_INNODB_TRX_RSEG_N_SLOTS_DEBUG, + SYS_VAR_INNODB_VERSION, SYS_VAR_INTERACTIVE_TIMEOUT, SYS_VAR_IS_RESULT_ACCURATE, SYS_VAR_LAST_INSERT_ID, @@ -541,6 +802,7 @@ const ObSysVarClassType ObSysVarFactory::SYS_VAR_IDS_SORTED_BY_NAME[] = { SYS_VAR_MAX_EXECUTION_TIME, SYS_VAR_MAX_SP_RECURSION_DEPTH, SYS_VAR_MAX_USER_CONNECTIONS, + SYS_VAR_MYISAM_MMAP_SIZE, SYS_VAR_NCHARACTER_SET_CONNECTION, SYS_VAR_NET_BUFFER_LENGTH, SYS_VAR_NET_READ_TIMEOUT, @@ -671,6 +933,7 @@ const ObSysVarClassType ObSysVarFactory::SYS_VAR_IDS_SORTED_BY_NAME[] = { SYS_VAR_SSL_KEY, SYS_VAR_STORED_PROGRAM_CACHE, SYS_VAR_SYSTEM_TIME_ZONE, + SYS_VAR_TABLE_OPEN_CACHE_INSTANCES, SYS_VAR_TIME_FORMAT, SYS_VAR_TIME_ZONE, SYS_VAR_TIMESTAMP, @@ -962,7 +1225,60 @@ const char *ObSysVarFactory::SYS_VAR_NAMES_SORTED_BY_ID[] = { "ob_security_version", "cardinality_estimation_model", "query_rewrite_enabled", - "query_rewrite_integrity" + "query_rewrite_integrity", + "flush", + "flush_time", + "innodb_adaptive_flushing", + "innodb_adaptive_flushing_lwm", + "innodb_adaptive_hash_index", + "innodb_adaptive_hash_index_parts", + "innodb_adaptive_max_sleep_delay", + "innodb_autoextend_increment", + "innodb_background_drop_list_empty", + "innodb_buffer_pool_dump_at_shutdown", + "innodb_buffer_pool_dump_now", + "innodb_buffer_pool_dump_pct", + "innodb_buffer_pool_filename", + "innodb_buffer_pool_load_abort", + "innodb_buffer_pool_load_now", + "innodb_buffer_pool_size", + "innodb_change_buffer_max_size", + "innodb_change_buffering", + "innodb_checksum_algorithm", + "innodb_cmp_per_index_enabled", + "innodb_commit_concurrency", + "innodb_compression_failure_threshold_pct", + "innodb_compression_level", + "innodb_compression_pad_pct_max", + "innodb_concurrency_tickets", + "innodb_default_row_format", + "innodb_disable_sort_file_cache", + "innodb_file_format", + "innodb_file_format_max", + "innodb_file_per_table", + "innodb_fill_factor", + "innodb_flush_neighbors", + "innodb_flush_sync", + "innodb_flushing_avg_loops", + "innodb_lru_scan_depth", + "innodb_max_dirty_pages_pct", + "innodb_max_dirty_pages_pct_lwm", + "innodb_max_purge_lag", + "innodb_max_purge_lag_delay", + "have_symlink", + "ignore_builtin_innodb", + "innodb_buffer_pool_chunk_size", + "innodb_buffer_pool_instances", + "innodb_buffer_pool_load_at_startup", + "innodb_checksums", + "innodb_doublewrite", + "innodb_file_format_check", + "innodb_flush_method", + "innodb_force_load_corrupted", + "innodb_page_size", + "innodb_version", + "myisam_mmap_size", + "table_open_cache_instances" }; bool ObSysVarFactory::sys_var_name_case_cmp(const char *name1, const ObString &name2) @@ -1396,6 +1712,59 @@ int ObSysVarFactory::create_all_sys_vars() + sizeof(ObSysVarCardinalityEstimationModel) + sizeof(ObSysVarQueryRewriteEnabled) + sizeof(ObSysVarQueryRewriteIntegrity) + + sizeof(ObSysVarFlush) + + sizeof(ObSysVarFlushTime) + + sizeof(ObSysVarInnodbAdaptiveFlushing) + + sizeof(ObSysVarInnodbAdaptiveFlushingLwm) + + sizeof(ObSysVarInnodbAdaptiveHashIndex) + + sizeof(ObSysVarInnodbAdaptiveHashIndexParts) + + sizeof(ObSysVarInnodbAdaptiveMaxSleepDelay) + + sizeof(ObSysVarInnodbAutoextendIncrement) + + sizeof(ObSysVarInnodbBackgroundDropListEmpty) + + sizeof(ObSysVarInnodbBufferPoolDumpAtShutdown) + + sizeof(ObSysVarInnodbBufferPoolDumpNow) + + sizeof(ObSysVarInnodbBufferPoolDumpPct) + + sizeof(ObSysVarInnodbBufferPoolFilename) + + sizeof(ObSysVarInnodbBufferPoolLoadAbort) + + sizeof(ObSysVarInnodbBufferPoolLoadNow) + + sizeof(ObSysVarInnodbBufferPoolSize) + + sizeof(ObSysVarInnodbChangeBufferMaxSize) + + sizeof(ObSysVarInnodbChangeBuffering) + + sizeof(ObSysVarInnodbChecksumAlgorithm) + + sizeof(ObSysVarInnodbCmpPerIndexEnabled) + + sizeof(ObSysVarInnodbCommitConcurrency) + + sizeof(ObSysVarInnodbCompressionFailureThresholdPct) + + sizeof(ObSysVarInnodbCompressionLevel) + + sizeof(ObSysVarInnodbCompressionPadPctMax) + + sizeof(ObSysVarInnodbConcurrencyTickets) + + sizeof(ObSysVarInnodbDefaultRowFormat) + + sizeof(ObSysVarInnodbDisableSortFileCache) + + sizeof(ObSysVarInnodbFileFormat) + + sizeof(ObSysVarInnodbFileFormatMax) + + sizeof(ObSysVarInnodbFilePerTable) + + sizeof(ObSysVarInnodbFillFactor) + + sizeof(ObSysVarInnodbFlushNeighbors) + + sizeof(ObSysVarInnodbFlushSync) + + sizeof(ObSysVarInnodbFlushingAvgLoops) + + sizeof(ObSysVarInnodbLruScanDepth) + + sizeof(ObSysVarInnodbMaxDirtyPagesPct) + + sizeof(ObSysVarInnodbMaxDirtyPagesPctLwm) + + sizeof(ObSysVarInnodbMaxPurgeLag) + + sizeof(ObSysVarInnodbMaxPurgeLagDelay) + + sizeof(ObSysVarHaveSymlink) + + sizeof(ObSysVarIgnoreBuiltinInnodb) + + sizeof(ObSysVarInnodbBufferPoolChunkSize) + + sizeof(ObSysVarInnodbBufferPoolInstances) + + sizeof(ObSysVarInnodbBufferPoolLoadAtStartup) + + sizeof(ObSysVarInnodbChecksums) + + sizeof(ObSysVarInnodbDoublewrite) + + sizeof(ObSysVarInnodbFileFormatCheck) + + sizeof(ObSysVarInnodbFlushMethod) + + sizeof(ObSysVarInnodbForceLoadCorrupted) + + sizeof(ObSysVarInnodbPageSize) + + sizeof(ObSysVarInnodbVersion) + + sizeof(ObSysVarMyisamMmapSize) + + sizeof(ObSysVarTableOpenCacheInstances) ; void *ptr = NULL; if (OB_ISNULL(ptr = allocator_.alloc(total_mem_size))) { @@ -3789,6 +4158,483 @@ int ObSysVarFactory::create_all_sys_vars() ptr = (void *)((char *)ptr + sizeof(ObSysVarQueryRewriteIntegrity)); } } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarFlush())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarFlush", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_FLUSH))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarFlush)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarFlushTime())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarFlushTime", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_FLUSH_TIME))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarFlushTime)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbAdaptiveFlushing())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbAdaptiveFlushing", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_ADAPTIVE_FLUSHING))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbAdaptiveFlushing)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbAdaptiveFlushingLwm())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbAdaptiveFlushingLwm", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_ADAPTIVE_FLUSHING_LWM))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbAdaptiveFlushingLwm)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbAdaptiveHashIndex())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbAdaptiveHashIndex", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbAdaptiveHashIndex)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbAdaptiveHashIndexParts())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbAdaptiveHashIndexParts", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX_PARTS))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbAdaptiveHashIndexParts)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbAdaptiveMaxSleepDelay())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbAdaptiveMaxSleepDelay", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_ADAPTIVE_MAX_SLEEP_DELAY))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbAdaptiveMaxSleepDelay)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbAutoextendIncrement())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbAutoextendIncrement", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_AUTOEXTEND_INCREMENT))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbAutoextendIncrement)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBackgroundDropListEmpty())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBackgroundDropListEmpty", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_BACKGROUND_DROP_LIST_EMPTY))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbBackgroundDropListEmpty)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolDumpAtShutdown())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolDumpAtShutdown", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbBufferPoolDumpAtShutdown)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolDumpNow())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolDumpNow", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_BUFFER_POOL_DUMP_NOW))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbBufferPoolDumpNow)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolDumpPct())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolDumpPct", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_BUFFER_POOL_DUMP_PCT))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbBufferPoolDumpPct)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolFilename())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolFilename", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_BUFFER_POOL_FILENAME))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbBufferPoolFilename)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolLoadAbort())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolLoadAbort", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_BUFFER_POOL_LOAD_ABORT))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbBufferPoolLoadAbort)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolLoadNow())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolLoadNow", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_BUFFER_POOL_LOAD_NOW))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbBufferPoolLoadNow)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolSize())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolSize", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_BUFFER_POOL_SIZE))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbBufferPoolSize)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbChangeBufferMaxSize())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbChangeBufferMaxSize", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_CHANGE_BUFFER_MAX_SIZE))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbChangeBufferMaxSize)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbChangeBuffering())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbChangeBuffering", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_CHANGE_BUFFERING))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbChangeBuffering)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbChecksumAlgorithm())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbChecksumAlgorithm", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_CHECKSUM_ALGORITHM))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbChecksumAlgorithm)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbCmpPerIndexEnabled())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbCmpPerIndexEnabled", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_CMP_PER_INDEX_ENABLED))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbCmpPerIndexEnabled)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbCommitConcurrency())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbCommitConcurrency", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_COMMIT_CONCURRENCY))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbCommitConcurrency)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbCompressionFailureThresholdPct())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbCompressionFailureThresholdPct", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_COMPRESSION_FAILURE_THRESHOLD_PCT))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbCompressionFailureThresholdPct)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbCompressionLevel())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbCompressionLevel", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_COMPRESSION_LEVEL))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbCompressionLevel)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbCompressionPadPctMax())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbCompressionPadPctMax", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_COMPRESSION_PAD_PCT_MAX))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbCompressionPadPctMax)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbConcurrencyTickets())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbConcurrencyTickets", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_CONCURRENCY_TICKETS))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbConcurrencyTickets)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbDefaultRowFormat())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbDefaultRowFormat", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_DEFAULT_ROW_FORMAT))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbDefaultRowFormat)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbDisableSortFileCache())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbDisableSortFileCache", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_DISABLE_SORT_FILE_CACHE))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbDisableSortFileCache)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFileFormat())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFileFormat", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_FILE_FORMAT))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbFileFormat)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFileFormatMax())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFileFormatMax", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_FILE_FORMAT_MAX))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbFileFormatMax)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFilePerTable())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFilePerTable", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_FILE_PER_TABLE))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbFilePerTable)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFillFactor())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFillFactor", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_FILL_FACTOR))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbFillFactor)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFlushNeighbors())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFlushNeighbors", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_FLUSH_NEIGHBORS))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbFlushNeighbors)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFlushSync())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFlushSync", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_FLUSH_SYNC))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbFlushSync)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFlushingAvgLoops())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFlushingAvgLoops", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_FLUSHING_AVG_LOOPS))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbFlushingAvgLoops)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbLruScanDepth())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbLruScanDepth", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_LRU_SCAN_DEPTH))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbLruScanDepth)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbMaxDirtyPagesPct())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbMaxDirtyPagesPct", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbMaxDirtyPagesPct)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbMaxDirtyPagesPctLwm())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbMaxDirtyPagesPctLwm", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT_LWM))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbMaxDirtyPagesPctLwm)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbMaxPurgeLag())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbMaxPurgeLag", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_MAX_PURGE_LAG))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbMaxPurgeLag)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbMaxPurgeLagDelay())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbMaxPurgeLagDelay", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_MAX_PURGE_LAG_DELAY))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbMaxPurgeLagDelay)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarHaveSymlink())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarHaveSymlink", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_HAVE_SYMLINK))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarHaveSymlink)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarIgnoreBuiltinInnodb())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarIgnoreBuiltinInnodb", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_IGNORE_BUILTIN_INNODB))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarIgnoreBuiltinInnodb)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolChunkSize())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolChunkSize", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_BUFFER_POOL_CHUNK_SIZE))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbBufferPoolChunkSize)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolInstances())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolInstances", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_BUFFER_POOL_INSTANCES))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbBufferPoolInstances)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolLoadAtStartup())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolLoadAtStartup", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_BUFFER_POOL_LOAD_AT_STARTUP))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbBufferPoolLoadAtStartup)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbChecksums())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbChecksums", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_CHECKSUMS))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbChecksums)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbDoublewrite())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbDoublewrite", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_DOUBLEWRITE))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbDoublewrite)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFileFormatCheck())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFileFormatCheck", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_FILE_FORMAT_CHECK))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbFileFormatCheck)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFlushMethod())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFlushMethod", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_FLUSH_METHOD))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbFlushMethod)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbForceLoadCorrupted())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbForceLoadCorrupted", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_FORCE_LOAD_CORRUPTED))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbForceLoadCorrupted)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbPageSize())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbPageSize", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_PAGE_SIZE))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbPageSize)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbVersion())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbVersion", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_INNODB_VERSION))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarInnodbVersion)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarMyisamMmapSize())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarMyisamMmapSize", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_MYISAM_MMAP_SIZE))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarMyisamMmapSize)); + } + } + if (OB_SUCC(ret)) { + if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarTableOpenCacheInstances())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarTableOpenCacheInstances", K(ret)); + } else { + store_buf_[ObSysVarsToIdxMap::get_store_idx(static_cast(SYS_VAR_TABLE_OPEN_CACHE_INSTANCES))] = sys_var_ptr; + ptr = (void *)((char *)ptr + sizeof(ObSysVarTableOpenCacheInstances)); + } + } } return ret; @@ -6714,6 +7560,589 @@ int ObSysVarFactory::create_sys_var(ObIAllocator &allocator_, ObSysVarClassType } break; } + case SYS_VAR_FLUSH: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarFlush)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarFlush))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarFlush())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarFlush", K(ret)); + } + break; + } + case SYS_VAR_FLUSH_TIME: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarFlushTime)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarFlushTime))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarFlushTime())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarFlushTime", K(ret)); + } + break; + } + case SYS_VAR_INNODB_ADAPTIVE_FLUSHING: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbAdaptiveFlushing)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbAdaptiveFlushing))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbAdaptiveFlushing())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbAdaptiveFlushing", K(ret)); + } + break; + } + case SYS_VAR_INNODB_ADAPTIVE_FLUSHING_LWM: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbAdaptiveFlushingLwm)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbAdaptiveFlushingLwm))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbAdaptiveFlushingLwm())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbAdaptiveFlushingLwm", K(ret)); + } + break; + } + case SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbAdaptiveHashIndex)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbAdaptiveHashIndex))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbAdaptiveHashIndex())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbAdaptiveHashIndex", K(ret)); + } + break; + } + case SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX_PARTS: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbAdaptiveHashIndexParts)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbAdaptiveHashIndexParts))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbAdaptiveHashIndexParts())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbAdaptiveHashIndexParts", K(ret)); + } + break; + } + case SYS_VAR_INNODB_ADAPTIVE_MAX_SLEEP_DELAY: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbAdaptiveMaxSleepDelay)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbAdaptiveMaxSleepDelay))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbAdaptiveMaxSleepDelay())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbAdaptiveMaxSleepDelay", K(ret)); + } + break; + } + case SYS_VAR_INNODB_AUTOEXTEND_INCREMENT: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbAutoextendIncrement)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbAutoextendIncrement))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbAutoextendIncrement())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbAutoextendIncrement", K(ret)); + } + break; + } + case SYS_VAR_INNODB_BACKGROUND_DROP_LIST_EMPTY: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbBackgroundDropListEmpty)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbBackgroundDropListEmpty))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBackgroundDropListEmpty())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBackgroundDropListEmpty", K(ret)); + } + break; + } + case SYS_VAR_INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbBufferPoolDumpAtShutdown)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbBufferPoolDumpAtShutdown))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolDumpAtShutdown())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolDumpAtShutdown", K(ret)); + } + break; + } + case SYS_VAR_INNODB_BUFFER_POOL_DUMP_NOW: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbBufferPoolDumpNow)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbBufferPoolDumpNow))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolDumpNow())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolDumpNow", K(ret)); + } + break; + } + case SYS_VAR_INNODB_BUFFER_POOL_DUMP_PCT: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbBufferPoolDumpPct)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbBufferPoolDumpPct))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolDumpPct())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolDumpPct", K(ret)); + } + break; + } + case SYS_VAR_INNODB_BUFFER_POOL_FILENAME: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbBufferPoolFilename)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbBufferPoolFilename))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolFilename())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolFilename", K(ret)); + } + break; + } + case SYS_VAR_INNODB_BUFFER_POOL_LOAD_ABORT: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbBufferPoolLoadAbort)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbBufferPoolLoadAbort))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolLoadAbort())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolLoadAbort", K(ret)); + } + break; + } + case SYS_VAR_INNODB_BUFFER_POOL_LOAD_NOW: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbBufferPoolLoadNow)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbBufferPoolLoadNow))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolLoadNow())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolLoadNow", K(ret)); + } + break; + } + case SYS_VAR_INNODB_BUFFER_POOL_SIZE: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbBufferPoolSize)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbBufferPoolSize))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolSize())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolSize", K(ret)); + } + break; + } + case SYS_VAR_INNODB_CHANGE_BUFFER_MAX_SIZE: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbChangeBufferMaxSize)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbChangeBufferMaxSize))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbChangeBufferMaxSize())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbChangeBufferMaxSize", K(ret)); + } + break; + } + case SYS_VAR_INNODB_CHANGE_BUFFERING: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbChangeBuffering)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbChangeBuffering))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbChangeBuffering())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbChangeBuffering", K(ret)); + } + break; + } + case SYS_VAR_INNODB_CHECKSUM_ALGORITHM: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbChecksumAlgorithm)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbChecksumAlgorithm))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbChecksumAlgorithm())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbChecksumAlgorithm", K(ret)); + } + break; + } + case SYS_VAR_INNODB_CMP_PER_INDEX_ENABLED: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbCmpPerIndexEnabled)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbCmpPerIndexEnabled))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbCmpPerIndexEnabled())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbCmpPerIndexEnabled", K(ret)); + } + break; + } + case SYS_VAR_INNODB_COMMIT_CONCURRENCY: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbCommitConcurrency)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbCommitConcurrency))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbCommitConcurrency())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbCommitConcurrency", K(ret)); + } + break; + } + case SYS_VAR_INNODB_COMPRESSION_FAILURE_THRESHOLD_PCT: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbCompressionFailureThresholdPct)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbCompressionFailureThresholdPct))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbCompressionFailureThresholdPct())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbCompressionFailureThresholdPct", K(ret)); + } + break; + } + case SYS_VAR_INNODB_COMPRESSION_LEVEL: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbCompressionLevel)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbCompressionLevel))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbCompressionLevel())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbCompressionLevel", K(ret)); + } + break; + } + case SYS_VAR_INNODB_COMPRESSION_PAD_PCT_MAX: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbCompressionPadPctMax)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbCompressionPadPctMax))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbCompressionPadPctMax())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbCompressionPadPctMax", K(ret)); + } + break; + } + case SYS_VAR_INNODB_CONCURRENCY_TICKETS: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbConcurrencyTickets)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbConcurrencyTickets))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbConcurrencyTickets())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbConcurrencyTickets", K(ret)); + } + break; + } + case SYS_VAR_INNODB_DEFAULT_ROW_FORMAT: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbDefaultRowFormat)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbDefaultRowFormat))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbDefaultRowFormat())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbDefaultRowFormat", K(ret)); + } + break; + } + case SYS_VAR_INNODB_DISABLE_SORT_FILE_CACHE: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbDisableSortFileCache)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbDisableSortFileCache))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbDisableSortFileCache())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbDisableSortFileCache", K(ret)); + } + break; + } + case SYS_VAR_INNODB_FILE_FORMAT: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbFileFormat)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbFileFormat))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFileFormat())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFileFormat", K(ret)); + } + break; + } + case SYS_VAR_INNODB_FILE_FORMAT_MAX: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbFileFormatMax)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbFileFormatMax))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFileFormatMax())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFileFormatMax", K(ret)); + } + break; + } + case SYS_VAR_INNODB_FILE_PER_TABLE: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbFilePerTable)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbFilePerTable))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFilePerTable())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFilePerTable", K(ret)); + } + break; + } + case SYS_VAR_INNODB_FILL_FACTOR: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbFillFactor)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbFillFactor))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFillFactor())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFillFactor", K(ret)); + } + break; + } + case SYS_VAR_INNODB_FLUSH_NEIGHBORS: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbFlushNeighbors)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbFlushNeighbors))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFlushNeighbors())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFlushNeighbors", K(ret)); + } + break; + } + case SYS_VAR_INNODB_FLUSH_SYNC: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbFlushSync)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbFlushSync))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFlushSync())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFlushSync", K(ret)); + } + break; + } + case SYS_VAR_INNODB_FLUSHING_AVG_LOOPS: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbFlushingAvgLoops)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbFlushingAvgLoops))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFlushingAvgLoops())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFlushingAvgLoops", K(ret)); + } + break; + } + case SYS_VAR_INNODB_LRU_SCAN_DEPTH: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbLruScanDepth)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbLruScanDepth))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbLruScanDepth())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbLruScanDepth", K(ret)); + } + break; + } + case SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbMaxDirtyPagesPct)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbMaxDirtyPagesPct))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbMaxDirtyPagesPct())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbMaxDirtyPagesPct", K(ret)); + } + break; + } + case SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT_LWM: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbMaxDirtyPagesPctLwm)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbMaxDirtyPagesPctLwm))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbMaxDirtyPagesPctLwm())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbMaxDirtyPagesPctLwm", K(ret)); + } + break; + } + case SYS_VAR_INNODB_MAX_PURGE_LAG: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbMaxPurgeLag)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbMaxPurgeLag))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbMaxPurgeLag())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbMaxPurgeLag", K(ret)); + } + break; + } + case SYS_VAR_INNODB_MAX_PURGE_LAG_DELAY: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbMaxPurgeLagDelay)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbMaxPurgeLagDelay))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbMaxPurgeLagDelay())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbMaxPurgeLagDelay", K(ret)); + } + break; + } + case SYS_VAR_HAVE_SYMLINK: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarHaveSymlink)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarHaveSymlink))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarHaveSymlink())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarHaveSymlink", K(ret)); + } + break; + } + case SYS_VAR_IGNORE_BUILTIN_INNODB: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarIgnoreBuiltinInnodb)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarIgnoreBuiltinInnodb))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarIgnoreBuiltinInnodb())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarIgnoreBuiltinInnodb", K(ret)); + } + break; + } + case SYS_VAR_INNODB_BUFFER_POOL_CHUNK_SIZE: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbBufferPoolChunkSize)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbBufferPoolChunkSize))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolChunkSize())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolChunkSize", K(ret)); + } + break; + } + case SYS_VAR_INNODB_BUFFER_POOL_INSTANCES: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbBufferPoolInstances)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbBufferPoolInstances))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolInstances())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolInstances", K(ret)); + } + break; + } + case SYS_VAR_INNODB_BUFFER_POOL_LOAD_AT_STARTUP: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbBufferPoolLoadAtStartup)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbBufferPoolLoadAtStartup))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbBufferPoolLoadAtStartup())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbBufferPoolLoadAtStartup", K(ret)); + } + break; + } + case SYS_VAR_INNODB_CHECKSUMS: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbChecksums)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbChecksums))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbChecksums())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbChecksums", K(ret)); + } + break; + } + case SYS_VAR_INNODB_DOUBLEWRITE: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbDoublewrite)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbDoublewrite))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbDoublewrite())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbDoublewrite", K(ret)); + } + break; + } + case SYS_VAR_INNODB_FILE_FORMAT_CHECK: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbFileFormatCheck)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbFileFormatCheck))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFileFormatCheck())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFileFormatCheck", K(ret)); + } + break; + } + case SYS_VAR_INNODB_FLUSH_METHOD: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbFlushMethod)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbFlushMethod))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbFlushMethod())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbFlushMethod", K(ret)); + } + break; + } + case SYS_VAR_INNODB_FORCE_LOAD_CORRUPTED: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbForceLoadCorrupted)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbForceLoadCorrupted))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbForceLoadCorrupted())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbForceLoadCorrupted", K(ret)); + } + break; + } + case SYS_VAR_INNODB_PAGE_SIZE: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbPageSize)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbPageSize))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbPageSize())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbPageSize", K(ret)); + } + break; + } + case SYS_VAR_INNODB_VERSION: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarInnodbVersion)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarInnodbVersion))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarInnodbVersion())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarInnodbVersion", K(ret)); + } + break; + } + case SYS_VAR_MYISAM_MMAP_SIZE: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarMyisamMmapSize)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarMyisamMmapSize))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarMyisamMmapSize())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarMyisamMmapSize", K(ret)); + } + break; + } + case SYS_VAR_TABLE_OPEN_CACHE_INSTANCES: { + void *ptr = NULL; + if (OB_ISNULL(ptr = allocator_.alloc(sizeof(ObSysVarTableOpenCacheInstances)))) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to alloc memory", K(ret), K(sizeof(ObSysVarTableOpenCacheInstances))); + } else if (OB_ISNULL(sys_var_ptr = new (ptr)ObSysVarTableOpenCacheInstances())) { + ret = OB_ALLOCATE_MEMORY_FAILED; + LOG_ERROR("fail to new ObSysVarTableOpenCacheInstances", K(ret)); + } + break; + } default: { ret = OB_ERR_UNEXPECTED; diff --git a/src/share/system_variable/ob_system_variable_factory.h b/src/share/system_variable/ob_system_variable_factory.h index a5beb0854f..d14a66d2b9 100644 --- a/src/share/system_variable/ob_system_variable_factory.h +++ b/src/share/system_variable/ob_system_variable_factory.h @@ -1922,6 +1922,433 @@ public: inline virtual ObSysVarClassType get_type() const { return SYS_VAR_QUERY_REWRITE_INTEGRITY; } inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(264); } }; +class ObSysVarFlush : public ObEnumSysVar +{ +public: + const static char * FLUSH_NAMES[]; +public: + ObSysVarFlush() : ObEnumSysVar(FLUSH_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_FLUSH; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(265); } +}; +class ObSysVarFlushTime : public ObIntSysVar +{ +public: + ObSysVarFlushTime() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_FLUSH_TIME; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(266); } +}; +class ObSysVarInnodbAdaptiveFlushing : public ObEnumSysVar +{ +public: + const static char * INNODB_ADAPTIVE_FLUSHING_NAMES[]; +public: + ObSysVarInnodbAdaptiveFlushing() : ObEnumSysVar(INNODB_ADAPTIVE_FLUSHING_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_ADAPTIVE_FLUSHING; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(267); } +}; +class ObSysVarInnodbAdaptiveFlushingLwm : public ObIntSysVar +{ +public: + ObSysVarInnodbAdaptiveFlushingLwm() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_ADAPTIVE_FLUSHING_LWM; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(268); } +}; +class ObSysVarInnodbAdaptiveHashIndex : public ObEnumSysVar +{ +public: + const static char * INNODB_ADAPTIVE_HASH_INDEX_NAMES[]; +public: + ObSysVarInnodbAdaptiveHashIndex() : ObEnumSysVar(INNODB_ADAPTIVE_HASH_INDEX_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(269); } +}; +class ObSysVarInnodbAdaptiveHashIndexParts : public ObIntSysVar +{ +public: + ObSysVarInnodbAdaptiveHashIndexParts() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX_PARTS; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(270); } +}; +class ObSysVarInnodbAdaptiveMaxSleepDelay : public ObIntSysVar +{ +public: + ObSysVarInnodbAdaptiveMaxSleepDelay() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_ADAPTIVE_MAX_SLEEP_DELAY; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(271); } +}; +class ObSysVarInnodbAutoextendIncrement : public ObIntSysVar +{ +public: + ObSysVarInnodbAutoextendIncrement() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_AUTOEXTEND_INCREMENT; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(272); } +}; +class ObSysVarInnodbBackgroundDropListEmpty : public ObEnumSysVar +{ +public: + const static char * INNODB_BACKGROUND_DROP_LIST_EMPTY_NAMES[]; +public: + ObSysVarInnodbBackgroundDropListEmpty() : ObEnumSysVar(INNODB_BACKGROUND_DROP_LIST_EMPTY_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_BACKGROUND_DROP_LIST_EMPTY; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(273); } +}; +class ObSysVarInnodbBufferPoolDumpAtShutdown : public ObEnumSysVar +{ +public: + const static char * INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN_NAMES[]; +public: + ObSysVarInnodbBufferPoolDumpAtShutdown() : ObEnumSysVar(INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(274); } +}; +class ObSysVarInnodbBufferPoolDumpNow : public ObEnumSysVar +{ +public: + const static char * INNODB_BUFFER_POOL_DUMP_NOW_NAMES[]; +public: + ObSysVarInnodbBufferPoolDumpNow() : ObEnumSysVar(INNODB_BUFFER_POOL_DUMP_NOW_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_BUFFER_POOL_DUMP_NOW; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(275); } +}; +class ObSysVarInnodbBufferPoolDumpPct : public ObIntSysVar +{ +public: + ObSysVarInnodbBufferPoolDumpPct() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_BUFFER_POOL_DUMP_PCT; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(276); } +}; +class ObSysVarInnodbBufferPoolFilename : public ObVarcharSysVar +{ +public: + ObSysVarInnodbBufferPoolFilename() : ObVarcharSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_BUFFER_POOL_FILENAME; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(277); } +}; +class ObSysVarInnodbBufferPoolLoadAbort : public ObEnumSysVar +{ +public: + const static char * INNODB_BUFFER_POOL_LOAD_ABORT_NAMES[]; +public: + ObSysVarInnodbBufferPoolLoadAbort() : ObEnumSysVar(INNODB_BUFFER_POOL_LOAD_ABORT_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_BUFFER_POOL_LOAD_ABORT; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(278); } +}; +class ObSysVarInnodbBufferPoolLoadNow : public ObEnumSysVar +{ +public: + const static char * INNODB_BUFFER_POOL_LOAD_NOW_NAMES[]; +public: + ObSysVarInnodbBufferPoolLoadNow() : ObEnumSysVar(INNODB_BUFFER_POOL_LOAD_NOW_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_BUFFER_POOL_LOAD_NOW; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(279); } +}; +class ObSysVarInnodbBufferPoolSize : public ObIntSysVar +{ +public: + ObSysVarInnodbBufferPoolSize() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_BUFFER_POOL_SIZE; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(280); } +}; +class ObSysVarInnodbChangeBufferMaxSize : public ObIntSysVar +{ +public: + ObSysVarInnodbChangeBufferMaxSize() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_CHANGE_BUFFER_MAX_SIZE; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(281); } +}; +class ObSysVarInnodbChangeBuffering : public ObEnumSysVar +{ +public: + const static char * INNODB_CHANGE_BUFFERING_NAMES[]; +public: + ObSysVarInnodbChangeBuffering() : ObEnumSysVar(INNODB_CHANGE_BUFFERING_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_CHANGE_BUFFERING; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(282); } +}; +class ObSysVarInnodbChecksumAlgorithm : public ObEnumSysVar +{ +public: + const static char * INNODB_CHECKSUM_ALGORITHM_NAMES[]; +public: + ObSysVarInnodbChecksumAlgorithm() : ObEnumSysVar(INNODB_CHECKSUM_ALGORITHM_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_CHECKSUM_ALGORITHM; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(283); } +}; +class ObSysVarInnodbCmpPerIndexEnabled : public ObEnumSysVar +{ +public: + const static char * INNODB_CMP_PER_INDEX_ENABLED_NAMES[]; +public: + ObSysVarInnodbCmpPerIndexEnabled() : ObEnumSysVar(INNODB_CMP_PER_INDEX_ENABLED_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_CMP_PER_INDEX_ENABLED; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(284); } +}; +class ObSysVarInnodbCommitConcurrency : public ObIntSysVar +{ +public: + ObSysVarInnodbCommitConcurrency() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_COMMIT_CONCURRENCY; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(285); } +}; +class ObSysVarInnodbCompressionFailureThresholdPct : public ObIntSysVar +{ +public: + ObSysVarInnodbCompressionFailureThresholdPct() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_COMPRESSION_FAILURE_THRESHOLD_PCT; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(286); } +}; +class ObSysVarInnodbCompressionLevel : public ObIntSysVar +{ +public: + ObSysVarInnodbCompressionLevel() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_COMPRESSION_LEVEL; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(287); } +}; +class ObSysVarInnodbCompressionPadPctMax : public ObIntSysVar +{ +public: + ObSysVarInnodbCompressionPadPctMax() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_COMPRESSION_PAD_PCT_MAX; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(288); } +}; +class ObSysVarInnodbConcurrencyTickets : public ObIntSysVar +{ +public: + ObSysVarInnodbConcurrencyTickets() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_CONCURRENCY_TICKETS; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(289); } +}; +class ObSysVarInnodbDefaultRowFormat : public ObEnumSysVar +{ +public: + const static char * INNODB_DEFAULT_ROW_FORMAT_NAMES[]; +public: + ObSysVarInnodbDefaultRowFormat() : ObEnumSysVar(INNODB_DEFAULT_ROW_FORMAT_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_DEFAULT_ROW_FORMAT; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(290); } +}; +class ObSysVarInnodbDisableSortFileCache : public ObEnumSysVar +{ +public: + const static char * INNODB_DISABLE_SORT_FILE_CACHE_NAMES[]; +public: + ObSysVarInnodbDisableSortFileCache() : ObEnumSysVar(INNODB_DISABLE_SORT_FILE_CACHE_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_DISABLE_SORT_FILE_CACHE; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(291); } +}; +class ObSysVarInnodbFileFormat : public ObEnumSysVar +{ +public: + const static char * INNODB_FILE_FORMAT_NAMES[]; +public: + ObSysVarInnodbFileFormat() : ObEnumSysVar(INNODB_FILE_FORMAT_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_FILE_FORMAT; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(292); } +}; +class ObSysVarInnodbFileFormatMax : public ObEnumSysVar +{ +public: + const static char * INNODB_FILE_FORMAT_MAX_NAMES[]; +public: + ObSysVarInnodbFileFormatMax() : ObEnumSysVar(INNODB_FILE_FORMAT_MAX_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_FILE_FORMAT_MAX; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(293); } +}; +class ObSysVarInnodbFilePerTable : public ObEnumSysVar +{ +public: + const static char * INNODB_FILE_PER_TABLE_NAMES[]; +public: + ObSysVarInnodbFilePerTable() : ObEnumSysVar(INNODB_FILE_PER_TABLE_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_FILE_PER_TABLE; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(294); } +}; +class ObSysVarInnodbFillFactor : public ObIntSysVar +{ +public: + ObSysVarInnodbFillFactor() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_FILL_FACTOR; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(295); } +}; +class ObSysVarInnodbFlushNeighbors : public ObEnumSysVar +{ +public: + const static char * INNODB_FLUSH_NEIGHBORS_NAMES[]; +public: + ObSysVarInnodbFlushNeighbors() : ObEnumSysVar(INNODB_FLUSH_NEIGHBORS_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_FLUSH_NEIGHBORS; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(296); } +}; +class ObSysVarInnodbFlushSync : public ObEnumSysVar +{ +public: + const static char * INNODB_FLUSH_SYNC_NAMES[]; +public: + ObSysVarInnodbFlushSync() : ObEnumSysVar(INNODB_FLUSH_SYNC_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_FLUSH_SYNC; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(297); } +}; +class ObSysVarInnodbFlushingAvgLoops : public ObIntSysVar +{ +public: + ObSysVarInnodbFlushingAvgLoops() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_FLUSHING_AVG_LOOPS; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(298); } +}; +class ObSysVarInnodbLruScanDepth : public ObIntSysVar +{ +public: + ObSysVarInnodbLruScanDepth() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_LRU_SCAN_DEPTH; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(299); } +}; +class ObSysVarInnodbMaxDirtyPagesPct : public ObNumericSysVar +{ +public: + ObSysVarInnodbMaxDirtyPagesPct() : ObNumericSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(300); } +}; +class ObSysVarInnodbMaxDirtyPagesPctLwm : public ObNumericSysVar +{ +public: + ObSysVarInnodbMaxDirtyPagesPctLwm() : ObNumericSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT_LWM; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(301); } +}; +class ObSysVarInnodbMaxPurgeLag : public ObIntSysVar +{ +public: + ObSysVarInnodbMaxPurgeLag() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_MAX_PURGE_LAG; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(302); } +}; +class ObSysVarInnodbMaxPurgeLagDelay : public ObIntSysVar +{ +public: + ObSysVarInnodbMaxPurgeLagDelay() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_MAX_PURGE_LAG_DELAY; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(303); } +}; +class ObSysVarHaveSymlink : public ObEnumSysVar +{ +public: + const static char * HAVE_SYMLINK_NAMES[]; +public: + ObSysVarHaveSymlink() : ObEnumSysVar(HAVE_SYMLINK_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_HAVE_SYMLINK; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(304); } +}; +class ObSysVarIgnoreBuiltinInnodb : public ObEnumSysVar +{ +public: + const static char * IGNORE_BUILTIN_INNODB_NAMES[]; +public: + ObSysVarIgnoreBuiltinInnodb() : ObEnumSysVar(IGNORE_BUILTIN_INNODB_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_IGNORE_BUILTIN_INNODB; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(305); } +}; +class ObSysVarInnodbBufferPoolChunkSize : public ObIntSysVar +{ +public: + ObSysVarInnodbBufferPoolChunkSize() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_BUFFER_POOL_CHUNK_SIZE; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(306); } +}; +class ObSysVarInnodbBufferPoolInstances : public ObIntSysVar +{ +public: + ObSysVarInnodbBufferPoolInstances() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_BUFFER_POOL_INSTANCES; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(307); } +}; +class ObSysVarInnodbBufferPoolLoadAtStartup : public ObEnumSysVar +{ +public: + const static char * INNODB_BUFFER_POOL_LOAD_AT_STARTUP_NAMES[]; +public: + ObSysVarInnodbBufferPoolLoadAtStartup() : ObEnumSysVar(INNODB_BUFFER_POOL_LOAD_AT_STARTUP_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_BUFFER_POOL_LOAD_AT_STARTUP; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(308); } +}; +class ObSysVarInnodbChecksums : public ObEnumSysVar +{ +public: + const static char * INNODB_CHECKSUMS_NAMES[]; +public: + ObSysVarInnodbChecksums() : ObEnumSysVar(INNODB_CHECKSUMS_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_CHECKSUMS; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(309); } +}; +class ObSysVarInnodbDoublewrite : public ObEnumSysVar +{ +public: + const static char * INNODB_DOUBLEWRITE_NAMES[]; +public: + ObSysVarInnodbDoublewrite() : ObEnumSysVar(INNODB_DOUBLEWRITE_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_DOUBLEWRITE; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(310); } +}; +class ObSysVarInnodbFileFormatCheck : public ObEnumSysVar +{ +public: + const static char * INNODB_FILE_FORMAT_CHECK_NAMES[]; +public: + ObSysVarInnodbFileFormatCheck() : ObEnumSysVar(INNODB_FILE_FORMAT_CHECK_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_FILE_FORMAT_CHECK; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(311); } +}; +class ObSysVarInnodbFlushMethod : public ObEnumSysVar +{ +public: + const static char * INNODB_FLUSH_METHOD_NAMES[]; +public: + ObSysVarInnodbFlushMethod() : ObEnumSysVar(INNODB_FLUSH_METHOD_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_FLUSH_METHOD; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(312); } +}; +class ObSysVarInnodbForceLoadCorrupted : public ObEnumSysVar +{ +public: + const static char * INNODB_FORCE_LOAD_CORRUPTED_NAMES[]; +public: + ObSysVarInnodbForceLoadCorrupted() : ObEnumSysVar(INNODB_FORCE_LOAD_CORRUPTED_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_FORCE_LOAD_CORRUPTED; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(313); } +}; +class ObSysVarInnodbPageSize : public ObEnumSysVar +{ +public: + const static char * INNODB_PAGE_SIZE_NAMES[]; +public: + ObSysVarInnodbPageSize() : ObEnumSysVar(INNODB_PAGE_SIZE_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_PAGE_SIZE; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(314); } +}; +class ObSysVarInnodbVersion : public ObEnumSysVar +{ +public: + const static char * INNODB_VERSION_NAMES[]; +public: + ObSysVarInnodbVersion() : ObEnumSysVar(INNODB_VERSION_NAMES, NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_INNODB_VERSION; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(315); } +}; +class ObSysVarMyisamMmapSize : public ObIntSysVar +{ +public: + ObSysVarMyisamMmapSize() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_MYISAM_MMAP_SIZE; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(316); } +}; +class ObSysVarTableOpenCacheInstances : public ObIntSysVar +{ +public: + ObSysVarTableOpenCacheInstances() : ObIntSysVar(NULL, NULL, NULL, NULL, NULL) {} + inline virtual ObSysVarClassType get_type() const { return SYS_VAR_TABLE_OPEN_CACHE_INSTANCES; } + inline virtual const common::ObObj &get_global_default_value() const { return ObSysVariables::get_default_value(317); } +}; class ObSysVarFactory @@ -1942,7 +2369,7 @@ public: static const common::ObString get_sys_var_name_by_id(ObSysVarClassType sys_var_id); const static int64_t MYSQL_SYS_VARS_COUNT = 99; - const static int64_t OB_SYS_VARS_COUNT = 166; + const static int64_t OB_SYS_VARS_COUNT = 219; const static int64_t ALL_SYS_VARS_COUNT = MYSQL_SYS_VARS_COUNT + OB_SYS_VARS_COUNT; const static int64_t INVALID_MAX_READ_STALE_TIME = -1; diff --git a/src/share/system_variable/ob_system_variable_init.cpp b/src/share/system_variable/ob_system_variable_init.cpp index a3462f0540..f9627d3924 100644 --- a/src/share/system_variable/ob_system_variable_init.cpp +++ b/src/share/system_variable/ob_system_variable_init.cpp @@ -3736,13 +3736,777 @@ static struct VarsInit{ ObSysVars[264].alias_ = "OB_SV_QUERY_REWRITE_INTEGRITY" ; }(); + [&] (){ + ObSysVars[265].default_value_ = "0" ; + ObSysVars[265].info_ = "If ON, the server flushes (synchronizes) all changes to disk after each SQL statement" ; + ObSysVars[265].name_ = "flush" ; + ObSysVars[265].data_type_ = ObIntType ; + ObSysVars[265].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[265].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[265].id_ = SYS_VAR_FLUSH ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_FLUSH)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_FLUSH] = 265 ; + ObSysVars[265].base_value_ = "0" ; + ObSysVars[265].alias_ = "OB_SV_FLUSH" ; + }(); + + [&] (){ + ObSysVars[266].default_value_ = "0" ; + ObSysVars[266].info_ = "if this is set to a nonzero value, all tables are closed every flush_time seconds to free up resources and synchronize unflushed data to disk" ; + ObSysVars[266].name_ = "flush_time" ; + ObSysVars[266].data_type_ = ObIntType ; + ObSysVars[266].min_val_ = "0" ; + ObSysVars[266].max_val_ = "31536000" ; + ObSysVars[266].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[266].id_ = SYS_VAR_FLUSH_TIME ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_FLUSH_TIME)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_FLUSH_TIME] = 266 ; + ObSysVars[266].base_value_ = "0" ; + ObSysVars[266].alias_ = "OB_SV_FLUSH_TIME" ; + }(); + + [&] (){ + ObSysVars[267].default_value_ = "1" ; + ObSysVars[267].info_ = "specifies whether to dynamically adjust the rate of flushing dirty pages in the InnoDB buffer pool based on the workload" ; + ObSysVars[267].name_ = "innodb_adaptive_flushing" ; + ObSysVars[267].data_type_ = ObIntType ; + ObSysVars[267].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[267].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[267].id_ = SYS_VAR_INNODB_ADAPTIVE_FLUSHING ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_ADAPTIVE_FLUSHING)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_ADAPTIVE_FLUSHING] = 267 ; + ObSysVars[267].base_value_ = "1" ; + ObSysVars[267].alias_ = "OB_SV_INNODB_ADAPTIVE_FLUSHING" ; + }(); + + [&] (){ + ObSysVars[268].default_value_ = "10" ; + ObSysVars[268].info_ = "Defines the low water mark representing percentage of redo log capacity at which adaptive flushing is enabled" ; + ObSysVars[268].name_ = "innodb_adaptive_flushing_lwm" ; + ObSysVars[268].data_type_ = ObIntType ; + ObSysVars[268].min_val_ = "0" ; + ObSysVars[268].max_val_ = "70" ; + ObSysVars[268].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[268].id_ = SYS_VAR_INNODB_ADAPTIVE_FLUSHING_LWM ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_ADAPTIVE_FLUSHING_LWM)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_ADAPTIVE_FLUSHING_LWM] = 268 ; + ObSysVars[268].base_value_ = "10" ; + ObSysVars[268].alias_ = "OB_SV_INNODB_ADAPTIVE_FLUSHING_LWM" ; + }(); + + [&] (){ + ObSysVars[269].default_value_ = "1" ; + ObSysVars[269].info_ = "Whether the InnoDB adaptive hash index is enabled or disabled. It may be desirable, depending on your workload, to dynamically enable or disable adaptive hash indexing to improve query performance" ; + ObSysVars[269].name_ = "innodb_adaptive_hash_index" ; + ObSysVars[269].data_type_ = ObIntType ; + ObSysVars[269].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[269].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[269].id_ = SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX] = 269 ; + ObSysVars[269].base_value_ = "1" ; + ObSysVars[269].alias_ = "OB_SV_INNODB_ADAPTIVE_HASH_INDEX" ; + }(); + + [&] (){ + ObSysVars[270].default_value_ = "8" ; + ObSysVars[270].info_ = "Partitions the adaptive hash index search system. Each index is bound to a specific partition, with each partition protected by a separate latch." ; + ObSysVars[270].name_ = "innodb_adaptive_hash_index_parts" ; + ObSysVars[270].data_type_ = ObIntType ; + ObSysVars[270].min_val_ = "1" ; + ObSysVars[270].max_val_ = "512" ; + ObSysVars[270].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[270].id_ = SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX_PARTS ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX_PARTS)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_ADAPTIVE_HASH_INDEX_PARTS] = 270 ; + ObSysVars[270].base_value_ = "8" ; + ObSysVars[270].alias_ = "OB_SV_INNODB_ADAPTIVE_HASH_INDEX_PARTS" ; + }(); + + [&] (){ + ObSysVars[271].default_value_ = "150000" ; + ObSysVars[271].info_ = "Permits InnoDB to automatically adjust the value of innodb_thread_sleep_delay up or down according to the current workload" ; + ObSysVars[271].name_ = "innodb_adaptive_max_sleep_delay" ; + ObSysVars[271].data_type_ = ObIntType ; + ObSysVars[271].min_val_ = "0" ; + ObSysVars[271].max_val_ = "1000000" ; + ObSysVars[271].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[271].id_ = SYS_VAR_INNODB_ADAPTIVE_MAX_SLEEP_DELAY ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_ADAPTIVE_MAX_SLEEP_DELAY)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_ADAPTIVE_MAX_SLEEP_DELAY] = 271 ; + ObSysVars[271].base_value_ = "150000" ; + ObSysVars[271].alias_ = "OB_SV_INNODB_ADAPTIVE_MAX_SLEEP_DELAY" ; + }(); + + [&] (){ + ObSysVars[272].default_value_ = "64" ; + ObSysVars[272].info_ = "The increment size (in megabytes) for extending the size of an auto-extending InnoDB system tablespace file when it becomes full" ; + ObSysVars[272].name_ = "innodb_autoextend_increment" ; + ObSysVars[272].data_type_ = ObIntType ; + ObSysVars[272].min_val_ = "1" ; + ObSysVars[272].max_val_ = "1000" ; + ObSysVars[272].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[272].id_ = SYS_VAR_INNODB_AUTOEXTEND_INCREMENT ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_AUTOEXTEND_INCREMENT)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_AUTOEXTEND_INCREMENT] = 272 ; + ObSysVars[272].base_value_ = "64" ; + ObSysVars[272].alias_ = "OB_SV_INNODB_AUTOEXTEND_INCREMENT" ; + }(); + + [&] (){ + ObSysVars[273].default_value_ = "0" ; + ObSysVars[273].info_ = "Enabling the innodb_background_drop_list_empty debug option helps avoid test case failures by delaying table creation until the background drop list is empty" ; + ObSysVars[273].name_ = "innodb_background_drop_list_empty" ; + ObSysVars[273].data_type_ = ObIntType ; + ObSysVars[273].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[273].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[273].id_ = SYS_VAR_INNODB_BACKGROUND_DROP_LIST_EMPTY ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_BACKGROUND_DROP_LIST_EMPTY)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_BACKGROUND_DROP_LIST_EMPTY] = 273 ; + ObSysVars[273].base_value_ = "0" ; + ObSysVars[273].alias_ = "OB_SV_INNODB_BACKGROUND_DROP_LIST_EMPTY" ; + }(); + + [&] (){ + ObSysVars[274].default_value_ = "1" ; + ObSysVars[274].info_ = "Specifies whether to record the pages cached in the InnoDB buffer pool when the MySQL server is shut down, to shorten the warmup process at the next restart" ; + ObSysVars[274].name_ = "innodb_buffer_pool_dump_at_shutdown" ; + ObSysVars[274].data_type_ = ObIntType ; + ObSysVars[274].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[274].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[274].id_ = SYS_VAR_INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN] = 274 ; + ObSysVars[274].base_value_ = "1" ; + ObSysVars[274].alias_ = "OB_SV_INNODB_BUFFER_POOL_DUMP_AT_SHUTDOWN" ; + }(); + + [&] (){ + ObSysVars[275].default_value_ = "0" ; + ObSysVars[275].info_ = "Immediately makes a record of pages cached in the InnoDB buffer pool" ; + ObSysVars[275].name_ = "innodb_buffer_pool_dump_now" ; + ObSysVars[275].data_type_ = ObIntType ; + ObSysVars[275].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[275].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[275].id_ = SYS_VAR_INNODB_BUFFER_POOL_DUMP_NOW ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_BUFFER_POOL_DUMP_NOW)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_BUFFER_POOL_DUMP_NOW] = 275 ; + ObSysVars[275].base_value_ = "0" ; + ObSysVars[275].alias_ = "OB_SV_INNODB_BUFFER_POOL_DUMP_NOW" ; + }(); + + [&] (){ + ObSysVars[276].default_value_ = "25" ; + ObSysVars[276].info_ = "Specifies the percentage of the most recently used pages for each buffer pool to read out and dump" ; + ObSysVars[276].name_ = "innodb_buffer_pool_dump_pct" ; + ObSysVars[276].data_type_ = ObIntType ; + ObSysVars[276].min_val_ = "1" ; + ObSysVars[276].max_val_ = "100" ; + ObSysVars[276].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[276].id_ = SYS_VAR_INNODB_BUFFER_POOL_DUMP_PCT ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_BUFFER_POOL_DUMP_PCT)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_BUFFER_POOL_DUMP_PCT] = 276 ; + ObSysVars[276].base_value_ = "25" ; + ObSysVars[276].alias_ = "OB_SV_INNODB_BUFFER_POOL_DUMP_PCT" ; + }(); + + [&] (){ + ObSysVars[277].default_value_ = "" ; + ObSysVars[277].info_ = "Specifies the name of the file that holds the list of tablespace IDs and page IDs produced by innodb_buffer_pool_dump_at_shutdown or innodb_buffer_pool_dump_now" ; + ObSysVars[277].name_ = "innodb_buffer_pool_filename" ; + ObSysVars[277].data_type_ = ObVarcharType ; + ObSysVars[277].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[277].id_ = SYS_VAR_INNODB_BUFFER_POOL_FILENAME ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_BUFFER_POOL_FILENAME)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_BUFFER_POOL_FILENAME] = 277 ; + ObSysVars[277].base_value_ = "" ; + ObSysVars[277].alias_ = "OB_SV_INNODB_BUFFER_POOL_FILENAME" ; + }(); + + [&] (){ + ObSysVars[278].default_value_ = "0" ; + ObSysVars[278].info_ = "Interrupts the process of restoring InnoDB buffer pool contents triggered by innodb_buffer_pool_load_at_startup or innodb_buffer_pool_load_now" ; + ObSysVars[278].name_ = "innodb_buffer_pool_load_abort" ; + ObSysVars[278].data_type_ = ObIntType ; + ObSysVars[278].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[278].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[278].id_ = SYS_VAR_INNODB_BUFFER_POOL_LOAD_ABORT ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_BUFFER_POOL_LOAD_ABORT)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_BUFFER_POOL_LOAD_ABORT] = 278 ; + ObSysVars[278].base_value_ = "0" ; + ObSysVars[278].alias_ = "OB_SV_INNODB_BUFFER_POOL_LOAD_ABORT" ; + }(); + + [&] (){ + ObSysVars[279].default_value_ = "0" ; + ObSysVars[279].info_ = "Immediately warms up the InnoDB buffer pool by loading data pages without waiting for a server restart" ; + ObSysVars[279].name_ = "innodb_buffer_pool_load_now" ; + ObSysVars[279].data_type_ = ObIntType ; + ObSysVars[279].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[279].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[279].id_ = SYS_VAR_INNODB_BUFFER_POOL_LOAD_NOW ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_BUFFER_POOL_LOAD_NOW)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_BUFFER_POOL_LOAD_NOW] = 279 ; + ObSysVars[279].base_value_ = "0" ; + ObSysVars[279].alias_ = "OB_SV_INNODB_BUFFER_POOL_LOAD_NOW" ; + }(); + + [&] (){ + ObSysVars[280].default_value_ = "134217728" ; + ObSysVars[280].info_ = "The size in bytes of the buffer pool, the memory area where InnoDB caches table and index data" ; + ObSysVars[280].name_ = "innodb_buffer_pool_size" ; + ObSysVars[280].data_type_ = ObUInt64Type ; + ObSysVars[280].min_val_ = "5242880" ; + ObSysVars[280].max_val_ = "18446744073709551615" ; + ObSysVars[280].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[280].id_ = SYS_VAR_INNODB_BUFFER_POOL_SIZE ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_BUFFER_POOL_SIZE)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_BUFFER_POOL_SIZE] = 280 ; + ObSysVars[280].base_value_ = "134217728" ; + ObSysVars[280].alias_ = "OB_SV_INNODB_BUFFER_POOL_SIZE" ; + }(); + + [&] (){ + ObSysVars[281].default_value_ = "25" ; + ObSysVars[281].info_ = "Maximum size for the InnoDB change buffer, as a percentage of the total size of the buffer pool." ; + ObSysVars[281].name_ = "innodb_change_buffer_max_size" ; + ObSysVars[281].data_type_ = ObIntType ; + ObSysVars[281].min_val_ = "0" ; + ObSysVars[281].max_val_ = "50" ; + ObSysVars[281].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[281].id_ = SYS_VAR_INNODB_CHANGE_BUFFER_MAX_SIZE ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_CHANGE_BUFFER_MAX_SIZE)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_CHANGE_BUFFER_MAX_SIZE] = 281 ; + ObSysVars[281].base_value_ = "25" ; + ObSysVars[281].alias_ = "OB_SV_INNODB_CHANGE_BUFFER_MAX_SIZE" ; + }(); + + [&] (){ + ObSysVars[282].default_value_ = "5" ; + ObSysVars[282].info_ = "Whether InnoDB performs change buffering, an optimization that delays write operations to secondary indexes so that the I/O operations can be performed sequentially" ; + ObSysVars[282].name_ = "innodb_change_buffering" ; + ObSysVars[282].data_type_ = ObIntType ; + ObSysVars[282].enum_names_ = "[u'none', u'inserts', u'deletes', u'changes', u'purges', u'all']" ; + ObSysVars[282].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[282].id_ = SYS_VAR_INNODB_CHANGE_BUFFERING ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_CHANGE_BUFFERING)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_CHANGE_BUFFERING] = 282 ; + ObSysVars[282].base_value_ = "5" ; + ObSysVars[282].alias_ = "OB_SV_INNODB_CHANGE_BUFFERING" ; + }(); + + [&] (){ + ObSysVars[283].default_value_ = "0" ; + ObSysVars[283].info_ = "Specifies how to generate and verify the checksum stored in the disk blocks of InnoDB tablespaces" ; + ObSysVars[283].name_ = "innodb_checksum_algorithm" ; + ObSysVars[283].data_type_ = ObIntType ; + ObSysVars[283].enum_names_ = "[u'crc32', u'strict_crc32', u'innodb', u'strict_innodb', u'none', u'strict_none']" ; + ObSysVars[283].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[283].id_ = SYS_VAR_INNODB_CHECKSUM_ALGORITHM ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_CHECKSUM_ALGORITHM)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_CHECKSUM_ALGORITHM] = 283 ; + ObSysVars[283].base_value_ = "0" ; + ObSysVars[283].alias_ = "OB_SV_INNODB_CHECKSUM_ALGORITHM" ; + }(); + + [&] (){ + ObSysVars[284].default_value_ = "0" ; + ObSysVars[284].info_ = "Enables per-index compression-related statistics in the Information Schema INNODB_CMP_PER_INDEX table" ; + ObSysVars[284].name_ = "innodb_cmp_per_index_enabled" ; + ObSysVars[284].data_type_ = ObIntType ; + ObSysVars[284].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[284].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[284].id_ = SYS_VAR_INNODB_CMP_PER_INDEX_ENABLED ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_CMP_PER_INDEX_ENABLED)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_CMP_PER_INDEX_ENABLED] = 284 ; + ObSysVars[284].base_value_ = "0" ; + ObSysVars[284].alias_ = "OB_SV_INNODB_CMP_PER_INDEX_ENABLED" ; + }(); + + [&] (){ + ObSysVars[285].default_value_ = "0" ; + ObSysVars[285].info_ = "The number of threads that can commit at the same time. A value of 0 (the default) permits any number of transactions to commit simultaneously" ; + ObSysVars[285].name_ = "innodb_commit_concurrency" ; + ObSysVars[285].data_type_ = ObIntType ; + ObSysVars[285].min_val_ = "0" ; + ObSysVars[285].max_val_ = "100" ; + ObSysVars[285].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[285].id_ = SYS_VAR_INNODB_COMMIT_CONCURRENCY ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_COMMIT_CONCURRENCY)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_COMMIT_CONCURRENCY] = 285 ; + ObSysVars[285].base_value_ = "0" ; + ObSysVars[285].alias_ = "OB_SV_INNODB_COMMIT_CONCURRENCY" ; + }(); + + [&] (){ + ObSysVars[286].default_value_ = "5" ; + ObSysVars[286].info_ = "Defines the compression failure rate threshold for a table, as a percentage, at which point MySQL begins adding padding within compressed pages to avoid expensive compression failures" ; + ObSysVars[286].name_ = "innodb_compression_failure_threshold_pct" ; + ObSysVars[286].data_type_ = ObIntType ; + ObSysVars[286].min_val_ = "0" ; + ObSysVars[286].max_val_ = "100" ; + ObSysVars[286].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[286].id_ = SYS_VAR_INNODB_COMPRESSION_FAILURE_THRESHOLD_PCT ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_COMPRESSION_FAILURE_THRESHOLD_PCT)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_COMPRESSION_FAILURE_THRESHOLD_PCT] = 286 ; + ObSysVars[286].base_value_ = "5" ; + ObSysVars[286].alias_ = "OB_SV_INNODB_COMPRESSION_FAILURE_THRESHOLD_PCT" ; + }(); + + [&] (){ + ObSysVars[287].default_value_ = "6" ; + ObSysVars[287].info_ = "Specifies the level of zlib compression to use for InnoDB compressed tables and indexes" ; + ObSysVars[287].name_ = "innodb_compression_level" ; + ObSysVars[287].data_type_ = ObIntType ; + ObSysVars[287].min_val_ = "0" ; + ObSysVars[287].max_val_ = "9" ; + ObSysVars[287].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[287].id_ = SYS_VAR_INNODB_COMPRESSION_LEVEL ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_COMPRESSION_LEVEL)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_COMPRESSION_LEVEL] = 287 ; + ObSysVars[287].base_value_ = "6" ; + ObSysVars[287].alias_ = "OB_SV_INNODB_COMPRESSION_LEVEL" ; + }(); + + [&] (){ + ObSysVars[288].default_value_ = "50" ; + ObSysVars[288].info_ = "Specifies the maximum percentage that can be reserved as free space within each compressed page, allowing room to reorganize the data and modification log within the page when a compressed table or index is updated and the data might be recompressed" ; + ObSysVars[288].name_ = "innodb_compression_pad_pct_max" ; + ObSysVars[288].data_type_ = ObIntType ; + ObSysVars[288].min_val_ = "0" ; + ObSysVars[288].max_val_ = "75" ; + ObSysVars[288].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[288].id_ = SYS_VAR_INNODB_COMPRESSION_PAD_PCT_MAX ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_COMPRESSION_PAD_PCT_MAX)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_COMPRESSION_PAD_PCT_MAX] = 288 ; + ObSysVars[288].base_value_ = "50" ; + ObSysVars[288].alias_ = "OB_SV_INNODB_COMPRESSION_PAD_PCT_MAX" ; + }(); + + [&] (){ + ObSysVars[289].default_value_ = "5000" ; + ObSysVars[289].info_ = "Determines the number of threads that can enter InnoDB concurrently" ; + ObSysVars[289].name_ = "innodb_concurrency_tickets" ; + ObSysVars[289].data_type_ = ObIntType ; + ObSysVars[289].min_val_ = "1" ; + ObSysVars[289].max_val_ = "4294967295" ; + ObSysVars[289].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[289].id_ = SYS_VAR_INNODB_CONCURRENCY_TICKETS ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_CONCURRENCY_TICKETS)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_CONCURRENCY_TICKETS] = 289 ; + ObSysVars[289].base_value_ = "5000" ; + ObSysVars[289].alias_ = "OB_SV_INNODB_CONCURRENCY_TICKETS" ; + }(); + + [&] (){ + ObSysVars[290].default_value_ = "2" ; + ObSysVars[290].info_ = "The innodb_default_row_format option defines the default row format for InnoDB tables and user-created temporary tables" ; + ObSysVars[290].name_ = "innodb_default_row_format" ; + ObSysVars[290].data_type_ = ObIntType ; + ObSysVars[290].enum_names_ = "[u'REDUNDANT', u'COMPACT', u'DYNAMIC']" ; + ObSysVars[290].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[290].id_ = SYS_VAR_INNODB_DEFAULT_ROW_FORMAT ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_DEFAULT_ROW_FORMAT)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_DEFAULT_ROW_FORMAT] = 290 ; + ObSysVars[290].base_value_ = "2" ; + ObSysVars[290].alias_ = "OB_SV_INNODB_DEFAULT_ROW_FORMAT" ; + }(); + + [&] (){ + ObSysVars[291].default_value_ = "0" ; + ObSysVars[291].info_ = "Disables the operating system file system cache for merge-sort temporary files. The effect is to open such files with the equivalent of O_DIRECT" ; + ObSysVars[291].name_ = "innodb_disable_sort_file_cache" ; + ObSysVars[291].data_type_ = ObIntType ; + ObSysVars[291].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[291].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[291].id_ = SYS_VAR_INNODB_DISABLE_SORT_FILE_CACHE ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_DISABLE_SORT_FILE_CACHE)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_DISABLE_SORT_FILE_CACHE] = 291 ; + ObSysVars[291].base_value_ = "0" ; + ObSysVars[291].alias_ = "OB_SV_INNODB_DISABLE_SORT_FILE_CACHE" ; + }(); + + [&] (){ + ObSysVars[292].default_value_ = "1" ; + ObSysVars[292].info_ = "Enables an InnoDB file format for file-per-table tablespaces" ; + ObSysVars[292].name_ = "innodb_file_format" ; + ObSysVars[292].data_type_ = ObIntType ; + ObSysVars[292].enum_names_ = "[u'Antelope', u'Barracuda']" ; + ObSysVars[292].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[292].id_ = SYS_VAR_INNODB_FILE_FORMAT ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_FILE_FORMAT)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_FILE_FORMAT] = 292 ; + ObSysVars[292].base_value_ = "1" ; + ObSysVars[292].alias_ = "OB_SV_INNODB_FILE_FORMAT" ; + }(); + + [&] (){ + ObSysVars[293].default_value_ = "1" ; + ObSysVars[293].info_ = "At server startup, InnoDB sets the value of this variable to the file format tag in the system tablespace (for example, Antelope or Barracuda)" ; + ObSysVars[293].name_ = "innodb_file_format_max" ; + ObSysVars[293].data_type_ = ObIntType ; + ObSysVars[293].enum_names_ = "[u'Antelope', u'Barracuda']" ; + ObSysVars[293].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[293].id_ = SYS_VAR_INNODB_FILE_FORMAT_MAX ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_FILE_FORMAT_MAX)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_FILE_FORMAT_MAX] = 293 ; + ObSysVars[293].base_value_ = "1" ; + ObSysVars[293].alias_ = "OB_SV_INNODB_FILE_FORMAT_MAX" ; + }(); + + [&] (){ + ObSysVars[294].default_value_ = "1" ; + ObSysVars[294].info_ = "When innodb_file_per_table is enabled, tables are created in file-per-table tablespaces by default" ; + ObSysVars[294].name_ = "innodb_file_per_table" ; + ObSysVars[294].data_type_ = ObIntType ; + ObSysVars[294].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[294].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[294].id_ = SYS_VAR_INNODB_FILE_PER_TABLE ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_FILE_PER_TABLE)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_FILE_PER_TABLE] = 294 ; + ObSysVars[294].base_value_ = "1" ; + ObSysVars[294].alias_ = "OB_SV_INNODB_FILE_PER_TABLE" ; + }(); + + [&] (){ + ObSysVars[295].default_value_ = "100" ; + ObSysVars[295].info_ = "InnoDB performs a bulk load when creating or rebuilding indexes" ; + ObSysVars[295].name_ = "innodb_fill_factor" ; + ObSysVars[295].data_type_ = ObIntType ; + ObSysVars[295].min_val_ = "10" ; + ObSysVars[295].max_val_ = "100" ; + ObSysVars[295].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[295].id_ = SYS_VAR_INNODB_FILL_FACTOR ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_FILL_FACTOR)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_FILL_FACTOR] = 295 ; + ObSysVars[295].base_value_ = "100" ; + ObSysVars[295].alias_ = "OB_SV_INNODB_FILL_FACTOR" ; + }(); + + [&] (){ + ObSysVars[296].default_value_ = "1" ; + ObSysVars[296].info_ = "Specifies whether flushing a page from the InnoDB buffer pool also flushes other dirty pages in the same extent" ; + ObSysVars[296].name_ = "innodb_flush_neighbors" ; + ObSysVars[296].data_type_ = ObIntType ; + ObSysVars[296].enum_names_ = "[u'0', u'1', u'2']" ; + ObSysVars[296].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[296].id_ = SYS_VAR_INNODB_FLUSH_NEIGHBORS ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_FLUSH_NEIGHBORS)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_FLUSH_NEIGHBORS] = 296 ; + ObSysVars[296].base_value_ = "1" ; + ObSysVars[296].alias_ = "OB_SV_INNODB_FLUSH_NEIGHBORS" ; + }(); + + [&] (){ + ObSysVars[297].default_value_ = "1" ; + ObSysVars[297].info_ = "The innodb_flush_sync variable, which is enabled by default, causes the innodb_io_capacity setting to be ignored during bursts of I/O activity that occur at checkpoints" ; + ObSysVars[297].name_ = "innodb_flush_sync" ; + ObSysVars[297].data_type_ = ObIntType ; + ObSysVars[297].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[297].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[297].id_ = SYS_VAR_INNODB_FLUSH_SYNC ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_FLUSH_SYNC)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_FLUSH_SYNC] = 297 ; + ObSysVars[297].base_value_ = "1" ; + ObSysVars[297].alias_ = "OB_SV_INNODB_FLUSH_SYNC" ; + }(); + + [&] (){ + ObSysVars[298].default_value_ = "30" ; + ObSysVars[298].info_ = "Number of iterations for which InnoDB keeps the previously calculated snapshot of the flushing state, controlling how quickly adaptive flushing responds to changing workloads" ; + ObSysVars[298].name_ = "innodb_flushing_avg_loops" ; + ObSysVars[298].data_type_ = ObIntType ; + ObSysVars[298].min_val_ = "1" ; + ObSysVars[298].max_val_ = "1000" ; + ObSysVars[298].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[298].id_ = SYS_VAR_INNODB_FLUSHING_AVG_LOOPS ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_FLUSHING_AVG_LOOPS)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_FLUSHING_AVG_LOOPS] = 298 ; + ObSysVars[298].base_value_ = "30" ; + ObSysVars[298].alias_ = "OB_SV_INNODB_FLUSHING_AVG_LOOPS" ; + }(); + + [&] (){ + ObSysVars[299].default_value_ = "1024" ; + ObSysVars[299].info_ = "A parameter that influences the algorithms and heuristics for the flush operation for the InnoDB buffer pool. Primarily of interest to performance experts tuning I/O-intensive workloads" ; + ObSysVars[299].name_ = "innodb_lru_scan_depth" ; + ObSysVars[299].data_type_ = ObUInt64Type ; + ObSysVars[299].min_val_ = "100" ; + ObSysVars[299].max_val_ = "18446744073709551615" ; + ObSysVars[299].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[299].id_ = SYS_VAR_INNODB_LRU_SCAN_DEPTH ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_LRU_SCAN_DEPTH)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_LRU_SCAN_DEPTH] = 299 ; + ObSysVars[299].base_value_ = "1024" ; + ObSysVars[299].alias_ = "OB_SV_INNODB_LRU_SCAN_DEPTH" ; + }(); + + [&] (){ + ObSysVars[300].default_value_ = "75" ; + ObSysVars[300].info_ = "InnoDB tries to flush data from the buffer pool so that the percentage of dirty pages does not exceed this value" ; + ObSysVars[300].name_ = "innodb_max_dirty_pages_pct" ; + ObSysVars[300].data_type_ = ObNumberType ; + ObSysVars[300].min_val_ = "0" ; + ObSysVars[300].max_val_ = "99.999" ; + ObSysVars[300].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[300].id_ = SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT] = 300 ; + ObSysVars[300].base_value_ = "75" ; + ObSysVars[300].alias_ = "OB_SV_INNODB_MAX_DIRTY_PAGES_PCT" ; + }(); + + [&] (){ + ObSysVars[301].default_value_ = "0" ; + ObSysVars[301].info_ = "Defines a low water mark representing the percentage of dirty pages at which preflushing is enabled to control the dirty page ratio" ; + ObSysVars[301].name_ = "innodb_max_dirty_pages_pct_lwm" ; + ObSysVars[301].data_type_ = ObNumberType ; + ObSysVars[301].min_val_ = "0" ; + ObSysVars[301].max_val_ = "99.999" ; + ObSysVars[301].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[301].id_ = SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT_LWM ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT_LWM)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_MAX_DIRTY_PAGES_PCT_LWM] = 301 ; + ObSysVars[301].base_value_ = "0" ; + ObSysVars[301].alias_ = "OB_SV_INNODB_MAX_DIRTY_PAGES_PCT_LWM" ; + }(); + + [&] (){ + ObSysVars[302].default_value_ = "0" ; + ObSysVars[302].info_ = "Defines the desired maximum purge lag. If this value is exceeded, a delay is imposed on INSERT, UPDATE, and DELETE operations to allow time for purge to catch up" ; + ObSysVars[302].name_ = "innodb_max_purge_lag" ; + ObSysVars[302].data_type_ = ObIntType ; + ObSysVars[302].min_val_ = "0" ; + ObSysVars[302].max_val_ = "4294967295" ; + ObSysVars[302].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[302].id_ = SYS_VAR_INNODB_MAX_PURGE_LAG ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_MAX_PURGE_LAG)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_MAX_PURGE_LAG] = 302 ; + ObSysVars[302].base_value_ = "0" ; + ObSysVars[302].alias_ = "OB_SV_INNODB_MAX_PURGE_LAG" ; + }(); + + [&] (){ + ObSysVars[303].default_value_ = "0" ; + ObSysVars[303].info_ = "Specifies the maximum delay in microseconds for the delay imposed when the innodb_max_purge_lag threshold is exceeded" ; + ObSysVars[303].name_ = "innodb_max_purge_lag_delay" ; + ObSysVars[303].data_type_ = ObIntType ; + ObSysVars[303].min_val_ = "0" ; + ObSysVars[303].max_val_ = "10000000" ; + ObSysVars[303].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY ; + ObSysVars[303].id_ = SYS_VAR_INNODB_MAX_PURGE_LAG_DELAY ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_MAX_PURGE_LAG_DELAY)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_MAX_PURGE_LAG_DELAY] = 303 ; + ObSysVars[303].base_value_ = "0" ; + ObSysVars[303].alias_ = "OB_SV_INNODB_MAX_PURGE_LAG_DELAY" ; + }(); + + [&] (){ + ObSysVars[304].default_value_ = "1" ; + ObSysVars[304].info_ = "This is required on Unix for support of the DATA DIRECTORY and INDEX DIRECTORY table options" ; + ObSysVars[304].name_ = "have_symlink" ; + ObSysVars[304].data_type_ = ObIntType ; + ObSysVars[304].enum_names_ = "[u'NO', u'YES']" ; + ObSysVars[304].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[304].id_ = SYS_VAR_HAVE_SYMLINK ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_HAVE_SYMLINK)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_HAVE_SYMLINK] = 304 ; + ObSysVars[304].base_value_ = "1" ; + ObSysVars[304].alias_ = "OB_SV_HAVE_SYMLINK" ; + }(); + + [&] (){ + ObSysVars[305].default_value_ = "0" ; + ObSysVars[305].info_ = "In earlier versions of MySQL, enabling this variable caused the server to behave as if the built-in InnoDB were not present, which enabled the InnoDB Plugin to be used instead" ; + ObSysVars[305].name_ = "ignore_builtin_innodb" ; + ObSysVars[305].data_type_ = ObIntType ; + ObSysVars[305].enum_names_ = "[u'NO', u'YES']" ; + ObSysVars[305].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[305].id_ = SYS_VAR_IGNORE_BUILTIN_INNODB ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_IGNORE_BUILTIN_INNODB)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_IGNORE_BUILTIN_INNODB] = 305 ; + ObSysVars[305].base_value_ = "0" ; + ObSysVars[305].alias_ = "OB_SV_IGNORE_BUILTIN_INNODB" ; + }(); + + [&] (){ + ObSysVars[306].default_value_ = "134217728" ; + ObSysVars[306].info_ = "defines the chunk size for InnoDB buffer pool resizing operations" ; + ObSysVars[306].name_ = "innodb_buffer_pool_chunk_size" ; + ObSysVars[306].data_type_ = ObIntType ; + ObSysVars[306].min_val_ = "1048576" ; + ObSysVars[306].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[306].id_ = SYS_VAR_INNODB_BUFFER_POOL_CHUNK_SIZE ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_BUFFER_POOL_CHUNK_SIZE)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_BUFFER_POOL_CHUNK_SIZE] = 306 ; + ObSysVars[306].base_value_ = "134217728" ; + ObSysVars[306].alias_ = "OB_SV_INNODB_BUFFER_POOL_CHUNK_SIZE" ; + }(); + + [&] (){ + ObSysVars[307].default_value_ = "8" ; + ObSysVars[307].info_ = "defines the chunk size for InnoDB buffer pool resizing operations" ; + ObSysVars[307].name_ = "innodb_buffer_pool_instances" ; + ObSysVars[307].data_type_ = ObIntType ; + ObSysVars[307].min_val_ = "1" ; + ObSysVars[307].max_val_ = "64" ; + ObSysVars[307].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[307].id_ = SYS_VAR_INNODB_BUFFER_POOL_INSTANCES ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_BUFFER_POOL_INSTANCES)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_BUFFER_POOL_INSTANCES] = 307 ; + ObSysVars[307].base_value_ = "8" ; + ObSysVars[307].alias_ = "OB_SV_INNODB_BUFFER_POOL_INSTANCES" ; + }(); + + [&] (){ + ObSysVars[308].default_value_ = "1" ; + ObSysVars[308].info_ = "Specifies that, on MySQL server startup, the InnoDB buffer pool is automatically warmed up by loading the same pages it held at an earlier time" ; + ObSysVars[308].name_ = "innodb_buffer_pool_load_at_startup" ; + ObSysVars[308].data_type_ = ObIntType ; + ObSysVars[308].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[308].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[308].id_ = SYS_VAR_INNODB_BUFFER_POOL_LOAD_AT_STARTUP ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_BUFFER_POOL_LOAD_AT_STARTUP)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_BUFFER_POOL_LOAD_AT_STARTUP] = 308 ; + ObSysVars[308].base_value_ = "1" ; + ObSysVars[308].alias_ = "OB_SV_INNODB_BUFFER_POOL_LOAD_AT_STARTUP" ; + }(); + + [&] (){ + ObSysVars[309].default_value_ = "1" ; + ObSysVars[309].info_ = "InnoDB can use checksum validation on all tablespace pages read from disk to ensure extra fault tolerance against hardware faults or corrupted data files" ; + ObSysVars[309].name_ = "innodb_checksums" ; + ObSysVars[309].data_type_ = ObIntType ; + ObSysVars[309].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[309].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[309].id_ = SYS_VAR_INNODB_CHECKSUMS ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_CHECKSUMS)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_CHECKSUMS] = 309 ; + ObSysVars[309].base_value_ = "1" ; + ObSysVars[309].alias_ = "OB_SV_INNODB_CHECKSUMS" ; + }(); + + [&] (){ + ObSysVars[310].default_value_ = "1" ; + ObSysVars[310].info_ = "When enabled (the default), InnoDB stores all data twice, first to the doublewrite buffer, then to the actual data files" ; + ObSysVars[310].name_ = "innodb_doublewrite" ; + ObSysVars[310].data_type_ = ObIntType ; + ObSysVars[310].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[310].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[310].id_ = SYS_VAR_INNODB_DOUBLEWRITE ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_DOUBLEWRITE)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_DOUBLEWRITE] = 310 ; + ObSysVars[310].base_value_ = "1" ; + ObSysVars[310].alias_ = "OB_SV_INNODB_DOUBLEWRITE" ; + }(); + + [&] (){ + ObSysVars[311].default_value_ = "1" ; + ObSysVars[311].info_ = "This variable can be set to 1 or 0 at server startup to enable or disable whether InnoDB checks the file format tag in the system tablespace (for example, Antelope or Barracuda)" ; + ObSysVars[311].name_ = "innodb_file_format_check" ; + ObSysVars[311].data_type_ = ObIntType ; + ObSysVars[311].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[311].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[311].id_ = SYS_VAR_INNODB_FILE_FORMAT_CHECK ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_FILE_FORMAT_CHECK)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_FILE_FORMAT_CHECK] = 311 ; + ObSysVars[311].base_value_ = "1" ; + ObSysVars[311].alias_ = "OB_SV_INNODB_FILE_FORMAT_CHECK" ; + }(); + + [&] (){ + ObSysVars[312].default_value_ = "0" ; + ObSysVars[312].info_ = "Defines the method used to flush data to InnoDB data files and log files, which can affect I/O throughput" ; + ObSysVars[312].name_ = "innodb_flush_method" ; + ObSysVars[312].data_type_ = ObIntType ; + ObSysVars[312].enum_names_ = "[u'null', u'fsync', u'O_DSYNC', u'littlesync', u'nosync', u'O_DIRECT', u'O_DIRECT_NO_FSYNC']" ; + ObSysVars[312].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[312].id_ = SYS_VAR_INNODB_FLUSH_METHOD ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_FLUSH_METHOD)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_FLUSH_METHOD] = 312 ; + ObSysVars[312].base_value_ = "0" ; + ObSysVars[312].alias_ = "OB_SV_INNODB_FLUSH_METHOD" ; + }(); + + [&] (){ + ObSysVars[313].default_value_ = "0" ; + ObSysVars[313].info_ = "Permits InnoDB to load tables at startup that are marked as corrupted" ; + ObSysVars[313].name_ = "innodb_force_load_corrupted" ; + ObSysVars[313].data_type_ = ObIntType ; + ObSysVars[313].enum_names_ = "[u'OFF', u'ON']" ; + ObSysVars[313].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[313].id_ = SYS_VAR_INNODB_FORCE_LOAD_CORRUPTED ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_FORCE_LOAD_CORRUPTED)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_FORCE_LOAD_CORRUPTED] = 313 ; + ObSysVars[313].base_value_ = "0" ; + ObSysVars[313].alias_ = "OB_SV_INNODB_FORCE_LOAD_CORRUPTED" ; + }(); + + [&] (){ + ObSysVars[314].default_value_ = "2" ; + ObSysVars[314].info_ = "Specifies the page size for InnoDB tablespaces. Values can be specified in bytes or kilobytes" ; + ObSysVars[314].name_ = "innodb_page_size" ; + ObSysVars[314].data_type_ = ObIntType ; + ObSysVars[314].enum_names_ = "[u'4096', u'8192', u'16384', u'32768', u'65536']" ; + ObSysVars[314].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[314].id_ = SYS_VAR_INNODB_PAGE_SIZE ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_PAGE_SIZE)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_PAGE_SIZE] = 314 ; + ObSysVars[314].base_value_ = "2" ; + ObSysVars[314].alias_ = "OB_SV_INNODB_PAGE_SIZE" ; + }(); + + [&] (){ + ObSysVars[315].default_value_ = "0" ; + ObSysVars[315].info_ = "The InnoDB version number" ; + ObSysVars[315].name_ = "innodb_version" ; + ObSysVars[315].data_type_ = ObIntType ; + ObSysVars[315].enum_names_ = "[u'5.7.38']" ; + ObSysVars[315].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[315].id_ = SYS_VAR_INNODB_VERSION ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_INNODB_VERSION)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_INNODB_VERSION] = 315 ; + ObSysVars[315].base_value_ = "0" ; + ObSysVars[315].alias_ = "OB_SV_INNODB_VERSION" ; + }(); + + [&] (){ + ObSysVars[316].default_value_ = "18446744073709551615" ; + ObSysVars[316].info_ = "The maximum amount of memory to use for memory mapping compressed MyISAM files" ; + ObSysVars[316].name_ = "myisam_mmap_size" ; + ObSysVars[316].data_type_ = ObUInt64Type ; + ObSysVars[316].min_val_ = "7" ; + ObSysVars[316].max_val_ = "18446744073709551615" ; + ObSysVars[316].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[316].id_ = SYS_VAR_MYISAM_MMAP_SIZE ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_MYISAM_MMAP_SIZE)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_MYISAM_MMAP_SIZE] = 316 ; + ObSysVars[316].base_value_ = "18446744073709551615" ; + ObSysVars[316].alias_ = "OB_SV_MYISAM_MMAP_SIZE" ; + }(); + + [&] (){ + ObSysVars[317].default_value_ = "16" ; + ObSysVars[317].info_ = "The maximum amount of memory to use for memory mapping compressed MyISAM files" ; + ObSysVars[317].name_ = "table_open_cache_instances" ; + ObSysVars[317].data_type_ = ObIntType ; + ObSysVars[317].min_val_ = "1" ; + ObSysVars[317].max_val_ = "64" ; + ObSysVars[317].flags_ = ObSysVarFlag::GLOBAL_SCOPE | ObSysVarFlag::MYSQL_ONLY | ObSysVarFlag::READONLY ; + ObSysVars[317].id_ = SYS_VAR_TABLE_OPEN_CACHE_INSTANCES ; + cur_max_var_id = MAX(cur_max_var_id, static_cast(SYS_VAR_TABLE_OPEN_CACHE_INSTANCES)) ; + ObSysVarsIdToArrayIdx[SYS_VAR_TABLE_OPEN_CACHE_INSTANCES] = 317 ; + ObSysVars[317].base_value_ = "16" ; + ObSysVars[317].alias_ = "OB_SV_TABLE_OPEN_CACHE_INSTANCES" ; + }(); + if (cur_max_var_id >= ObSysVarFactory::OB_MAX_SYS_VAR_ID) { HasInvalidSysVar = true; } } }vars_init; -static int64_t var_amount = 265; +static int64_t var_amount = 318; int64_t ObSysVariables::get_all_sys_var_count(){ return ObSysVarFactory::ALL_SYS_VARS_COUNT;} ObSysVarClassType ObSysVariables::get_sys_var_id(int64_t i){ return ObSysVars[i].id_;} diff --git a/src/share/system_variable/ob_system_variable_init.json b/src/share/system_variable/ob_system_variable_init.json index 12c40d3b62..68cde440f6 100644 --- a/src/share/system_variable/ob_system_variable_init.json +++ b/src/share/system_variable/ob_system_variable_init.json @@ -3791,5 +3791,872 @@ "info_cn": "", "background_cn": "", "ref_url": "" + }, + "flush": { + "id": 10181, + "name": "flush", + "default_value": "0", + "base_value": "0", + "data_type": "enum", + "info": "If ON, the server flushes (synchronizes) all changes to disk after each SQL statement", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "flush_time": { + "id": 10182, + "name": "flush_time", + "default_value": "0", + "base_value": "0", + "data_type": "int", + "info": "if this is set to a nonzero value, all tables are closed every flush_time seconds to free up resources and synchronize unflushed data to disk", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "0", + "max_val": "31536000", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_adaptive_flushing": { + "id": 10183, + "name": "innodb_adaptive_flushing", + "default_value": "1", + "base_value": "1", + "data_type": "enum", + "info": "specifies whether to dynamically adjust the rate of flushing dirty pages in the InnoDB buffer pool based on the workload", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_adaptive_flushing_lwm": { + "id": 10184, + "name": "innodb_adaptive_flushing_lwm", + "default_value": "10", + "base_value": "10", + "data_type": "int", + "info": "Defines the low water mark representing percentage of redo log capacity at which adaptive flushing is enabled", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "0", + "max_val": "70", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_adaptive_hash_index": { + "id": 10185, + "name": "innodb_adaptive_hash_index", + "default_value": "1", + "base_value": "1", + "data_type": "enum", + "info": "Whether the InnoDB adaptive hash index is enabled or disabled. It may be desirable, depending on your workload, to dynamically enable or disable adaptive hash indexing to improve query performance", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_adaptive_hash_index_parts": { + "id": 10186, + "name": "innodb_adaptive_hash_index_parts", + "default_value": "8", + "base_value": "8", + "data_type": "int", + "info": "Partitions the adaptive hash index search system. Each index is bound to a specific partition, with each partition protected by a separate latch.", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "1", + "max_val": "512", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_adaptive_max_sleep_delay": { + "id": 10187, + "name": "innodb_adaptive_max_sleep_delay", + "default_value": "150000", + "base_value": "150000", + "data_type": "int", + "info": "Permits InnoDB to automatically adjust the value of innodb_thread_sleep_delay up or down according to the current workload", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "0", + "max_val": "1000000", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_autoextend_increment": { + "id": 10188, + "name": "innodb_autoextend_increment", + "default_value": "64", + "base_value": "64", + "data_type": "int", + "info": "The increment size (in megabytes) for extending the size of an auto-extending InnoDB system tablespace file when it becomes full", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "1", + "max_val": "1000", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_background_drop_list_empty": { + "id": 10189, + "name": "innodb_background_drop_list_empty", + "default_value": "0", + "base_value": "0", + "data_type": "enum", + "info": "Enabling the innodb_background_drop_list_empty debug option helps avoid test case failures by delaying table creation until the background drop list is empty", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_buffer_pool_dump_at_shutdown": { + "id": 10190, + "name": "innodb_buffer_pool_dump_at_shutdown", + "default_value": "1", + "base_value": "1", + "data_type": "enum", + "info": "Specifies whether to record the pages cached in the InnoDB buffer pool when the MySQL server is shut down, to shorten the warmup process at the next restart", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_buffer_pool_dump_now": { + "id": 10191, + "name": "innodb_buffer_pool_dump_now", + "default_value": "0", + "base_value": "0", + "data_type": "enum", + "info": "Immediately makes a record of pages cached in the InnoDB buffer pool", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_buffer_pool_dump_pct": { + "id": 10192, + "name": "innodb_buffer_pool_dump_pct", + "default_value": "25", + "base_value": "25", + "data_type": "int", + "info": "Specifies the percentage of the most recently used pages for each buffer pool to read out and dump", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "1", + "max_val": "100", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_buffer_pool_filename": { + "id": 10193, + "name": "innodb_buffer_pool_filename", + "default_value": "", + "base_value": "", + "data_type": "varchar", + "info": "Specifies the name of the file that holds the list of tablespace IDs and page IDs produced by innodb_buffer_pool_dump_at_shutdown or innodb_buffer_pool_dump_now", + "flags": "GLOBAL | MYSQL_ONLY", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_buffer_pool_load_abort": { + "id": 10194, + "name": "innodb_buffer_pool_load_abort", + "default_value": "0", + "base_value": "0", + "data_type": "enum", + "info": "Interrupts the process of restoring InnoDB buffer pool contents triggered by innodb_buffer_pool_load_at_startup or innodb_buffer_pool_load_now", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_buffer_pool_load_now": { + "id": 10195, + "name": "innodb_buffer_pool_load_now", + "default_value": "0", + "base_value": "0", + "data_type": "enum", + "info": "Immediately warms up the InnoDB buffer pool by loading data pages without waiting for a server restart", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_buffer_pool_size": { + "id": 10196, + "name": "innodb_buffer_pool_size", + "default_value": "134217728", + "base_value": "134217728", + "data_type": "uint", + "info": "The size in bytes of the buffer pool, the memory area where InnoDB caches table and index data", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "5242880", + "max_val": "18446744073709551615", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_change_buffer_max_size": { + "id": 10197, + "name": "innodb_change_buffer_max_size", + "default_value": "25", + "base_value": "25", + "data_type": "int", + "info": "Maximum size for the InnoDB change buffer, as a percentage of the total size of the buffer pool.", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "0", + "max_val": "50", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_change_buffering": { + "id": 10198, + "name": "innodb_change_buffering", + "default_value": "5", + "base_value": "5", + "data_type": "enum", + "info": "Whether InnoDB performs change buffering, an optimization that delays write operations to secondary indexes so that the I/O operations can be performed sequentially", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "none", + "inserts", + "deletes", + "changes", + "purges", + "all" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_checksum_algorithm": { + "id": 10199, + "name": "innodb_checksum_algorithm", + "default_value": "0", + "base_value": "0", + "data_type": "enum", + "info": "Specifies how to generate and verify the checksum stored in the disk blocks of InnoDB tablespaces", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "crc32", + "strict_crc32", + "innodb", + "strict_innodb", + "none", + "strict_none" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_cmp_per_index_enabled": { + "id": 10200, + "name": "innodb_cmp_per_index_enabled", + "default_value": "0", + "base_value": "0", + "data_type": "enum", + "info": "Enables per-index compression-related statistics in the Information Schema INNODB_CMP_PER_INDEX table", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_commit_concurrency": { + "id": 10201, + "name": "innodb_commit_concurrency", + "default_value": "0", + "base_value": "0", + "data_type": "int", + "info": "The number of threads that can commit at the same time. A value of 0 (the default) permits any number of transactions to commit simultaneously", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "0", + "max_val": "100", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_compression_failure_threshold_pct": { + "id": 10202, + "name": "innodb_compression_failure_threshold_pct", + "default_value": "5", + "base_value": "5", + "data_type": "int", + "info": "Defines the compression failure rate threshold for a table, as a percentage, at which point MySQL begins adding padding within compressed pages to avoid expensive compression failures", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "0", + "max_val": "100", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_compression_level": { + "id": 10203, + "name": "innodb_compression_level", + "default_value": "6", + "base_value": "6", + "data_type": "int", + "info": "Specifies the level of zlib compression to use for InnoDB compressed tables and indexes", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "0", + "max_val": "9", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_compression_pad_pct_max": { + "id": 10204, + "name": "innodb_compression_pad_pct_max", + "default_value": "50", + "base_value": "50", + "data_type": "int", + "info": "Specifies the maximum percentage that can be reserved as free space within each compressed page, allowing room to reorganize the data and modification log within the page when a compressed table or index is updated and the data might be recompressed", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "0", + "max_val": "75", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_concurrency_tickets": { + "id": 10205, + "name": "innodb_concurrency_tickets", + "default_value": "5000", + "base_value": "5000", + "data_type": "int", + "info": "Determines the number of threads that can enter InnoDB concurrently", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "1", + "max_val": "4294967295", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_default_row_format": { + "id": 10206, + "name": "innodb_default_row_format", + "default_value": "2", + "base_value": "2", + "data_type": "enum", + "info": "The innodb_default_row_format option defines the default row format for InnoDB tables and user-created temporary tables", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "REDUNDANT", + "COMPACT", + "DYNAMIC" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_disable_sort_file_cache": { + "id": 10207, + "name": "innodb_disable_sort_file_cache", + "default_value": "0", + "base_value": "0", + "data_type": "enum", + "info": "Disables the operating system file system cache for merge-sort temporary files. The effect is to open such files with the equivalent of O_DIRECT", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_file_format": { + "id": 10208, + "name": "innodb_file_format", + "default_value": "1", + "base_value": "1", + "data_type": "enum", + "info": "Enables an InnoDB file format for file-per-table tablespaces", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "Antelope", + "Barracuda" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_file_format_max": { + "id": 10209, + "name": "innodb_file_format_max", + "default_value": "1", + "base_value": "1", + "data_type": "enum", + "info": "At server startup, InnoDB sets the value of this variable to the file format tag in the system tablespace (for example, Antelope or Barracuda)", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "Antelope", + "Barracuda" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_file_per_table": { + "id": 10210, + "name": "innodb_file_per_table", + "default_value": "1", + "base_value": "1", + "data_type": "enum", + "info": "When innodb_file_per_table is enabled, tables are created in file-per-table tablespaces by default", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_fill_factor": { + "id": 10211, + "name": "innodb_fill_factor", + "default_value": "100", + "base_value": "100", + "data_type": "int", + "info": "InnoDB performs a bulk load when creating or rebuilding indexes", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "10", + "max_val": "100", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_flush_neighbors": { + "id": 10212, + "name": "innodb_flush_neighbors", + "default_value": "1", + "base_value": "1", + "data_type": "enum", + "info": "Specifies whether flushing a page from the InnoDB buffer pool also flushes other dirty pages in the same extent", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "0", + "1", + "2" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_flush_sync": { + "id": 10213, + "name": "innodb_flush_sync", + "default_value": "1", + "base_value": "1", + "data_type": "enum", + "info": "The innodb_flush_sync variable, which is enabled by default, causes the innodb_io_capacity setting to be ignored during bursts of I/O activity that occur at checkpoints", + "flags": "GLOBAL | MYSQL_ONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_flushing_avg_loops": { + "id": 10214, + "name": "innodb_flushing_avg_loops", + "default_value": "30", + "base_value": "30", + "data_type": "int", + "info": "Number of iterations for which InnoDB keeps the previously calculated snapshot of the flushing state, controlling how quickly adaptive flushing responds to changing workloads", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "1", + "max_val": "1000", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_lru_scan_depth": { + "id": 10215, + "name": "innodb_lru_scan_depth", + "default_value": "1024", + "base_value": "1024", + "data_type": "uint", + "info": "A parameter that influences the algorithms and heuristics for the flush operation for the InnoDB buffer pool. Primarily of interest to performance experts tuning I/O-intensive workloads", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "100", + "max_val": "18446744073709551615", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_max_dirty_pages_pct": { + "id": 10216, + "name": "innodb_max_dirty_pages_pct", + "default_value": "75", + "base_value": "75", + "data_type": "numeric", + "info": "InnoDB tries to flush data from the buffer pool so that the percentage of dirty pages does not exceed this value", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "0", + "max_val": "99.999", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_max_dirty_pages_pct_lwm": { + "id": 10217, + "name": "innodb_max_dirty_pages_pct_lwm", + "default_value": "0", + "base_value": "0", + "data_type": "numeric", + "info": "Defines a low water mark representing the percentage of dirty pages at which preflushing is enabled to control the dirty page ratio", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "0", + "max_val": "99.999", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_max_purge_lag": { + "id": 10218, + "name": "innodb_max_purge_lag", + "default_value": "0", + "base_value": "0", + "data_type": "int", + "info": "Defines the desired maximum purge lag. If this value is exceeded, a delay is imposed on INSERT, UPDATE, and DELETE operations to allow time for purge to catch up", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "0", + "max_val": "4294967295", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_max_purge_lag_delay": { + "id": 10219, + "name": "innodb_max_purge_lag_delay", + "default_value": "0", + "base_value": "0", + "data_type": "int", + "info": "Specifies the maximum delay in microseconds for the delay imposed when the innodb_max_purge_lag threshold is exceeded", + "flags": "GLOBAL | MYSQL_ONLY", + "min_val": "0", + "max_val": "10000000", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "have_symlink": { + "id": 10220, + "name": "have_symlink", + "default_value": "1", + "base_value": "1", + "data_type": "enum", + "info": "This is required on Unix for support of the DATA DIRECTORY and INDEX DIRECTORY table options", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "enum_names": [ + "NO", + "YES" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "ignore_builtin_innodb": { + "id": 10221, + "name": "ignore_builtin_innodb", + "default_value": "0", + "base_value": "0", + "data_type": "enum", + "info": "In earlier versions of MySQL, enabling this variable caused the server to behave as if the built-in InnoDB were not present, which enabled the InnoDB Plugin to be used instead", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "enum_names": [ + "NO", + "YES" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_buffer_pool_chunk_size": { + "id": 10222, + "name": "innodb_buffer_pool_chunk_size", + "default_value": "134217728", + "base_value": "134217728", + "data_type": "int", + "info": "defines the chunk size for InnoDB buffer pool resizing operations", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "min_val": "1048576", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_buffer_pool_instances": { + "id": 10223, + "name": "innodb_buffer_pool_instances", + "default_value": "8", + "base_value": "8", + "data_type": "int", + "info": "defines the chunk size for InnoDB buffer pool resizing operations", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "min_val": "1", + "max_val": "64", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_buffer_pool_load_at_startup": { + "id": 10224, + "name": "innodb_buffer_pool_load_at_startup", + "default_value": "1", + "base_value": "1", + "data_type": "enum", + "info": "Specifies that, on MySQL server startup, the InnoDB buffer pool is automatically warmed up by loading the same pages it held at an earlier time", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_checksums": { + "id": 10225, + "name": "innodb_checksums", + "default_value": "1", + "base_value": "1", + "data_type": "enum", + "info": "InnoDB can use checksum validation on all tablespace pages read from disk to ensure extra fault tolerance against hardware faults or corrupted data files", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_doublewrite": { + "id": 10226, + "name": "innodb_doublewrite", + "default_value": "1", + "base_value": "1", + "data_type": "enum", + "info": "When enabled (the default), InnoDB stores all data twice, first to the doublewrite buffer, then to the actual data files", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_file_format_check": { + "id": 10227, + "name": "innodb_file_format_check", + "default_value": "1", + "base_value": "1", + "data_type": "enum", + "info": "This variable can be set to 1 or 0 at server startup to enable or disable whether InnoDB checks the file format tag in the system tablespace (for example, Antelope or Barracuda)", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_flush_method": { + "id": 10228, + "name": "innodb_flush_method", + "default_value": "0", + "base_value": "0", + "data_type": "enum", + "info": "Defines the method used to flush data to InnoDB data files and log files, which can affect I/O throughput", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "enum_names": [ + "null", + "fsync", + "O_DSYNC", + "littlesync", + "nosync", + "O_DIRECT", + "O_DIRECT_NO_FSYNC" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_force_load_corrupted": { + "id": 10229, + "name": "innodb_force_load_corrupted", + "default_value": "0", + "base_value": "0", + "data_type": "enum", + "info": "Permits InnoDB to load tables at startup that are marked as corrupted", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "enum_names": [ + "OFF", + "ON" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_page_size": { + "id": 10230, + "name": "innodb_page_size", + "default_value": "2", + "base_value": "2", + "data_type": "enum", + "info": "Specifies the page size for InnoDB tablespaces. Values can be specified in bytes or kilobytes", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "enum_names": [ + "4096", + "8192", + "16384", + "32768", + "65536" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "innodb_version": { + "id": 10231, + "name": "innodb_version", + "default_value": "0", + "base_value": "0", + "data_type": "enum", + "info": "The InnoDB version number", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "enum_names": [ + "5.7.38" + ], + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "myisam_mmap_size": { + "id": 10232, + "name": "myisam_mmap_size", + "default_value": "18446744073709551615", + "base_value": "18446744073709551615", + "data_type": "uint", + "info": "The maximum amount of memory to use for memory mapping compressed MyISAM files", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "min_val": "7", + "max_val": "18446744073709551615", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" + }, + "table_open_cache_instances": { + "id": 10233, + "name": "table_open_cache_instances", + "default_value": "16", + "base_value": "16", + "data_type": "int", + "info": "The maximum amount of memory to use for memory mapping compressed MyISAM files", + "flags": "GLOBAL | MYSQL_ONLY | READONLY", + "min_val": "1", + "max_val": "64", + "publish_version": "424", + "info_cn": "", + "background_cn": "", + "ref_url": "" } + + } diff --git a/src/sql/resolver/ob_stmt_type.h b/src/sql/resolver/ob_stmt_type.h index 0a5671adf4..8801a52564 100644 --- a/src/sql/resolver/ob_stmt_type.h +++ b/src/sql/resolver/ob_stmt_type.h @@ -308,6 +308,10 @@ OB_STMT_TYPE_DEF_UNKNOWN_AT(T_FLUSH_MOCK, no_priv_needed, 307) OB_STMT_TYPE_DEF_UNKNOWN_AT(T_FLUSH_MOCK_LIST, no_priv_needed, 308) OB_STMT_TYPE_DEF_UNKNOWN_AT(T_HANDLER_MOCK, no_priv_needed, 309) OB_STMT_TYPE_DEF_UNKNOWN_AT(T_SHOW_PLUGINS, no_priv_needed, 310) +OB_STMT_TYPE_DEF_UNKNOWN_AT(T_SHOW_ENGINE, err_stmt_type_priv, 311) +OB_STMT_TYPE_DEF_UNKNOWN_AT(T_SHOW_OPEN_TABLES, err_stmt_type_priv, 312) +OB_STMT_TYPE_DEF_UNKNOWN_AT(T_REPAIR_TABLE, no_priv_needed, 313) +OB_STMT_TYPE_DEF_UNKNOWN_AT(T_CHECKSUM_TABLE, no_priv_needed, 314) OB_STMT_TYPE_DEF_UNKNOWN_AT(T_MAX, err_stmt_type_priv, 500) #endif