tidb: github.com/pingcap/tidb/sessionctx/variable Index | Files

package variable

import "github.com/pingcap/tidb/sessionctx/variable"

Index

Package Files

error.go mock_globalaccessor.go sequence_state.go session.go statusvar.go sysvar.go tidb_vars.go varsutil.go

Constants

const (
    SQLModeVar           = "sql_mode"
    CharacterSetResults  = "character_set_results"
    MaxAllowedPacket     = "max_allowed_packet"
    TimeZone             = "time_zone"
    TxnIsolation         = "tx_isolation"
    TransactionIsolation = "transaction_isolation"
    TxnIsolationOneShot  = "tx_isolation_one_shot"
    MaxExecutionTime     = "max_execution_time"
)

special session variables.

const (
    // SlowLogRowPrefixStr is slow log row prefix.
    SlowLogRowPrefixStr = "# "
    // SlowLogSpaceMarkStr is slow log space mark.
    SlowLogSpaceMarkStr = ": "
    // SlowLogSQLSuffixStr is slow log suffix.
    SlowLogSQLSuffixStr = ";"
    // SlowLogTimeStr is slow log field name.
    SlowLogTimeStr = "Time"
    // SlowLogStartPrefixStr is slow log start row prefix.
    SlowLogStartPrefixStr = SlowLogRowPrefixStr + SlowLogTimeStr + SlowLogSpaceMarkStr
    // SlowLogTxnStartTSStr is slow log field name.
    SlowLogTxnStartTSStr = "Txn_start_ts"
    // SlowLogUserAndHostStr is the user and host field name, which is compatible with MySQL.
    SlowLogUserAndHostStr = "User@Host"
    // SlowLogUserStr is slow log field name.
    SlowLogUserStr = "User"
    // SlowLogHostStr only for slow_query table usage.
    SlowLogHostStr = "Host"
    // SlowLogConnIDStr is slow log field name.
    SlowLogConnIDStr = "Conn_ID"
    // SlowLogQueryTimeStr is slow log field name.
    SlowLogQueryTimeStr = "Query_time"
    // SlowLogParseTimeStr is the parse sql time.
    SlowLogParseTimeStr = "Parse_time"
    // SlowLogCompileTimeStr is the compile plan time.
    SlowLogCompileTimeStr = "Compile_time"
    // SlowLogRewriteTimeStr is the rewrite time.
    SlowLogRewriteTimeStr = "Rewrite_time"
    // SlowLogOptimizeTimeStr is the optimization time.
    SlowLogOptimizeTimeStr = "Optimize_time"
    // SlowLogWaitTSTimeStr is the time of waiting TS.
    SlowLogWaitTSTimeStr = "Wait_TS"
    // SlowLogPreprocSubQueriesStr is the number of pre-processed sub-queries.
    SlowLogPreprocSubQueriesStr = "Preproc_subqueries"
    // SlowLogPreProcSubQueryTimeStr is the total time of pre-processing sub-queries.
    SlowLogPreProcSubQueryTimeStr = "Preproc_subqueries_time"
    // SlowLogDBStr is slow log field name.
    SlowLogDBStr = "DB"
    // SlowLogIsInternalStr is slow log field name.
    SlowLogIsInternalStr = "Is_internal"
    // SlowLogIndexNamesStr is slow log field name.
    SlowLogIndexNamesStr = "Index_names"
    // SlowLogDigestStr is slow log field name.
    SlowLogDigestStr = "Digest"
    // SlowLogQuerySQLStr is slow log field name.
    SlowLogQuerySQLStr = "Query" // use for slow log table, slow log will not print this field name but print sql directly.
    // SlowLogStatsInfoStr is plan stats info.
    SlowLogStatsInfoStr = "Stats"
    // SlowLogNumCopTasksStr is the number of cop-tasks.
    SlowLogNumCopTasksStr = "Num_cop_tasks"
    // SlowLogCopProcAvg is the average process time of all cop-tasks.
    SlowLogCopProcAvg = "Cop_proc_avg"
    // SlowLogCopProcP90 is the p90 process time of all cop-tasks.
    SlowLogCopProcP90 = "Cop_proc_p90"
    // SlowLogCopProcMax is the max process time of all cop-tasks.
    SlowLogCopProcMax = "Cop_proc_max"
    // SlowLogCopProcAddr is the address of TiKV where the cop-task which cost max process time run.
    SlowLogCopProcAddr = "Cop_proc_addr"
    // SlowLogCopWaitAvg is the average wait time of all cop-tasks.
    SlowLogCopWaitAvg = "Cop_wait_avg"
    // SlowLogCopWaitP90 is the p90 wait time of all cop-tasks.
    SlowLogCopWaitP90 = "Cop_wait_p90"
    // SlowLogCopWaitMax is the max wait time of all cop-tasks.
    SlowLogCopWaitMax = "Cop_wait_max"
    // SlowLogCopWaitAddr is the address of TiKV where the cop-task which cost wait process time run.
    SlowLogCopWaitAddr = "Cop_wait_addr"
    // SlowLogCopBackoffPrefix contains backoff information.
    SlowLogCopBackoffPrefix = "Cop_backoff_"
    // SlowLogMemMax is the max number bytes of memory used in this statement.
    SlowLogMemMax = "Mem_max"
    // SlowLogDiskMax is the nax number bytes of disk used in this statement.
    SlowLogDiskMax = "Disk_max"
    // SlowLogPrepared is used to indicate whether this sql execute in prepare.
    SlowLogPrepared = "Prepared"
    // SlowLogPlanFromCache is used to indicate whether this plan is from plan cache.
    SlowLogPlanFromCache = "Plan_from_cache"
    // SlowLogHasMoreResults is used to indicate whether this sql has more following results.
    SlowLogHasMoreResults = "Has_more_results"
    // SlowLogSucc is used to indicate whether this sql execute successfully.
    SlowLogSucc = "Succ"
    // SlowLogPrevStmt is used to show the previous executed statement.
    SlowLogPrevStmt = "Prev_stmt"
    // SlowLogPlan is used to record the query plan.
    SlowLogPlan = "Plan"
    // SlowLogPlanDigest is used to record the query plan digest.
    SlowLogPlanDigest = "Plan_digest"
    // SlowLogPlanPrefix is the prefix of the plan value.
    SlowLogPlanPrefix = ast.TiDBDecodePlan + "('"
    // SlowLogPlanSuffix is the suffix of the plan value.
    SlowLogPlanSuffix = "')"
    // SlowLogPrevStmtPrefix is the prefix of Prev_stmt in slow log file.
    SlowLogPrevStmtPrefix = SlowLogPrevStmt + SlowLogSpaceMarkStr
    // SlowLogKVTotal is the total time waiting for kv.
    SlowLogKVTotal = "KV_total"
    // SlowLogPDTotal is the total time waiting for pd.
    SlowLogPDTotal = "PD_total"
    // SlowLogBackoffTotal is the total time doing backoff.
    SlowLogBackoffTotal = "Backoff_total"
    // SlowLogWriteSQLRespTotal is the total time used to write response to client.
    SlowLogWriteSQLRespTotal = "Write_sql_response_total"
)
const (
    // CharacterSetConnection is the name for character_set_connection system variable.
    CharacterSetConnection = "character_set_connection"
    // CollationConnection is the name for collation_connection system variable.
    CollationConnection = "collation_connection"
    // CharsetDatabase is the name for character_set_database system variable.
    CharsetDatabase = "character_set_database"
    // CollationDatabase is the name for collation_database system variable.
    CollationDatabase = "collation_database"
    // GeneralLog is the name for 'general_log' system variable.
    GeneralLog = "general_log"
    // AvoidTemporalUpgrade is the name for 'avoid_temporal_upgrade' system variable.
    AvoidTemporalUpgrade = "avoid_temporal_upgrade"
    // MaxPreparedStmtCount is the name for 'max_prepared_stmt_count' system variable.
    MaxPreparedStmtCount = "max_prepared_stmt_count"
    // BigTables is the name for 'big_tables' system variable.
    BigTables = "big_tables"
    // CheckProxyUsers is the name for 'check_proxy_users' system variable.
    CheckProxyUsers = "check_proxy_users"
    // CoreFile is the name for 'core_file' system variable.
    CoreFile = "core_file"
    // DefaultWeekFormat is the name for 'default_week_format' system variable.
    DefaultWeekFormat = "default_week_format"
    // GroupConcatMaxLen is the name for 'group_concat_max_len' system variable.
    GroupConcatMaxLen = "group_concat_max_len"
    // DelayKeyWrite is the name for 'delay_key_write' system variable.
    DelayKeyWrite = "delay_key_write"
    // EndMakersInJSON is the name for 'end_markers_in_json' system variable.
    EndMakersInJSON = "end_markers_in_json"
    // InnodbCommitConcurrency is the name for 'innodb_commit_concurrency' system variable.
    InnodbCommitConcurrency = "innodb_commit_concurrency"
    // InnodbFastShutdown is the name for 'innodb_fast_shutdown' system variable.
    InnodbFastShutdown = "innodb_fast_shutdown"
    // InnodbLockWaitTimeout is the name for 'innodb_lock_wait_timeout' system variable.
    InnodbLockWaitTimeout = "innodb_lock_wait_timeout"
    // SQLLogBin is the name for 'sql_log_bin' system variable.
    SQLLogBin = "sql_log_bin"
    // LogBin is the name for 'log_bin' system variable.
    LogBin = "log_bin"
    // MaxSortLength is the name for 'max_sort_length' system variable.
    MaxSortLength = "max_sort_length"
    // MaxSpRecursionDepth is the name for 'max_sp_recursion_depth' system variable.
    MaxSpRecursionDepth = "max_sp_recursion_depth"
    // MaxUserConnections is the name for 'max_user_connections' system variable.
    MaxUserConnections = "max_user_connections"
    // OfflineMode is the name for 'offline_mode' system variable.
    OfflineMode = "offline_mode"
    // InteractiveTimeout is the name for 'interactive_timeout' system variable.
    InteractiveTimeout = "interactive_timeout"
    // FlushTime is the name for 'flush_time' system variable.
    FlushTime = "flush_time"
    // PseudoSlaveMode is the name for 'pseudo_slave_mode' system variable.
    PseudoSlaveMode = "pseudo_slave_mode"
    // LowPriorityUpdates is the name for 'low_priority_updates' system variable.
    LowPriorityUpdates = "low_priority_updates"
    // SessionTrackGtids is the name for 'session_track_gtids' system variable.
    SessionTrackGtids = "session_track_gtids"
    // OldPasswords is the name for 'old_passwords' system variable.
    OldPasswords = "old_passwords"
    // MaxConnections is the name for 'max_connections' system variable.
    MaxConnections = "max_connections"
    // SkipNameResolve is the name for 'skip_name_resolve' system variable.
    SkipNameResolve = "skip_name_resolve"
    // ForeignKeyChecks is the name for 'foreign_key_checks' system variable.
    ForeignKeyChecks = "foreign_key_checks"
    // SQLSafeUpdates is the name for 'sql_safe_updates' system variable.
    SQLSafeUpdates = "sql_safe_updates"
    // WarningCount is the name for 'warning_count' system variable.
    WarningCount = "warning_count"
    // ErrorCount is the name for 'error_count' system variable.
    ErrorCount = "error_count"
    // SQLSelectLimit is the name for 'sql_select_limit' system variable.
    SQLSelectLimit = "sql_select_limit"
    // MaxConnectErrors is the name for 'max_connect_errors' system variable.
    MaxConnectErrors = "max_connect_errors"
    // TableDefinitionCache is the name for 'table_definition_cache' system variable.
    TableDefinitionCache = "table_definition_cache"
    // TmpTableSize is the name for 'tmp_table_size' system variable.
    TmpTableSize = "tmp_table_size"
    // ConnectTimeout is the name for 'connect_timeout' system variable.
    ConnectTimeout = "connect_timeout"
    // SyncBinlog is the name for 'sync_binlog' system variable.
    SyncBinlog = "sync_binlog"
    // BlockEncryptionMode is the name for 'block_encryption_mode' system variable.
    BlockEncryptionMode = "block_encryption_mode"
    // WaitTimeout is the name for 'wait_timeout' system variable.
    WaitTimeout = "wait_timeout"
    // ValidatePasswordNumberCount is the name of 'validate_password_number_count' system variable.
    ValidatePasswordNumberCount = "validate_password_number_count"
    // ValidatePasswordLength is the name of 'validate_password_length' system variable.
    ValidatePasswordLength = "validate_password_length"
    // PluginDir is the name of 'plugin_dir' system variable.
    PluginDir = "plugin_dir"
    // PluginLoad is the name of 'plugin_load' system variable.
    PluginLoad = "plugin_load"
    // Port is the name for 'port' system variable.
    Port = "port"
    // DataDir is the name for 'datadir' system variable.
    DataDir = "datadir"
    // Profiling is the name for 'Profiling' system variable.
    Profiling = "profiling"
    // Socket is the name for 'socket' system variable.
    Socket = "socket"
    // BinlogOrderCommits is the name for 'binlog_order_commits' system variable.
    BinlogOrderCommits = "binlog_order_commits"
    // MasterVerifyChecksum is the name for 'master_verify_checksum' system variable.
    MasterVerifyChecksum = "master_verify_checksum"
    // ValidatePasswordCheckUserName is the name for 'validate_password_check_user_name' system variable.
    ValidatePasswordCheckUserName = "validate_password_check_user_name"
    // SuperReadOnly is the name for 'super_read_only' system variable.
    SuperReadOnly = "super_read_only"
    // SQLNotes is the name for 'sql_notes' system variable.
    SQLNotes = "sql_notes"
    // QueryCacheType is the name for 'query_cache_type' system variable.
    QueryCacheType = "query_cache_type"
    // SlaveCompressedProtocol is the name for 'slave_compressed_protocol' system variable.
    SlaveCompressedProtocol = "slave_compressed_protocol"
    // BinlogRowQueryLogEvents is the name for 'binlog_rows_query_log_events' system variable.
    BinlogRowQueryLogEvents = "binlog_rows_query_log_events"
    // LogSlowSlaveStatements is the name for 'log_slow_slave_statements' system variable.
    LogSlowSlaveStatements = "log_slow_slave_statements"
    // LogSlowAdminStatements is the name for 'log_slow_admin_statements' system variable.
    LogSlowAdminStatements = "log_slow_admin_statements"
    // LogQueriesNotUsingIndexes is the name for 'log_queries_not_using_indexes' system variable.
    LogQueriesNotUsingIndexes = "log_queries_not_using_indexes"
    // QueryCacheWlockInvalidate is the name for 'query_cache_wlock_invalidate' system variable.
    QueryCacheWlockInvalidate = "query_cache_wlock_invalidate"
    // SQLAutoIsNull is the name for 'sql_auto_is_null' system variable.
    SQLAutoIsNull = "sql_auto_is_null"
    // RelayLogPurge is the name for 'relay_log_purge' system variable.
    RelayLogPurge = "relay_log_purge"
    // AutomaticSpPrivileges is the name for 'automatic_sp_privileges' system variable.
    AutomaticSpPrivileges = "automatic_sp_privileges"
    // SQLQuoteShowCreate is the name for 'sql_quote_show_create' system variable.
    SQLQuoteShowCreate = "sql_quote_show_create"
    // SlowQueryLog is the name for 'slow_query_log' system variable.
    SlowQueryLog = "slow_query_log"
    // BinlogDirectNonTransactionalUpdates is the name for 'binlog_direct_non_transactional_updates' system variable.
    BinlogDirectNonTransactionalUpdates = "binlog_direct_non_transactional_updates"
    // SQLBigSelects is the name for 'sql_big_selects' system variable.
    SQLBigSelects = "sql_big_selects"
    // LogBinTrustFunctionCreators is the name for 'log_bin_trust_function_creators' system variable.
    LogBinTrustFunctionCreators = "log_bin_trust_function_creators"
    // OldAlterTable is the name for 'old_alter_table' system variable.
    OldAlterTable = "old_alter_table"
    // EnforceGtidConsistency is the name for 'enforce_gtid_consistency' system variable.
    EnforceGtidConsistency = "enforce_gtid_consistency"
    // SecureAuth is the name for 'secure_auth' system variable.
    SecureAuth = "secure_auth"
    // UniqueChecks is the name for 'unique_checks' system variable.
    UniqueChecks = "unique_checks"
    // SQLWarnings is the name for 'sql_warnings' system variable.
    SQLWarnings = "sql_warnings"
    // AutoCommit is the name for 'autocommit' system variable.
    AutoCommit = "autocommit"
    // KeepFilesOnCreate is the name for 'keep_files_on_create' system variable.
    KeepFilesOnCreate = "keep_files_on_create"
    // ShowOldTemporals is the name for 'show_old_temporals' system variable.
    ShowOldTemporals = "show_old_temporals"
    // LocalInFile is the name for 'local_infile' system variable.
    LocalInFile = "local_infile"
    // PerformanceSchema is the name for 'performance_schema' system variable.
    PerformanceSchema = "performance_schema"
    // Flush is the name for 'flush' system variable.
    Flush = "flush"
    // SlaveAllowBatching is the name for 'slave_allow_batching' system variable.
    SlaveAllowBatching = "slave_allow_batching"
    // MyISAMUseMmap is the name for 'myisam_use_mmap' system variable.
    MyISAMUseMmap = "myisam_use_mmap"
    // InnodbFilePerTable is the name for 'innodb_file_per_table' system variable.
    InnodbFilePerTable = "innodb_file_per_table"
    // InnodbLogCompressedPages is the name for 'innodb_log_compressed_pages' system variable.
    InnodbLogCompressedPages = "innodb_log_compressed_pages"
    // InnodbPrintAllDeadlocks is the name for 'innodb_print_all_deadlocks' system variable.
    InnodbPrintAllDeadlocks = "innodb_print_all_deadlocks"
    // InnodbStrictMode is the name for 'innodb_strict_mode' system variable.
    InnodbStrictMode = "innodb_strict_mode"
    // InnodbCmpPerIndexEnabled is the name for 'innodb_cmp_per_index_enabled' system variable.
    InnodbCmpPerIndexEnabled = "innodb_cmp_per_index_enabled"
    // InnodbBufferPoolDumpAtShutdown is the name for 'innodb_buffer_pool_dump_at_shutdown' system variable.
    InnodbBufferPoolDumpAtShutdown = "innodb_buffer_pool_dump_at_shutdown"
    // InnodbAdaptiveHashIndex is the name for 'innodb_adaptive_hash_index' system variable.
    InnodbAdaptiveHashIndex = "innodb_adaptive_hash_index"
    // InnodbFtEnableStopword is the name for 'innodb_ft_enable_stopword' system variable.
    InnodbFtEnableStopword = "innodb_ft_enable_stopword"
    // InnodbSupportXA is the name for 'innodb_support_xa' system variable.
    InnodbSupportXA = "innodb_support_xa"
    // InnodbOptimizeFullTextOnly is the name for 'innodb_optimize_fulltext_only' system variable.
    InnodbOptimizeFullTextOnly = "innodb_optimize_fulltext_only"
    // InnodbStatusOutputLocks is the name for 'innodb_status_output_locks' system variable.
    InnodbStatusOutputLocks = "innodb_status_output_locks"
    // InnodbBufferPoolDumpNow is the name for 'innodb_buffer_pool_dump_now' system variable.
    InnodbBufferPoolDumpNow = "innodb_buffer_pool_dump_now"
    // InnodbBufferPoolLoadNow is the name for 'innodb_buffer_pool_load_now' system variable.
    InnodbBufferPoolLoadNow = "innodb_buffer_pool_load_now"
    // InnodbStatsOnMetadata is the name for 'innodb_stats_on_metadata' system variable.
    InnodbStatsOnMetadata = "innodb_stats_on_metadata"
    // InnodbDisableSortFileCache is the name for 'innodb_disable_sort_file_cache' system variable.
    InnodbDisableSortFileCache = "innodb_disable_sort_file_cache"
    // InnodbStatsAutoRecalc is the name for 'innodb_stats_auto_recalc' system variable.
    InnodbStatsAutoRecalc = "innodb_stats_auto_recalc"
    // InnodbBufferPoolLoadAbort is the name for 'innodb_buffer_pool_load_abort' system variable.
    InnodbBufferPoolLoadAbort = "innodb_buffer_pool_load_abort"
    // InnodbStatsPersistent is the name for 'innodb_stats_persistent' system variable.
    InnodbStatsPersistent = "innodb_stats_persistent"
    // InnodbRandomReadAhead is the name for 'innodb_random_read_ahead' system variable.
    InnodbRandomReadAhead = "innodb_random_read_ahead"
    // InnodbAdaptiveFlushing is the name for 'innodb_adaptive_flushing' system variable.
    InnodbAdaptiveFlushing = "innodb_adaptive_flushing"
    // InnodbTableLocks is the name for 'innodb_table_locks' system variable.
    InnodbTableLocks = "innodb_table_locks"
    // InnodbStatusOutput is the name for 'innodb_status_output' system variable.
    InnodbStatusOutput = "innodb_status_output"

    // NetBufferLength is the name for 'net_buffer_length' system variable.
    NetBufferLength = "net_buffer_length"
    // QueryCacheSize is the name of 'query_cache_size' system variable.
    QueryCacheSize = "query_cache_size"
    // TxReadOnly is the name of 'tx_read_only' system variable.
    TxReadOnly = "tx_read_only"
    // TransactionReadOnly is the name of 'transaction_read_only' system variable.
    TransactionReadOnly = "transaction_read_only"
    // CharacterSetServer is the name of 'character_set_server' system variable.
    CharacterSetServer = "character_set_server"
    // AutoIncrementIncrement is the name of 'auto_increment_increment' system variable.
    AutoIncrementIncrement = "auto_increment_increment"
    // AutoIncrementOffset is the name of 'auto_increment_offset' system variable.
    AutoIncrementOffset = "auto_increment_offset"
    // InitConnect is the name of 'init_connect' system variable.
    InitConnect = "init_connect"
    // CollationServer is the name of 'collation_server' variable.
    CollationServer = "collation_server"
    // NetWriteTimeout is the name of 'net_write_timeout' variable.
    NetWriteTimeout = "net_write_timeout"
    // ThreadPoolSize is the name of 'thread_pool_size' variable.
    ThreadPoolSize = "thread_pool_size"
    // WindowingUseHighPrecision is the name of 'windowing_use_high_precision' system variable.
    WindowingUseHighPrecision = "windowing_use_high_precision"
)
const (
    TiDBDDLSlowOprThreshold = "ddl_slow_threshold"

    // tidb_snapshot is used for reading history data, the default value is empty string.
    // The value can be a datetime string like '2017-11-11 20:20:20' or a tso string. When this variable is set, the session reads history data of that time.
    TiDBSnapshot = "tidb_snapshot"

    // tidb_opt_agg_push_down is used to enable/disable the optimizer rule of aggregation push down.
    TiDBOptAggPushDown = "tidb_opt_agg_push_down"

    TiDBOptBCJ = "tidb_opt_broadcast_join"
    // tidb_opt_distinct_agg_push_down is used to decide whether agg with distinct should be pushed to tikv/tiflash.
    TiDBOptDistinctAggPushDown = "tidb_opt_distinct_agg_push_down"

    // tidb_opt_write_row_id is used to enable/disable the operations of insert、replace and update to _tidb_rowid.
    TiDBOptWriteRowID = "tidb_opt_write_row_id"

    // Auto analyze will run if (table modify count)/(table row count) is greater than this value.
    TiDBAutoAnalyzeRatio = "tidb_auto_analyze_ratio"

    // Auto analyze will run if current time is within start time and end time.
    TiDBAutoAnalyzeStartTime = "tidb_auto_analyze_start_time"
    TiDBAutoAnalyzeEndTime   = "tidb_auto_analyze_end_time"

    // tidb_checksum_table_concurrency is used to speed up the ADMIN CHECKSUM TABLE
    // statement, when a table has multiple indices, those indices can be
    // scanned concurrently, with the cost of higher system performance impact.
    TiDBChecksumTableConcurrency = "tidb_checksum_table_concurrency"

    // TiDBCurrentTS is used to get the current transaction timestamp.
    // It is read-only.
    TiDBCurrentTS = "tidb_current_ts"

    // tidb_config is a read-only variable that shows the config of the current server.
    TiDBConfig = "tidb_config"

    // tidb_batch_insert is used to enable/disable auto-split insert data. If set this option on, insert executor will automatically
    // insert data into multiple batches and use a single txn for each batch. This will be helpful when inserting large data.
    TiDBBatchInsert = "tidb_batch_insert"

    // tidb_batch_delete is used to enable/disable auto-split delete data. If set this option on, delete executor will automatically
    // split data into multiple batches and use a single txn for each batch. This will be helpful when deleting large data.
    TiDBBatchDelete = "tidb_batch_delete"

    // tidb_batch_commit is used to enable/disable auto-split the transaction.
    // If set this option on, the transaction will be committed when it reaches stmt-count-limit and starts a new transaction.
    TiDBBatchCommit = "tidb_batch_commit"

    // tidb_dml_batch_size is used to split the insert/delete data into small batches.
    // It only takes effort when tidb_batch_insert/tidb_batch_delete is on.
    // Its default value is 20000. When the row size is large, 20k rows could be larger than 100MB.
    // User could change it to a smaller one to avoid breaking the transaction size limitation.
    TiDBDMLBatchSize = "tidb_dml_batch_size"

    // The following session variables controls the memory quota during query execution.
    // "tidb_mem_quota_query":				control the memory quota of a query.
    TIDBMemQuotaQuery               = "tidb_mem_quota_query" // Bytes.
    TIDBNestedLoopJoinCacheCapacity = "tidb_nested_loop_join_cache_capacity"
    // TODO: remove them below sometime, it should have only one Quota(TIDBMemQuotaQuery).
    TIDBMemQuotaHashJoin          = "tidb_mem_quota_hashjoin"          // Bytes.
    TIDBMemQuotaMergeJoin         = "tidb_mem_quota_mergejoin"         // Bytes.
    TIDBMemQuotaSort              = "tidb_mem_quota_sort"              // Bytes.
    TIDBMemQuotaTopn              = "tidb_mem_quota_topn"              // Bytes.
    TIDBMemQuotaIndexLookupReader = "tidb_mem_quota_indexlookupreader" // Bytes.
    TIDBMemQuotaIndexLookupJoin   = "tidb_mem_quota_indexlookupjoin"   // Bytes.
    TIDBMemQuotaNestedLoopApply   = "tidb_mem_quota_nestedloopapply"   // Bytes.

    // tidb_general_log is used to log every query in the server in info level.
    TiDBGeneralLog = "tidb_general_log"

    // tidb_pprof_sql_cpu is used to add label sql label to pprof result.
    TiDBPProfSQLCPU = "tidb_pprof_sql_cpu"

    // tidb_retry_limit is the maximum number of retries when committing a transaction.
    TiDBRetryLimit = "tidb_retry_limit"

    // tidb_disable_txn_auto_retry disables transaction auto retry.
    TiDBDisableTxnAutoRetry = "tidb_disable_txn_auto_retry"

    // tidb_enable_streaming enables TiDB to use streaming API for coprocessor requests.
    TiDBEnableStreaming = "tidb_enable_streaming"

    // tidb_enable_chunk_rpc enables TiDB to use Chunk format for coprocessor requests.
    TiDBEnableChunkRPC = "tidb_enable_chunk_rpc"

    // tidb_optimizer_selectivity_level is used to control the selectivity estimation level.
    TiDBOptimizerSelectivityLevel = "tidb_optimizer_selectivity_level"

    // tidb_txn_mode is used to control the transaction behavior.
    TiDBTxnMode = "tidb_txn_mode"

    // tidb_row_format_version is used to control tidb row format version current.
    TiDBRowFormatVersion = "tidb_row_format_version"

    // tidb_enable_table_partition is used to control table partition feature.
    // The valid value include auto/on/off:
    // on or auto: enable table partition if the partition type is implemented.
    // off: always disable table partition.
    TiDBEnableTablePartition = "tidb_enable_table_partition"

    // tidb_skip_isolation_level_check is used to control whether to return error when set unsupported transaction
    // isolation level.
    TiDBSkipIsolationLevelCheck = "tidb_skip_isolation_level_check"

    // TiDBLowResolutionTSO is used for reading data with low resolution TSO which is updated once every two seconds
    TiDBLowResolutionTSO = "tidb_low_resolution_tso"

    // TiDBReplicaRead is used for reading data from replicas, followers for example.
    TiDBReplicaRead = "tidb_replica_read"

    // TiDBAllowRemoveAutoInc indicates whether a user can drop the auto_increment column attribute or not.
    TiDBAllowRemoveAutoInc = "tidb_allow_remove_auto_inc"

    // TiDBEvolvePlanTaskMaxTime controls the max time of a single evolution task.
    TiDBEvolvePlanTaskMaxTime = "tidb_evolve_plan_task_max_time"

    // TiDBEvolvePlanTaskStartTime is the start time of evolution task.
    TiDBEvolvePlanTaskStartTime = "tidb_evolve_plan_task_start_time"
    // TiDBEvolvePlanTaskEndTime is the end time of evolution task.
    TiDBEvolvePlanTaskEndTime = "tidb_evolve_plan_task_end_time"

    // tidb_slow_log_threshold is used to set the slow log threshold in the server.
    TiDBSlowLogThreshold = "tidb_slow_log_threshold"

    // tidb_record_plan_in_slow_log is used to log the plan of the slow query.
    TiDBRecordPlanInSlowLog = "tidb_record_plan_in_slow_log"

    // tidb_enable_slow_log enables TiDB to log slow queries.
    TiDBEnableSlowLog = "tidb_enable_slow_log"

    // tidb_query_log_max_len is used to set the max length of the query in the log.
    TiDBQueryLogMaxLen = "tidb_query_log_max_len"

    // TiDBCheckMb4ValueInUTF8 is used to control whether to enable the check wrong utf8 value.
    TiDBCheckMb4ValueInUTF8 = "tidb_check_mb4_value_in_utf8"

    // TiDBFoundInPlanCache indicates whether the last statement was found in plan cache
    TiDBFoundInPlanCache = "last_plan_from_cache"

    // TiDBAllowAutoRandExplicitInsert indicates whether explicit insertion on auto_random column is allowed.
    TiDBAllowAutoRandExplicitInsert = "allow_auto_random_explicit_insert"
)

TiDB system variable names that only in session scope.

const (
    // tidb_build_stats_concurrency is used to speed up the ANALYZE statement, when a table has multiple indices,
    // those indices can be scanned concurrently, with the cost of higher system performance impact.
    TiDBBuildStatsConcurrency = "tidb_build_stats_concurrency"

    // tidb_distsql_scan_concurrency is used to set the concurrency of a distsql scan task.
    // A distsql scan task can be a table scan or a index scan, which may be distributed to many TiKV nodes.
    // Higher concurrency may reduce latency, but with the cost of higher memory usage and system performance impact.
    // If the query has a LIMIT clause, high concurrency makes the system do much more work than needed.
    // tidb_distsql_scan_concurrency is deprecated, use tidb_executor_concurrency instead.
    TiDBDistSQLScanConcurrency = "tidb_distsql_scan_concurrency"

    // tidb_opt_insubquery_to_join_and_agg is used to enable/disable the optimizer rule of rewriting IN subquery.
    TiDBOptInSubqToJoinAndAgg = "tidb_opt_insubq_to_join_and_agg"

    // tidb_opt_correlation_threshold is a guard to enable row count estimation using column order correlation.
    TiDBOptCorrelationThreshold = "tidb_opt_correlation_threshold"

    // tidb_opt_correlation_exp_factor is an exponential factor to control heuristic approach when tidb_opt_correlation_threshold is not satisfied.
    TiDBOptCorrelationExpFactor = "tidb_opt_correlation_exp_factor"

    // tidb_opt_cpu_factor is the CPU cost of processing one expression for one row.
    TiDBOptCPUFactor = "tidb_opt_cpu_factor"
    // tidb_opt_copcpu_factor is the CPU cost of processing one expression for one row in coprocessor.
    TiDBOptCopCPUFactor = "tidb_opt_copcpu_factor"
    // tidb_opt_tiflash_concurrency_factor is concurrency number of tiflash computation.
    TiDBOptTiFlashConcurrencyFactor = "tidb_opt_tiflash_concurrency_factor"
    // tidb_opt_network_factor is the network cost of transferring 1 byte data.
    TiDBOptNetworkFactor = "tidb_opt_network_factor"
    // tidb_opt_scan_factor is the IO cost of scanning 1 byte data on TiKV.
    TiDBOptScanFactor = "tidb_opt_scan_factor"
    // tidb_opt_desc_factor is the IO cost of scanning 1 byte data on TiKV in desc order.
    TiDBOptDescScanFactor = "tidb_opt_desc_factor"
    // tidb_opt_seek_factor is the IO cost of seeking the start value in a range on TiKV or TiFlash.
    TiDBOptSeekFactor = "tidb_opt_seek_factor"
    // tidb_opt_memory_factor is the memory cost of storing one tuple.
    TiDBOptMemoryFactor = "tidb_opt_memory_factor"
    // tidb_opt_disk_factor is the IO cost of reading/writing one byte to temporary disk.
    TiDBOptDiskFactor = "tidb_opt_disk_factor"
    // tidb_opt_concurrency_factor is the CPU cost of additional one goroutine.
    TiDBOptConcurrencyFactor = "tidb_opt_concurrency_factor"

    // tidb_index_join_batch_size is used to set the batch size of a index lookup join.
    // The index lookup join fetches batches of data from outer executor and constructs ranges for inner executor.
    // This value controls how much of data in a batch to do the index join.
    // Large value may reduce the latency but consumes more system resource.
    TiDBIndexJoinBatchSize = "tidb_index_join_batch_size"

    // tidb_index_lookup_size is used for index lookup executor.
    // The index lookup executor first scan a batch of handles from a index, then use those handles to lookup the table
    // rows, this value controls how much of handles in a batch to do a lookup task.
    // Small value sends more RPCs to TiKV, consume more system resource.
    // Large value may do more work than needed if the query has a limit.
    TiDBIndexLookupSize = "tidb_index_lookup_size"

    // tidb_index_lookup_concurrency is used for index lookup executor.
    // A lookup task may have 'tidb_index_lookup_size' of handles at maximun, the handles may be distributed
    // in many TiKV nodes, we executes multiple concurrent index lookup tasks concurrently to reduce the time
    // waiting for a task to finish.
    // Set this value higher may reduce the latency but consumes more system resource.
    // tidb_index_lookup_concurrency is deprecated, use tidb_executor_concurrency instead.
    TiDBIndexLookupConcurrency = "tidb_index_lookup_concurrency"

    // tidb_index_lookup_join_concurrency is used for index lookup join executor.
    // IndexLookUpJoin starts "tidb_index_lookup_join_concurrency" inner workers
    // to fetch inner rows and join the matched (outer, inner) row pairs.
    // tidb_index_lookup_join_concurrency is deprecated, use tidb_executor_concurrency instead.
    TiDBIndexLookupJoinConcurrency = "tidb_index_lookup_join_concurrency"

    // tidb_index_serial_scan_concurrency is used for controlling the concurrency of index scan operation
    // when we need to keep the data output order the same as the order of index data.
    TiDBIndexSerialScanConcurrency = "tidb_index_serial_scan_concurrency"

    // TiDBMaxChunkSize is used to control the max chunk size during query execution.
    TiDBMaxChunkSize = "tidb_max_chunk_size"

    // TiDBAllowBatchCop means if we should send batch coprocessor to TiFlash. It can be set to 0, 1 and 2.
    // 0 means never use batch cop, 1 means use batch cop in case of aggregation and join, 2, means to force to send batch cop for any query.
    // The default value is 0
    TiDBAllowBatchCop = "tidb_allow_batch_cop"

    // TiDBInitChunkSize is used to control the init chunk size during query execution.
    TiDBInitChunkSize = "tidb_init_chunk_size"

    // tidb_enable_cascades_planner is used to control whether to enable the cascades planner.
    TiDBEnableCascadesPlanner = "tidb_enable_cascades_planner"

    // tidb_skip_utf8_check skips the UTF8 validate process, validate UTF8 has performance cost, if we can make sure
    // the input string values are valid, we can skip the check.
    TiDBSkipUTF8Check = "tidb_skip_utf8_check"

    // tidb_skip_ascii_check skips the ASCII validate process
    // old tidb may already have fields with invalid ASCII bytes
    // disable ASCII validate can guarantee a safe replication
    TiDBSkipASCIICheck = "tidb_skip_ascii_check"

    // tidb_hash_join_concurrency is used for hash join executor.
    // The hash join outer executor starts multiple concurrent join workers to probe the hash table.
    // tidb_hash_join_concurrency is deprecated, use tidb_executor_concurrency instead.
    TiDBHashJoinConcurrency = "tidb_hash_join_concurrency"

    // tidb_projection_concurrency is used for projection operator.
    // This variable controls the worker number of projection operator.
    // tidb_projection_concurrency is deprecated, use tidb_executor_concurrency instead.
    TiDBProjectionConcurrency = "tidb_projection_concurrency"

    // tidb_hashagg_partial_concurrency is used for hash agg executor.
    // The hash agg executor starts multiple concurrent partial workers to do partial aggregate works.
    // tidb_hashagg_partial_concurrency is deprecated, use tidb_executor_concurrency instead.
    TiDBHashAggPartialConcurrency = "tidb_hashagg_partial_concurrency"

    // tidb_hashagg_final_concurrency is used for hash agg executor.
    // The hash agg executor starts multiple concurrent final workers to do final aggregate works.
    // tidb_hashagg_final_concurrency is deprecated, use tidb_executor_concurrency instead.
    TiDBHashAggFinalConcurrency = "tidb_hashagg_final_concurrency"

    // tidb_window_concurrency is used for window parallel executor.
    // tidb_window_concurrency is deprecated, use tidb_executor_concurrency instead.
    TiDBWindowConcurrency = "tidb_window_concurrency"

    // tidb_enable_parallel_apply is used for parallel apply.
    TiDBEnableParallelApply = "tidb_enable_parallel_apply"

    // tidb_backoff_lock_fast is used for tikv backoff base time in milliseconds.
    TiDBBackoffLockFast = "tidb_backoff_lock_fast"

    // tidb_backoff_weight is used to control the max back off time in TiDB.
    // The default maximum back off time is a small value.
    // BackOffWeight could multiply it to let the user adjust the maximum time for retrying.
    // Only positive integers can be accepted, which means that the maximum back off time can only grow.
    TiDBBackOffWeight = "tidb_backoff_weight"

    // tidb_ddl_reorg_worker_cnt defines the count of ddl reorg workers.
    TiDBDDLReorgWorkerCount = "tidb_ddl_reorg_worker_cnt"

    // tidb_ddl_reorg_batch_size defines the transaction batch size of ddl reorg workers.
    TiDBDDLReorgBatchSize = "tidb_ddl_reorg_batch_size"

    // tidb_ddl_error_count_limit defines the count of ddl error limit.
    TiDBDDLErrorCountLimit = "tidb_ddl_error_count_limit"

    // tidb_ddl_reorg_priority defines the operations priority of adding indices.
    // It can be: PRIORITY_LOW, PRIORITY_NORMAL, PRIORITY_HIGH
    TiDBDDLReorgPriority = "tidb_ddl_reorg_priority"

    // tidb_max_delta_schema_count defines the max length of deltaSchemaInfos.
    // deltaSchemaInfos is a queue that maintains the history of schema changes.
    TiDBMaxDeltaSchemaCount = "tidb_max_delta_schema_count"

    // tidb_scatter_region will scatter the regions for DDLs when it is ON.
    TiDBScatterRegion = "tidb_scatter_region"

    // TiDBWaitSplitRegionFinish defines the split region behaviour is sync or async.
    TiDBWaitSplitRegionFinish = "tidb_wait_split_region_finish"

    // TiDBWaitSplitRegionTimeout uses to set the split and scatter region back off time.
    TiDBWaitSplitRegionTimeout = "tidb_wait_split_region_timeout"

    // tidb_force_priority defines the operations priority of all statements.
    // It can be "NO_PRIORITY", "LOW_PRIORITY", "HIGH_PRIORITY", "DELAYED"
    TiDBForcePriority = "tidb_force_priority"

    // tidb_enable_radix_join indicates to use radix hash join algorithm to execute
    // HashJoin.
    TiDBEnableRadixJoin = "tidb_enable_radix_join"

    // tidb_constraint_check_in_place indicates to check the constraint when the SQL executing.
    // It could hurt the performance of bulking insert when it is ON.
    TiDBConstraintCheckInPlace = "tidb_constraint_check_in_place"

    // tidb_enable_window_function is used to control whether to enable the window function.
    TiDBEnableWindowFunction = "tidb_enable_window_function"

    // tidb_enable_vectorized_expression is used to control whether to enable the vectorized expression evaluation.
    TiDBEnableVectorizedExpression = "tidb_enable_vectorized_expression"

    // TIDBOptJoinReorderThreshold defines the threshold less than which
    // we'll choose a rather time consuming algorithm to calculate the join order.
    TiDBOptJoinReorderThreshold = "tidb_opt_join_reorder_threshold"

    // SlowQueryFile indicates which slow query log file for SLOW_QUERY table to parse.
    TiDBSlowQueryFile = "tidb_slow_query_file"

    // TiDBEnableFastAnalyze indicates to use fast analyze.
    TiDBEnableFastAnalyze = "tidb_enable_fast_analyze"

    // TiDBExpensiveQueryTimeThreshold indicates the time threshold of expensive query.
    TiDBExpensiveQueryTimeThreshold = "tidb_expensive_query_time_threshold"

    // TiDBEnableIndexMerge indicates to generate IndexMergePath.
    TiDBEnableIndexMerge = "tidb_enable_index_merge"

    // TiDBEnableNoopFuncs set true will enable using fake funcs(like get_lock release_lock)
    TiDBEnableNoopFuncs = "tidb_enable_noop_functions"

    // TiDBEnableStmtSummary indicates whether the statement summary is enabled.
    TiDBEnableStmtSummary = "tidb_enable_stmt_summary"

    // TiDBStmtSummaryInternalQuery indicates whether the statement summary contain internal query.
    TiDBStmtSummaryInternalQuery = "tidb_stmt_summary_internal_query"

    // TiDBStmtSummaryRefreshInterval indicates the refresh interval in seconds for each statement summary.
    TiDBStmtSummaryRefreshInterval = "tidb_stmt_summary_refresh_interval"

    // TiDBStmtSummaryHistorySize indicates the history size of each statement summary.
    TiDBStmtSummaryHistorySize = "tidb_stmt_summary_history_size"

    // TiDBStmtSummaryMaxStmtCount indicates the max number of statements kept in memory.
    TiDBStmtSummaryMaxStmtCount = "tidb_stmt_summary_max_stmt_count"

    // TiDBStmtSummaryMaxSQLLength indicates the max length of displayed normalized sql and sample sql.
    TiDBStmtSummaryMaxSQLLength = "tidb_stmt_summary_max_sql_length"

    // TiDBCapturePlanBaseline indicates whether the capture of plan baselines is enabled.
    TiDBCapturePlanBaseline = "tidb_capture_plan_baselines"

    // TiDBUsePlanBaselines indicates whether the use of plan baselines is enabled.
    TiDBUsePlanBaselines = "tidb_use_plan_baselines"

    // TiDBEvolvePlanBaselines indicates whether the evolution of plan baselines is enabled.
    TiDBEvolvePlanBaselines = "tidb_evolve_plan_baselines"

    // TiDBIsolationReadEngines indicates the tidb only read from the stores whose engine type is involved in IsolationReadEngines.
    // Now, only support TiKV and TiFlash.
    TiDBIsolationReadEngines = "tidb_isolation_read_engines"

    // TiDBStoreLimit indicates the limit of sending request to a store, 0 means without limit.
    TiDBStoreLimit = "tidb_store_limit"

    // TiDBMetricSchemaStep indicates the step when query metric schema.
    TiDBMetricSchemaStep = "tidb_metric_query_step"

    // TiDBMetricSchemaRangeDuration indicates the range duration when query metric schema.
    TiDBMetricSchemaRangeDuration = "tidb_metric_query_range_duration"

    // TiDBEnableCollectExecutionInfo indicates that whether execution info is collected.
    TiDBEnableCollectExecutionInfo = "tidb_enable_collect_execution_info"

    // DefExecutorConcurrency is used for controlling the concurrency of all types of executors.
    TiDBExecutorConcurrency = "tidb_executor_concurrency"

    // TiDBEnableClusteredIndex indicates if clustered index feature is enabled.
    TiDBEnableClusteredIndex = "tidb_enable_clustered_index"

    // TiDBSlowLogMasking indicates that whether masking the query data when log slow query.
    // Deprecated: use TiDBLogDesensitization instead.
    TiDBSlowLogMasking = "tidb_slow_log_masking"

    // TiDBLogDesensitization indicates that whether desensitization when log query.
    TiDBLogDesensitization = "tidb_log_desensitization"

    // TiDBShardAllocateStep indicates the max size of continuous rowid shard in one transaction.
    TiDBShardAllocateStep = "tidb_shard_allocate_step"
    // TiDBEnableTelemetry indicates that whether usage data report to PingCAP is enabled.
    TiDBEnableTelemetry = "tidb_enable_telemetry"
)

TiDB system variable names that both in session and global scope.

const (
    DefHostname                        = "localhost"
    DefIndexLookupConcurrency          = ConcurrencyUnset
    DefIndexLookupJoinConcurrency      = ConcurrencyUnset
    DefIndexSerialScanConcurrency      = 1
    DefIndexJoinBatchSize              = 25000
    DefIndexLookupSize                 = 20000
    DefDistSQLScanConcurrency          = 15
    DefBuildStatsConcurrency           = 4
    DefAutoAnalyzeRatio                = 0.5
    DefAutoAnalyzeStartTime            = "00:00 +0000"
    DefAutoAnalyzeEndTime              = "23:59 +0000"
    DefAutoIncrementIncrement          = 1
    DefAutoIncrementOffset             = 1
    DefChecksumTableConcurrency        = 4
    DefSkipUTF8Check                   = false
    DefSkipASCIICheck                  = false
    DefOptAggPushDown                  = false
    DefOptBCJ                          = false
    DefOptWriteRowID                   = false
    DefOptCorrelationThreshold         = 0.9
    DefOptCorrelationExpFactor         = 1
    DefOptCPUFactor                    = 3.0
    DefOptCopCPUFactor                 = 3.0
    DefOptTiFlashConcurrencyFactor     = 24.0
    DefOptNetworkFactor                = 1.0
    DefOptScanFactor                   = 1.5
    DefOptDescScanFactor               = 3.0
    DefOptSeekFactor                   = 20.0
    DefOptMemoryFactor                 = 0.001
    DefOptDiskFactor                   = 1.5
    DefOptConcurrencyFactor            = 3.0
    DefOptInSubqToJoinAndAgg           = true
    DefBatchInsert                     = false
    DefBatchDelete                     = false
    DefBatchCommit                     = false
    DefCurretTS                        = 0
    DefInitChunkSize                   = 32
    DefMaxChunkSize                    = 1024
    DefDMLBatchSize                    = 0
    DefMaxPreparedStmtCount            = -1
    DefWaitTimeout                     = 0
    DefTiDBMemQuotaHashJoin            = 32 << 30 // 32GB.
    DefTiDBMemQuotaMergeJoin           = 32 << 30 // 32GB.
    DefTiDBMemQuotaSort                = 32 << 30 // 32GB.
    DefTiDBMemQuotaTopn                = 32 << 30 // 32GB.
    DefTiDBMemQuotaIndexLookupReader   = 32 << 30 // 32GB.
    DefTiDBMemQuotaIndexLookupJoin     = 32 << 30 // 32GB.
    DefTiDBMemQuotaNestedLoopApply     = 32 << 30 // 32GB.
    DefTiDBMemQuotaDistSQL             = 32 << 30 // 32GB.
    DefTiDBGeneralLog                  = 0
    DefTiDBPProfSQLCPU                 = 0
    DefTiDBRetryLimit                  = 10
    DefTiDBDisableTxnAutoRetry         = true
    DefTiDBConstraintCheckInPlace      = false
    DefTiDBHashJoinConcurrency         = ConcurrencyUnset
    DefTiDBProjectionConcurrency       = ConcurrencyUnset
    DefTiDBOptimizerSelectivityLevel   = 0
    DefTiDBAllowBatchCop               = 1
    DefTiDBTxnMode                     = ""
    DefTiDBRowFormatV1                 = 1
    DefTiDBRowFormatV2                 = 2
    DefTiDBDDLReorgWorkerCount         = 4
    DefTiDBDDLReorgBatchSize           = 256
    DefTiDBDDLErrorCountLimit          = 512
    DefTiDBMaxDeltaSchemaCount         = 1024
    DefTiDBHashAggPartialConcurrency   = ConcurrencyUnset
    DefTiDBHashAggFinalConcurrency     = ConcurrencyUnset
    DefTiDBWindowConcurrency           = ConcurrencyUnset
    DefTiDBForcePriority               = mysql.NoPriority
    DefTiDBUseRadixJoin                = false
    DefEnableWindowFunction            = true
    DefEnableVectorizedExpression      = true
    DefTiDBOptJoinReorderThreshold     = 0
    DefTiDBDDLSlowOprThreshold         = 300
    DefTiDBUseFastAnalyze              = false
    DefTiDBSkipIsolationLevelCheck     = false
    DefTiDBExpensiveQueryTimeThreshold = 60 // 60s
    DefTiDBScatterRegion               = false
    DefTiDBWaitSplitRegionFinish       = true
    DefWaitSplitRegionTimeout          = 300 // 300s
    DefTiDBEnableNoopFuncs             = false
    DefTiDBAllowRemoveAutoInc          = false
    DefTiDBUsePlanBaselines            = true
    DefTiDBEvolvePlanBaselines         = false
    DefTiDBEvolvePlanTaskMaxTime       = 600 // 600s
    DefTiDBEvolvePlanTaskStartTime     = "00:00 +0000"
    DefTiDBEvolvePlanTaskEndTime       = "23:59 +0000"
    DefInnodbLockWaitTimeout           = 50 // 50s
    DefTiDBStoreLimit                  = 0
    DefTiDBMetricSchemaStep            = 60 // 60s
    DefTiDBMetricSchemaRangeDuration   = 60 // 60s
    DefTiDBFoundInPlanCache            = false
    DefTiDBEnableCollectExecutionInfo  = true
    DefTiDBAllowAutoRandExplicitInsert = false
    DefTiDBEnableClusteredIndex        = false
    DefTiDBSlowLogMasking              = false
    DefTiDBLogDesensitization          = false
    DefTiDBShardAllocateStep           = math.MaxInt64
    DefTiDBEnableTelemetry             = true
    DefTiDBEnableParallelApply         = false
)

Default TiDB system variable values.

const ConcurrencyUnset = -1

ConcurrencyUnset means the value the of the concurrency related variable is unset.

const (

    // FullDayTimeFormat is the full format of analyze start time and end time.
    FullDayTimeFormat = "15:04 -0700"
)

Variables

var (
    ErrCantSetToNull               = terror.ClassVariable.New(mysql.ErrCantSetToNull, mysql.MySQLErrName[mysql.ErrCantSetToNull])
    ErrSnapshotTooOld              = terror.ClassVariable.New(mysql.ErrSnapshotTooOld, mysql.MySQLErrName[mysql.ErrSnapshotTooOld])
    ErrUnsupportedValueForVar      = terror.ClassVariable.New(mysql.ErrUnsupportedValueForVar, mysql.MySQLErrName[mysql.ErrUnsupportedValueForVar])
    ErrUnknownSystemVar            = terror.ClassVariable.New(mysql.ErrUnknownSystemVariable, mysql.MySQLErrName[mysql.ErrUnknownSystemVariable])
    ErrIncorrectScope              = terror.ClassVariable.New(mysql.ErrIncorrectGlobalLocalVar, mysql.MySQLErrName[mysql.ErrIncorrectGlobalLocalVar])
    ErrUnknownTimeZone             = terror.ClassVariable.New(mysql.ErrUnknownTimeZone, mysql.MySQLErrName[mysql.ErrUnknownTimeZone])
    ErrReadOnly                    = terror.ClassVariable.New(mysql.ErrVariableIsReadonly, mysql.MySQLErrName[mysql.ErrVariableIsReadonly])
    ErrWrongValueForVar            = terror.ClassVariable.New(mysql.ErrWrongValueForVar, mysql.MySQLErrName[mysql.ErrWrongValueForVar])
    ErrWrongTypeForVar             = terror.ClassVariable.New(mysql.ErrWrongTypeForVar, mysql.MySQLErrName[mysql.ErrWrongTypeForVar])
    ErrTruncatedWrongValue         = terror.ClassVariable.New(mysql.ErrTruncatedWrongValue, mysql.MySQLErrName[mysql.ErrTruncatedWrongValue])
    ErrMaxPreparedStmtCountReached = terror.ClassVariable.New(mysql.ErrMaxPreparedStmtCountReached, mysql.MySQLErrName[mysql.ErrMaxPreparedStmtCountReached])
    ErrUnsupportedIsolationLevel   = terror.ClassVariable.New(mysql.ErrUnsupportedIsolationLevel, mysql.MySQLErrName[mysql.ErrUnsupportedIsolationLevel])
)

Error instances.

var (
    ProcessGeneralLog uint32
    EnablePProfSQLCPU = atomic.NewBool(false)

    // Export for testing.
    MaxDDLReorgBatchSize int32 = 10240
    MinDDLReorgBatchSize int32 = 32
    // DDLSlowOprThreshold is the threshold for ddl slow operations, uint is millisecond.
    DDLSlowOprThreshold            uint32 = DefTiDBDDLSlowOprThreshold
    ForcePriority                         = int32(DefTiDBForcePriority)
    ServerHostname, _                     = os.Hostname()
    MaxOfMaxAllowedPacket          uint64 = 1073741824
    ExpensiveQueryTimeThreshold    uint64 = DefTiDBExpensiveQueryTimeThreshold
    MinExpensiveQueryTimeThreshold uint64 = 10 //10s
    CapturePlanBaseline                   = serverGlobalVariable{/* contains filtered or unexported fields */}
    DefExecutorConcurrency                = 5
)

Process global variables.

var DefaultStatusVarScopeFlag = ScopeGlobal | ScopeSession

DefaultStatusVarScopeFlag is the default scope of status variables.

var PluginVarNames []string

PluginVarNames is global plugin var names set.

var SetCharsetVariables = []string{
    "character_set_client",
    "character_set_results",
}

SetCharsetVariables is the system variable names related to set charset statements.

var SetNamesVariables = []string{
    "character_set_client",
    "character_set_connection",
    "character_set_results",
}

SetNamesVariables is the system variable names related to set names statements.

var SynonymsSysVariables = map[string][]string{}

SynonymsSysVariables is synonyms of system variables.

var SysVars map[string]*SysVar

SysVars is global sys vars map.

var (
    // TxIsolationNames are the valid values of the variable "tx_isolation" or "transaction_isolation".
    TxIsolationNames = map[string]struct{}{
        "READ-UNCOMMITTED": {},
        "READ-COMMITTED":   {},
        "REPEATABLE-READ":  {},
        "SERIALIZABLE":     {},
    }
)

func BoolToInt32 Uses

func BoolToInt32(b bool) int32

BoolToInt32 converts bool to int32

func BoolToIntStr Uses

func BoolToIntStr(b bool) string

BoolToIntStr converts bool to int string, for example "0" or "1".

func CheckDeprecationSetSystemVar Uses

func CheckDeprecationSetSystemVar(s *SessionVars, name string)

CheckDeprecationSetSystemVar checks if the system variable is deprecated.

func GetDDLErrorCountLimit Uses

func GetDDLErrorCountLimit() int64

GetDDLErrorCountLimit gets ddlErrorCountlimit size.

func GetDDLReorgBatchSize Uses

func GetDDLReorgBatchSize() int32

GetDDLReorgBatchSize gets ddlReorgBatchSize.

func GetDDLReorgWorkerCounter Uses

func GetDDLReorgWorkerCounter() int32

GetDDLReorgWorkerCounter gets ddlReorgWorkerCounter.

func GetGlobalSystemVar Uses

func GetGlobalSystemVar(s *SessionVars, key string) (string, error)

GetGlobalSystemVar gets a global system variable.

func GetMaxDeltaSchemaCount Uses

func GetMaxDeltaSchemaCount() int64

GetMaxDeltaSchemaCount gets maxDeltaSchemaCount size.

func GetScopeNoneSystemVar Uses

func GetScopeNoneSystemVar(key string) (string, bool, error)

GetScopeNoneSystemVar checks the validation of `key`, and return the default value if its scope is `ScopeNone`.

func GetSessionOnlySysVars Uses

func GetSessionOnlySysVars(s *SessionVars, key string) (string, bool, error)

GetSessionOnlySysVars get the default value defined in code for session only variable. The return bool value indicates whether it's a session only variable.

func GetSessionSystemVar Uses

func GetSessionSystemVar(s *SessionVars, key string) (string, error)

GetSessionSystemVar gets a system variable. If it is a session only variable, use the default value defined in code. Returns error if there is no such variable.

func GetStatusVars Uses

func GetStatusVars(vars *SessionVars) (map[string]*StatusVal, error)

GetStatusVars gets registered statistics status variables. TODO: Refactor this function to avoid repeated memory allocation / dealloc

func GoTimeToTS Uses

func GoTimeToTS(t time.Time) uint64

GoTimeToTS converts a Go time to uint64 timestamp.

func RegisterStatistics Uses

func RegisterStatistics(s Statistics)

RegisterStatistics registers statistics.

func SetDDLErrorCountLimit Uses

func SetDDLErrorCountLimit(cnt int64)

SetDDLErrorCountLimit sets ddlErrorCountlimit size.

func SetDDLReorgBatchSize Uses

func SetDDLReorgBatchSize(cnt int32)

SetDDLReorgBatchSize sets ddlReorgBatchSize size. Max batch size is MaxDDLReorgBatchSize.

func SetDDLReorgWorkerCounter Uses

func SetDDLReorgWorkerCounter(cnt int32)

SetDDLReorgWorkerCounter sets ddlReorgWorkerCounter count. Max worker count is maxDDLReorgWorkerCount.

func SetLocalSystemVar Uses

func SetLocalSystemVar(name string, val string)

SetLocalSystemVar sets values of the local variables which in "server" scope.

func SetMaxDeltaSchemaCount Uses

func SetMaxDeltaSchemaCount(cnt int64)

SetMaxDeltaSchemaCount sets maxDeltaSchemaCount size.

func SetSessionSystemVar Uses

func SetSessionSystemVar(vars *SessionVars, name string, value types.Datum) error

SetSessionSystemVar sets system variable and updates SessionVars states.

func TiDBOptOn Uses

func TiDBOptOn(opt string) bool

TiDBOptOn could be used for all tidb session variable options, we use "ON"/1 to turn on those options.

func ValidateGetSystemVar Uses

func ValidateGetSystemVar(name string, isGlobal bool) error

ValidateGetSystemVar checks if system variable exists and validates its scope when get system variable.

func ValidateSetSystemVar Uses

func ValidateSetSystemVar(vars *SessionVars, name string, value string, scope ScopeFlag) (string, error)

ValidateSetSystemVar checks if system variable satisfies specific restriction.

type BatchSize Uses

type BatchSize struct {
    // IndexJoinBatchSize is the batch size of a index lookup join.
    IndexJoinBatchSize int

    // IndexLookupSize is the number of handles for an index lookup task in index double read executor.
    IndexLookupSize int

    // InitChunkSize defines init row count of a Chunk during query execution.
    InitChunkSize int

    // MaxChunkSize defines max row count of a Chunk during query execution.
    MaxChunkSize int
}

BatchSize defines batch size values.

type Concurrency Uses

type Concurrency struct {

    // ExecutorConcurrency is the number of concurrent worker for all executors.
    ExecutorConcurrency int
    // contains filtered or unexported fields
}

Concurrency defines concurrency values.

func (*Concurrency) DistSQLScanConcurrency Uses

func (c *Concurrency) DistSQLScanConcurrency() int

DistSQLScanConcurrency return the number of concurrent dist SQL scan worker.

func (*Concurrency) HashAggFinalConcurrency Uses

func (c *Concurrency) HashAggFinalConcurrency() int

HashAggFinalConcurrency return the number of concurrent hash aggregation final worker.

func (*Concurrency) HashAggPartialConcurrency Uses

func (c *Concurrency) HashAggPartialConcurrency() int

HashAggPartialConcurrency return the number of concurrent hash aggregation partial worker.

func (*Concurrency) HashJoinConcurrency Uses

func (c *Concurrency) HashJoinConcurrency() int

HashJoinConcurrency return the number of concurrent hash join outer worker.

func (*Concurrency) IndexLookupConcurrency Uses

func (c *Concurrency) IndexLookupConcurrency() int

IndexLookupConcurrency return the number of concurrent index lookup worker.

func (*Concurrency) IndexLookupJoinConcurrency Uses

func (c *Concurrency) IndexLookupJoinConcurrency() int

IndexLookupJoinConcurrency return the number of concurrent index lookup join inner worker.

func (*Concurrency) IndexSerialScanConcurrency Uses

func (c *Concurrency) IndexSerialScanConcurrency() int

IndexSerialScanConcurrency return the number of concurrent index serial scan worker. This option is not sync with ExecutorConcurrency since it's used by Analyze table.

func (*Concurrency) ProjectionConcurrency Uses

func (c *Concurrency) ProjectionConcurrency() int

ProjectionConcurrency return the number of concurrent projection worker.

func (*Concurrency) SetDistSQLScanConcurrency Uses

func (c *Concurrency) SetDistSQLScanConcurrency(n int)

SetDistSQLScanConcurrency set the number of concurrent dist SQL scan worker.

func (*Concurrency) SetHashAggFinalConcurrency Uses

func (c *Concurrency) SetHashAggFinalConcurrency(n int)

SetHashAggFinalConcurrency set the number of concurrent hash aggregation final worker.

func (*Concurrency) SetHashAggPartialConcurrency Uses

func (c *Concurrency) SetHashAggPartialConcurrency(n int)

SetHashAggPartialConcurrency set the number of concurrent hash aggregation partial worker.

func (*Concurrency) SetHashJoinConcurrency Uses

func (c *Concurrency) SetHashJoinConcurrency(n int)

SetHashJoinConcurrency set the number of concurrent hash join outer worker.

func (*Concurrency) SetIndexLookupConcurrency Uses

func (c *Concurrency) SetIndexLookupConcurrency(n int)

SetIndexLookupConcurrency set the number of concurrent index lookup worker.

func (*Concurrency) SetIndexLookupJoinConcurrency Uses

func (c *Concurrency) SetIndexLookupJoinConcurrency(n int)

SetIndexLookupJoinConcurrency set the number of concurrent index lookup join inner worker.

func (*Concurrency) SetIndexSerialScanConcurrency Uses

func (c *Concurrency) SetIndexSerialScanConcurrency(n int)

SetIndexSerialScanConcurrency set the number of concurrent index serial scan worker.

func (*Concurrency) SetProjectionConcurrency Uses

func (c *Concurrency) SetProjectionConcurrency(n int)

SetProjectionConcurrency set the number of concurrent projection worker.

func (*Concurrency) SetWindowConcurrency Uses

func (c *Concurrency) SetWindowConcurrency(n int)

SetWindowConcurrency set the number of concurrent window worker.

func (*Concurrency) WindowConcurrency Uses

func (c *Concurrency) WindowConcurrency() int

WindowConcurrency return the number of concurrent window worker.

type ConnectionInfo Uses

type ConnectionInfo struct {
    ConnectionID      uint32
    ConnectionType    string
    Host              string
    ClientIP          string
    ClientPort        string
    ServerID          int
    ServerPort        int
    Duration          float64
    User              string
    ServerOSLoginUser string
    OSVersion         string
    ClientVersion     string
    ServerVersion     string
    SSLVersion        string
    PID               int
    DB                string
}

ConnectionInfo present connection used by audit.

type GlobalVarAccessor Uses

type GlobalVarAccessor interface {
    // GetAllSysVars gets all the global system variable values.
    GetAllSysVars() (map[string]string, error)
    // GetGlobalSysVar gets the global system variable value for name.
    GetGlobalSysVar(name string) (string, error)
    // SetGlobalSysVar sets the global system variable name to value.
    SetGlobalSysVar(name string, value string) error
}

GlobalVarAccessor is the interface for accessing global scope system and status variables.

type MemQuota Uses

type MemQuota struct {
    // MemQuotaQuery defines the memory quota for a query.
    MemQuotaQuery int64

    // NestedLoopJoinCacheCapacity defines the memory capacity for apply cache.
    NestedLoopJoinCacheCapacity int64

    // The variables below do not take any effect anymore, it's remaining for compatibility.
    // TODO: remove them in v4.1
    // MemQuotaHashJoin defines the memory quota for a hash join executor.
    MemQuotaHashJoin int64
    // MemQuotaMergeJoin defines the memory quota for a merge join executor.
    MemQuotaMergeJoin int64
    // MemQuotaSort defines the memory quota for a sort executor.
    MemQuotaSort int64
    // MemQuotaTopn defines the memory quota for a top n executor.
    MemQuotaTopn int64
    // MemQuotaIndexLookupReader defines the memory quota for a index lookup reader executor.
    MemQuotaIndexLookupReader int64
    // MemQuotaIndexLookupJoin defines the memory quota for a index lookup join executor.
    MemQuotaIndexLookupJoin int64
    // MemQuotaNestedLoopApply defines the memory quota for a nested loop apply executor.
    MemQuotaNestedLoopApply int64
    // MemQuotaDistSQL defines the memory quota for all operators in DistSQL layer like co-processor and selectResult.
    MemQuotaDistSQL int64
}

MemQuota defines memory quota values.

type MockGlobalAccessor Uses

type MockGlobalAccessor struct {
}

MockGlobalAccessor implements GlobalVarAccessor interface. it's used in tests

func NewMockGlobalAccessor Uses

func NewMockGlobalAccessor() *MockGlobalAccessor

NewMockGlobalAccessor implements GlobalVarAccessor interface.

func (*MockGlobalAccessor) GetAllSysVars Uses

func (m *MockGlobalAccessor) GetAllSysVars() (map[string]string, error)

GetAllSysVars implements GlobalVarAccessor.GetAllSysVars interface.

func (*MockGlobalAccessor) GetGlobalSysVar Uses

func (m *MockGlobalAccessor) GetGlobalSysVar(name string) (string, error)

GetGlobalSysVar implements GlobalVarAccessor.GetGlobalSysVar interface.

func (*MockGlobalAccessor) SetGlobalSysVar Uses

func (m *MockGlobalAccessor) SetGlobalSysVar(name string, value string) error

SetGlobalSysVar implements GlobalVarAccessor.SetGlobalSysVar interface.

type PreparedParams Uses

type PreparedParams []types.Datum

PreparedParams contains the parameters of the current prepared statement when executing it.

func (PreparedParams) String Uses

func (pps PreparedParams) String() string

type RetryInfo Uses

type RetryInfo struct {
    Retrying               bool
    DroppedPreparedStmtIDs []uint32
    // contains filtered or unexported fields
}

RetryInfo saves retry information.

func (*RetryInfo) AddAutoIncrementID Uses

func (r *RetryInfo) AddAutoIncrementID(id int64)

AddAutoIncrementID adds id to autoIncrementIDs.

func (*RetryInfo) AddAutoRandomID Uses

func (r *RetryInfo) AddAutoRandomID(id int64)

AddAutoRandomID adds id to autoRandomIDs.

func (*RetryInfo) Clean Uses

func (r *RetryInfo) Clean()

Clean does some clean work.

func (*RetryInfo) GetCurrAutoIncrementID Uses

func (r *RetryInfo) GetCurrAutoIncrementID() (int64, error)

GetCurrAutoIncrementID gets current autoIncrementID.

func (*RetryInfo) GetCurrAutoRandomID Uses

func (r *RetryInfo) GetCurrAutoRandomID() (int64, error)

GetCurrAutoRandomID gets current AutoRandomID.

func (*RetryInfo) ResetOffset Uses

func (r *RetryInfo) ResetOffset()

ResetOffset resets the current retry offset.

type RewritePhaseInfo Uses

type RewritePhaseInfo struct {
    // DurationRewrite is the duration of rewriting the SQL.
    DurationRewrite time.Duration

    // DurationPreprocessSubQuery is the duration of pre-processing sub-queries.
    DurationPreprocessSubQuery time.Duration

    // PreprocessSubQueries is the number of pre-processed sub-queries.
    PreprocessSubQueries int
}

RewritePhaseInfo records some information about the rewrite phase

func (*RewritePhaseInfo) Reset Uses

func (r *RewritePhaseInfo) Reset()

Reset resets all fields in RewritePhaseInfo.

type ScopeFlag Uses

type ScopeFlag uint8

ScopeFlag is for system variable whether can be changed in global/session dynamically or not.

const (
    // ScopeNone means the system variable can not be changed dynamically.
    ScopeNone ScopeFlag = 0
    // ScopeGlobal means the system variable can be changed globally.
    ScopeGlobal ScopeFlag = 1 << 0
    // ScopeSession means the system variable can only be changed in current session.
    ScopeSession ScopeFlag = 1 << 1
)

type SequenceState Uses

type SequenceState struct {
    // contains filtered or unexported fields
}

SequenceState cache all sequence's latest value accessed by lastval() builtins. It's a session scoped variable, and all public methods of SequenceState are currently-safe.

func NewSequenceState Uses

func NewSequenceState() *SequenceState

NewSequenceState creates a SequenceState.

func (*SequenceState) GetLastValue Uses

func (ss *SequenceState) GetLastValue(sequenceID int64) (int64, bool, error)

GetLastValue will return last value of the specified sequenceID, bool(true) indicates the sequenceID is not in the cache map and NULL will be returned.

func (*SequenceState) UpdateState Uses

func (ss *SequenceState) UpdateState(sequenceID, value int64)

UpdateState will update the last value of specified sequenceID in a session.

type SessionVars Uses

type SessionVars struct {
    Concurrency
    MemQuota
    BatchSize
    // DMLBatchSize indicates the number of rows batch-committed for a statement.
    // It will be used when using LOAD DATA or BatchInsert or BatchDelete is on.
    DMLBatchSize        int
    RetryLimit          int64
    DisableTxnAutoRetry bool
    // UsersLock is a lock for user defined variables.
    UsersLock sync.RWMutex
    // Users are user defined variables.
    Users map[string]types.Datum

    // SysWarningCount is the system variable "warning_count", because it is on the hot path, so we extract it from the systems
    SysWarningCount int
    // SysErrorCount is the system variable "error_count", because it is on the hot path, so we extract it from the systems
    SysErrorCount uint16
    // PreparedStmts stores prepared statement.
    PreparedStmts        map[uint32]interface{}
    PreparedStmtNameToID map[string]uint32

    // PreparedParams params for prepared statements
    PreparedParams PreparedParams

    // ActiveRoles stores active roles for current user
    ActiveRoles []*auth.RoleIdentity

    RetryInfo *RetryInfo
    //  TxnCtx Should be reset on transaction finished.
    TxnCtx *TransactionContext

    // KVVars is the variables for KV storage.
    KVVars *kv.Variables

    // Status stands for the session status. e.g. in transaction or not, auto commit is on or off, and so on.
    Status uint16

    // ClientCapability is client's capability.
    ClientCapability uint32

    // TLSConnectionState is the TLS connection state (nil if not using TLS).
    TLSConnectionState *tls.ConnectionState

    // ConnectionID is the connection id of the current session.
    ConnectionID uint64

    // PlanID is the unique id of logical and physical plan.
    PlanID int

    // PlanColumnID is the unique id for column when building plan.
    PlanColumnID int64

    // User is the user identity with which the session login.
    User *auth.UserIdentity

    // CurrentDB is the default database of this session.
    CurrentDB string

    // CurrentDBChanged indicates if the CurrentDB has been updated, and if it is we should print it into
    // the slow log to make it be compatible with MySQL, https://github.com/pingcap/tidb/issues/17846.
    CurrentDBChanged bool

    // StrictSQLMode indicates if the session is in strict mode.
    StrictSQLMode bool

    // CommonGlobalLoaded indicates if common global variable has been loaded for this session.
    CommonGlobalLoaded bool

    // InRestrictedSQL indicates if the session is handling restricted SQL execution.
    InRestrictedSQL bool

    // SnapshotTS is used for reading history data. For simplicity, SnapshotTS only supports distsql request.
    SnapshotTS uint64

    // SnapshotInfoschema is used with SnapshotTS, when the schema version at snapshotTS less than current schema
    // version, we load an old version schema for query.
    SnapshotInfoschema interface{}

    // BinlogClient is used to write binlog.
    BinlogClient *pumpcli.PumpsClient

    // GlobalVarsAccessor is used to set and get global variables.
    GlobalVarsAccessor GlobalVarAccessor

    // LastFoundRows is the number of found rows of last query statement
    LastFoundRows uint64

    // StmtCtx holds variables for current executing statement.
    StmtCtx *stmtctx.StatementContext

    // AllowAggPushDown can be set to false to forbid aggregation push down.
    AllowAggPushDown bool

    // AllowBCJ means allow broadcast join.
    AllowBCJ bool
    // AllowDistinctAggPushDown can be set true to allow agg with distinct push down to tikv/tiflash.
    AllowDistinctAggPushDown bool

    // AllowWriteRowID can be set to false to forbid write data to _tidb_rowid.
    // This variable is currently not recommended to be turned on.
    AllowWriteRowID bool

    // AllowBatchCop means if we should send batch coprocessor to TiFlash. Default value is 1, means to use batch cop in case of aggregation and join.
    // If value is set to 2 , which means to force to send batch cop for any query. Value is set to 0 means never use batch cop.
    AllowBatchCop int

    // TiDBAllowAutoRandExplicitInsert indicates whether explicit insertion on auto_random column is allowed.
    AllowAutoRandExplicitInsert bool

    // CorrelationThreshold is the guard to enable row count estimation using column order correlation.
    CorrelationThreshold float64

    // CorrelationExpFactor is used to control the heuristic approach of row count estimation when CorrelationThreshold is not met.
    CorrelationExpFactor int

    // CPUFactor is the CPU cost of processing one expression for one row.
    CPUFactor float64
    // CopCPUFactor is the CPU cost of processing one expression for one row in coprocessor.
    CopCPUFactor float64
    // CopTiFlashConcurrencyFactor is the concurrency number of computation in tiflash coprocessor.
    CopTiFlashConcurrencyFactor float64
    // NetworkFactor is the network cost of transferring 1 byte data.
    NetworkFactor float64
    // ScanFactor is the IO cost of scanning 1 byte data on TiKV and TiFlash.
    ScanFactor float64
    // DescScanFactor is the IO cost of scanning 1 byte data on TiKV and TiFlash in desc order.
    DescScanFactor float64
    // SeekFactor is the IO cost of seeking the start value of a range in TiKV or TiFlash.
    SeekFactor float64
    // MemoryFactor is the memory cost of storing one tuple.
    MemoryFactor float64
    // DiskFactor is the IO cost of reading/writing one byte to temporary disk.
    DiskFactor float64
    // ConcurrencyFactor is the CPU cost of additional one goroutine.
    ConcurrencyFactor float64

    // CurrInsertValues is used to record current ValuesExpr's values.
    // See http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_values
    CurrInsertValues chunk.Row

    // Per-connection time zones. Each client that connects has its own time zone setting, given by the session time_zone variable.
    // See https://dev.mysql.com/doc/refman/5.7/en/time-zone-support.html
    TimeZone *time.Location

    SQLMode mysql.SQLMode

    // AutoIncrementIncrement and AutoIncrementOffset indicates the autoID's start value and increment.
    AutoIncrementIncrement int

    AutoIncrementOffset int

    // SkipASCIICheck check on input value.
    SkipASCIICheck bool

    // SkipUTF8Check check on input value.
    SkipUTF8Check bool

    // BatchInsert indicates if we should split insert data into multiple batches.
    BatchInsert bool

    // BatchDelete indicates if we should split delete data into multiple batches.
    BatchDelete bool

    // BatchCommit indicates if we should split the transaction into multiple batches.
    BatchCommit bool

    // IDAllocator is provided by kvEncoder, if it is provided, we will use it to alloc auto id instead of using
    // Table.alloc.
    IDAllocator autoid.Allocator

    // OptimizerSelectivityLevel defines the level of the selectivity estimation in plan.
    OptimizerSelectivityLevel int

    // EnableTablePartition enables table partition feature.
    EnableTablePartition string

    // EnableCascadesPlanner enables the cascades planner.
    EnableCascadesPlanner bool

    // EnableWindowFunction enables the window function.
    EnableWindowFunction bool

    // EnableVectorizedExpression  enables the vectorized expression evaluation.
    EnableVectorizedExpression bool

    // DDLReorgPriority is the operation priority of adding indices.
    DDLReorgPriority int

    // WaitSplitRegionFinish defines the split region behaviour is sync or async.
    WaitSplitRegionFinish bool

    // WaitSplitRegionTimeout defines the split region timeout.
    WaitSplitRegionTimeout uint64

    // EnableStreaming indicates whether the coprocessor request can use streaming API.
    // TODO: remove this after tidb-server configuration "enable-streaming' removed.
    EnableStreaming bool

    // EnableChunkRPC indicates whether the coprocessor request can use chunk API.
    EnableChunkRPC bool

    // L2CacheSize indicates the size of CPU L2 cache, using byte as unit.
    L2CacheSize int

    // EnableRadixJoin indicates whether to use radix hash join to execute
    // HashJoin.
    EnableRadixJoin bool

    // ConstraintCheckInPlace indicates whether to check the constraint when the SQL executing.
    ConstraintCheckInPlace bool

    // CommandValue indicates which command current session is doing.
    CommandValue uint32

    // TiDBOptJoinReorderThreshold defines the minimal number of join nodes
    // to use the greedy join reorder algorithm.
    TiDBOptJoinReorderThreshold int

    // SlowQueryFile indicates which slow query log file for SLOW_QUERY table to parse.
    SlowQueryFile string

    // EnableFastAnalyze indicates whether to take fast analyze.
    EnableFastAnalyze bool

    // TxnMode indicates should be pessimistic or optimistic.
    TxnMode string

    // LowResolutionTSO is used for reading data with low resolution TSO which is updated once every two seconds.
    LowResolutionTSO bool

    // MaxExecutionTime is the timeout for select statement, in milliseconds.
    // If the value is 0, timeouts are not enabled.
    // See https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html#sysvar_max_execution_time
    MaxExecutionTime uint64

    // Killed is a flag to indicate that this query is killed.
    Killed uint32

    // ConnectionInfo indicates current connection info used by current session, only be lazy assigned by plugin.
    ConnectionInfo *ConnectionInfo

    // use noop funcs or not
    EnableNoopFuncs bool

    // StartTime is the start time of the last query.
    StartTime time.Time

    // DurationParse is the duration of parsing SQL string to AST of the last query.
    DurationParse time.Duration

    // DurationCompile is the duration of compiling AST to execution plan of the last query.
    DurationCompile time.Duration

    // RewritePhaseInfo records all information about the rewriting phase.
    RewritePhaseInfo

    // DurationOptimization is the duration of optimizing a query.
    DurationOptimization time.Duration

    // DurationWaitTS is the duration of waiting for a snapshot TS
    DurationWaitTS time.Duration

    // PrevStmt is used to store the previous executed statement in the current session.
    PrevStmt fmt.Stringer

    // AllowRemoveAutoInc indicates whether a user can drop the auto_increment column attribute or not.
    AllowRemoveAutoInc bool

    // UsePlanBaselines indicates whether we will use plan baselines to adjust plan.
    UsePlanBaselines bool

    // EvolvePlanBaselines indicates whether we will evolve the plan baselines.
    EvolvePlanBaselines bool

    // IsolationReadEngines is used to isolation read, tidb only read from the stores whose engine type is in the engines.
    IsolationReadEngines map[kv.StoreType]struct{}

    PlannerSelectBlockAsName []ast.HintTable

    // LockWaitTimeout is the duration waiting for pessimistic lock in milliseconds
    // negative value means nowait, 0 means default behavior, others means actual wait time
    LockWaitTimeout int64

    // MetricSchemaStep indicates the step when query metric schema.
    MetricSchemaStep int64
    // MetricSchemaRangeDuration indicates the step when query metric schema.
    MetricSchemaRangeDuration int64

    // Some data of cluster-level memory tables will be retrieved many times in different inspection rules,
    // and the cost of retrieving some data is expensive. We use the `TableSnapshot` to cache those data
    // and obtain them lazily, and provide a consistent view of inspection tables for each inspection rules.
    // All cached snapshots will be released at the end of retrieving
    InspectionTableCache map[string]TableSnapshot

    // RowEncoder is reused in session for encode row data.
    RowEncoder rowcodec.Encoder

    // SequenceState cache all sequence's latest value accessed by lastval() builtins. It's a session scoped
    // variable, and all public methods of SequenceState are currently-safe.
    SequenceState *SequenceState

    // WindowingUseHighPrecision determines whether to compute window operations without loss of precision.
    // see https://dev.mysql.com/doc/refman/8.0/en/window-function-optimization.html for more details.
    WindowingUseHighPrecision bool

    // FoundInPlanCache indicates whether this statement was found in plan cache.
    FoundInPlanCache bool
    // PrevFoundInPlanCache indicates whether the last statement was found in plan cache.
    PrevFoundInPlanCache bool

    // OptimizerUseInvisibleIndexes indicates whether optimizer can use invisible index
    OptimizerUseInvisibleIndexes bool

    // SelectLimit limits the max counts of select statement's output
    SelectLimit uint64

    // EnableClusteredIndex indicates whether to enable clustered index when creating a new table.
    EnableClusteredIndex bool

    // EnableLogDesensitization indicates that whether desensitization when log query.
    EnableLogDesensitization bool

    // PresumeKeyNotExists indicates lazy existence checking is enabled.
    PresumeKeyNotExists bool

    // EnableParallelApply indicates that thether to use parallel apply.
    EnableParallelApply bool

    // ShardAllocateStep indicates the max size of continuous rowid shard in one transaction.
    ShardAllocateStep int64
    // contains filtered or unexported fields
}

SessionVars is to handle user-defined or global variables in the current session.

func NewSessionVars Uses

func NewSessionVars() *SessionVars

NewSessionVars creates a session vars object.

func (*SessionVars) AddPreparedStmt Uses

func (s *SessionVars) AddPreparedStmt(stmtID uint32, stmt interface{}) error

AddPreparedStmt adds prepareStmt to current session and count in global.

func (*SessionVars) AllocPlanColumnID Uses

func (s *SessionVars) AllocPlanColumnID() int64

AllocPlanColumnID allocates column id for plan.

func (*SessionVars) CleanBuffers Uses

func (s *SessionVars) CleanBuffers()

CleanBuffers cleans the temporary bufs

func (*SessionVars) GetAllowInSubqToJoinAndAgg Uses

func (s *SessionVars) GetAllowInSubqToJoinAndAgg() bool

GetAllowInSubqToJoinAndAgg get AllowInSubqToJoinAndAgg from sql hints and SessionVars.allowInSubqToJoinAndAgg.

func (*SessionVars) GetCharsetInfo Uses

func (s *SessionVars) GetCharsetInfo() (charset, collation string)

GetCharsetInfo gets charset and collation for current context. What character set should the server translate a statement to after receiving it? For this, the server uses the character_set_connection and collation_connection system variables. It converts statements sent by the client from character_set_client to character_set_connection (except for string literals that have an introducer such as _latin1 or _utf8). collation_connection is important for comparisons of literal strings. For comparisons of strings with column values, collation_connection does not matter because columns have their own collation, which has a higher collation precedence. See https://dev.mysql.com/doc/refman/5.7/en/charset-connection.html

func (*SessionVars) GetEnableCascadesPlanner Uses

func (s *SessionVars) GetEnableCascadesPlanner() bool

GetEnableCascadesPlanner get EnableCascadesPlanner from sql hints and SessionVars.EnableCascadesPlanner.

func (*SessionVars) GetEnableIndexMerge Uses

func (s *SessionVars) GetEnableIndexMerge() bool

GetEnableIndexMerge get EnableIndexMerge from SessionVars.enableIndexMerge.

func (*SessionVars) GetIsolationReadEngines Uses

func (s *SessionVars) GetIsolationReadEngines() map[kv.StoreType]struct{}

GetIsolationReadEngines gets isolation read engines.

func (*SessionVars) GetNextPreparedStmtID Uses

func (s *SessionVars) GetNextPreparedStmtID() uint32

GetNextPreparedStmtID generates and returns the next session scope prepared statement id.

func (*SessionVars) GetPrevStmtDigest Uses

func (s *SessionVars) GetPrevStmtDigest() string

GetPrevStmtDigest returns the digest of the previous statement.

func (*SessionVars) GetReadableTxnMode Uses

func (s *SessionVars) GetReadableTxnMode() string

GetReadableTxnMode returns the session variable TxnMode but rewrites it to "OPTIMISTIC" when it's empty.

func (*SessionVars) GetReplicaRead Uses

func (s *SessionVars) GetReplicaRead() kv.ReplicaReadType

GetReplicaRead get ReplicaRead from sql hints and SessionVars.replicaRead.

func (*SessionVars) GetSplitRegionTimeout Uses

func (s *SessionVars) GetSplitRegionTimeout() time.Duration

GetSplitRegionTimeout gets split region timeout.

func (*SessionVars) GetStatusFlag Uses

func (s *SessionVars) GetStatusFlag(flag uint16) bool

GetStatusFlag gets the session server status variable, returns true if it is on.

func (*SessionVars) GetSystemVar Uses

func (s *SessionVars) GetSystemVar(name string) (string, bool)

GetSystemVar gets the string value of a system variable.

func (*SessionVars) GetWriteStmtBufs Uses

func (s *SessionVars) GetWriteStmtBufs() *WriteStmtBufs

GetWriteStmtBufs get pointer of SessionVars.writeStmtBufs.

func (*SessionVars) InTxn Uses

func (s *SessionVars) InTxn() bool

InTxn returns if the session is in transaction.

func (*SessionVars) IsAutocommit Uses

func (s *SessionVars) IsAutocommit() bool

IsAutocommit returns if the session is set to autocommit.

func (*SessionVars) IsPessimisticReadConsistency Uses

func (s *SessionVars) IsPessimisticReadConsistency() bool

IsPessimisticReadConsistency if true it means the statement is in an read consistency pessimistic transaction.

func (*SessionVars) IsReadConsistencyTxn Uses

func (s *SessionVars) IsReadConsistencyTxn() bool

IsReadConsistencyTxn if true it means the transaction is an read consistency (read committed) transaction.

func (*SessionVars) LazyCheckKeyNotExists Uses

func (s *SessionVars) LazyCheckKeyNotExists() bool

LazyCheckKeyNotExists returns if we can lazy check key not exists.

func (*SessionVars) Location Uses

func (s *SessionVars) Location() *time.Location

Location returns the value of time_zone session variable. If it is nil, then return time.Local.

func (*SessionVars) RemovePreparedStmt Uses

func (s *SessionVars) RemovePreparedStmt(stmtID uint32)

RemovePreparedStmt removes preparedStmt from current session and decrease count in global.

func (*SessionVars) SetAllowInSubqToJoinAndAgg Uses

func (s *SessionVars) SetAllowInSubqToJoinAndAgg(val bool)

SetAllowInSubqToJoinAndAgg set SessionVars.allowInSubqToJoinAndAgg.

func (*SessionVars) SetEnableCascadesPlanner Uses

func (s *SessionVars) SetEnableCascadesPlanner(val bool)

SetEnableCascadesPlanner set SessionVars.EnableCascadesPlanner.

func (*SessionVars) SetEnableIndexMerge Uses

func (s *SessionVars) SetEnableIndexMerge(val bool)

SetEnableIndexMerge set SessionVars.enableIndexMerge.

func (*SessionVars) SetLastInsertID Uses

func (s *SessionVars) SetLastInsertID(insertID uint64)

SetLastInsertID saves the last insert id to the session context. TODO: we may store the result for last_insert_id sys var later.

func (*SessionVars) SetPrevStmtDigest Uses

func (s *SessionVars) SetPrevStmtDigest(prevStmtDigest string)

SetPrevStmtDigest sets the digest of the previous statement.

func (*SessionVars) SetReplicaRead Uses

func (s *SessionVars) SetReplicaRead(val kv.ReplicaReadType)

SetReplicaRead set SessionVars.replicaRead.

func (*SessionVars) SetStatusFlag Uses

func (s *SessionVars) SetStatusFlag(flag uint16, on bool)

SetStatusFlag sets the session server status variable. If on is ture sets the flag in session status, otherwise removes the flag.

func (*SessionVars) SetSystemVar Uses

func (s *SessionVars) SetSystemVar(name string, val string) error

SetSystemVar sets the value of a system variable.

func (*SessionVars) SetTxnIsolationLevelOneShotStateForNextTxn Uses

func (s *SessionVars) SetTxnIsolationLevelOneShotStateForNextTxn()

SetTxnIsolationLevelOneShotStateForNextTxn sets the txnIsolationLevelOneShot.state for next transaction.

func (*SessionVars) SetUserVar Uses

func (s *SessionVars) SetUserVar(varName string, svalue string, collation string)

SetUserVar set the value and collation for user defined variable.

func (*SessionVars) SlowLogFormat Uses

func (s *SessionVars) SlowLogFormat(logItems *SlowQueryLogItems) string

SlowLogFormat uses for formatting slow log. The slow log output is like below: # Time: 2019-04-28T15:24:04.309074+08:00 # Txn_start_ts: 406315658548871171 # User@Host: root[root] @ localhost [127.0.0.1] # Conn_ID: 6 # Query_time: 4.895492 # Process_time: 0.161 Request_count: 1 Total_keys: 100001 Processed_keys: 100000 # DB: test # Index_names: [t1.idx1,t2.idx2] # Is_internal: false # Digest: 42a1c8aae6f133e934d4bf0147491709a8812ea05ff8819ec522780fe657b772 # Stats: t1:1,t2:2 # Num_cop_tasks: 10 # Cop_process: Avg_time: 1s P90_time: 2s Max_time: 3s Max_addr: 10.6.131.78 # Cop_wait: Avg_time: 10ms P90_time: 20ms Max_time: 30ms Max_Addr: 10.6.131.79 # Memory_max: 4096 # Disk_max: 65535 # Succ: true # Prev_stmt: begin; select * from t_slim;

func (*SessionVars) WithdrawAllPreparedStmt Uses

func (s *SessionVars) WithdrawAllPreparedStmt()

WithdrawAllPreparedStmt remove all preparedStmt in current session and decrease count in global.

type SlowQueryLogItems Uses

type SlowQueryLogItems struct {
    TxnTS             uint64
    SQL               string
    Digest            string
    TimeTotal         time.Duration
    TimeParse         time.Duration
    TimeCompile       time.Duration
    TimeOptimize      time.Duration
    TimeWaitTS        time.Duration
    IndexNames        string
    StatsInfos        map[string]uint64
    CopTasks          *stmtctx.CopTasksDetails
    ExecDetail        execdetails.ExecDetails
    MemMax            int64
    DiskMax           int64
    Succ              bool
    Prepared          bool
    PlanFromCache     bool
    HasMoreResults    bool
    PrevStmt          string
    Plan              string
    PlanDigest        string
    RewriteInfo       RewritePhaseInfo
    KVTotal           time.Duration
    PDTotal           time.Duration
    BackoffTotal      time.Duration
    WriteSQLRespTotal time.Duration
}

SlowQueryLogItems is a collection of items that should be included in the slow query log.

type Statistics Uses

type Statistics interface {
    // GetScope gets the status variables scope.
    GetScope(status string) ScopeFlag
    // Stats returns the statistics status variables.
    Stats(*SessionVars) (map[string]interface{}, error)
}

Statistics is the interface of statistics.

type StatusVal Uses

type StatusVal struct {
    Scope ScopeFlag
    Value interface{}
}

StatusVal is the value of the corresponding status variable.

type SysVar Uses

type SysVar struct {
    // Scope is for whether can be changed or not
    Scope ScopeFlag

    // Name is the variable name.
    Name string

    // Value is the variable value.
    Value string
}

SysVar is for system variable.

func GetSysVar Uses

func GetSysVar(name string) *SysVar

GetSysVar returns sys var info for name as key.

type TableDelta Uses

type TableDelta struct {
    Delta    int64
    Count    int64
    ColSize  map[int64]int64
    InitTime time.Time // InitTime is the time that this delta is generated.
}

TableDelta stands for the changed count for one table or partition.

type TableSnapshot Uses

type TableSnapshot struct {
    Rows [][]types.Datum
    Err  error
}

TableSnapshot represents a data snapshot of the table contained in `information_schema`.

type TransactionContext Uses

type TransactionContext struct {
    DirtyDB       interface{}
    Binlog        interface{}
    InfoSchema    interface{}
    History       interface{}
    SchemaVersion int64
    StartTS       uint64

    // ShardStep indicates the max size of continuous rowid shard in one transaction.
    ShardStep int

    // TableDeltaMap is used in the schema validator for DDL changes in one table not to block others.
    // It's also used in the statistias updating.
    // Note: for the partitionted table, it stores all the partition IDs.
    TableDeltaMap map[int64]TableDelta

    PessimisticCacheHit int

    // CreateTime For metrics.
    CreateTime     time.Time
    StatementCount int
    CouldRetry     bool
    IsPessimistic  bool
    Isolation      string
    LockExpire     uint32
    ForUpdate      uint32
    // contains filtered or unexported fields
}

TransactionContext is used to store variables that has transaction scope.

func (*TransactionContext) AddUnchangedRowKey Uses

func (tc *TransactionContext) AddUnchangedRowKey(key []byte)

AddUnchangedRowKey adds an unchanged row key in update statement for pessimistic lock.

func (*TransactionContext) Cleanup Uses

func (tc *TransactionContext) Cleanup()

Cleanup clears up transaction info that no longer use.

func (*TransactionContext) ClearDelta Uses

func (tc *TransactionContext) ClearDelta()

ClearDelta clears the delta map.

func (*TransactionContext) CollectUnchangedRowKeys Uses

func (tc *TransactionContext) CollectUnchangedRowKeys(buf []kv.Key) []kv.Key

CollectUnchangedRowKeys collects unchanged row keys for pessimistic lock.

func (*TransactionContext) GetForUpdateTS Uses

func (tc *TransactionContext) GetForUpdateTS() uint64

GetForUpdateTS returns the ts for update.

func (*TransactionContext) GetKeyInPessimisticLockCache Uses

func (tc *TransactionContext) GetKeyInPessimisticLockCache(key kv.Key) (val []byte, ok bool)

GetKeyInPessimisticLockCache gets a key in pessimistic lock cache.

func (*TransactionContext) GetShard Uses

func (tc *TransactionContext) GetShard(shardRowIDBits uint64, typeBitsLength uint64, reserveSignBit bool, count int) int64

GetShard returns the shard prefix for the next `count` rowids.

func (*TransactionContext) GetStmtFutureForRC Uses

func (tc *TransactionContext) GetStmtFutureForRC() oracle.Future

GetStmtFutureForRC gets the stmtFuture.

func (*TransactionContext) SetForUpdateTS Uses

func (tc *TransactionContext) SetForUpdateTS(forUpdateTS uint64)

SetForUpdateTS sets the ts for update.

func (*TransactionContext) SetPessimisticLockCache Uses

func (tc *TransactionContext) SetPessimisticLockCache(key kv.Key, val []byte)

SetPessimisticLockCache sets a key value pair into pessimistic lock cache.

func (*TransactionContext) SetStmtFutureForRC Uses

func (tc *TransactionContext) SetStmtFutureForRC(future oracle.Future)

SetStmtFutureForRC sets the stmtFuture .

func (*TransactionContext) UpdateDeltaForTable Uses

func (tc *TransactionContext) UpdateDeltaForTable(physicalTableID int64, delta int64, count int64, colSize map[int64]int64)

UpdateDeltaForTable updates the delta info for some table.

type WriteStmtBufs Uses

type WriteStmtBufs struct {
    // RowValBuf is used by tablecodec.EncodeRow, to reduce runtime.growslice.
    RowValBuf []byte
    // AddRowValues use to store temp insert rows value, to reduce memory allocations when importing data.
    AddRowValues []types.Datum

    // IndexValsBuf is used by index.FetchValues
    IndexValsBuf []types.Datum
    // IndexKeyBuf is used by index.GenIndexKey
    IndexKeyBuf []byte
}

WriteStmtBufs can be used by insert/replace/delete/update statement. TODO: use a common memory pool to replace this.

Package variable imports 43 packages (graph) and is imported by 814 packages. Updated 2020-08-08. Refresh now. Tools for package owners.