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

package variable

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

Index

Package Files

mock_globalaccessor.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"
    // 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"
    // 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"
    // SlowLogMemMax is the max number bytes of memory used in this statement.
    SlowLogMemMax = "Mem_max"
    // SlowLogSucc is used to indicate whether this sql execute successfully.
    SlowLogSucc = "Succ"
    // SlowLogPrevStmt is used to show the previous executed statement.
    SlowLogPrevStmt = "Prev_stmt"
    // SlowLogPrevStmtPrefix is the prefix of Prev_stmt in slow log file.
    SlowLogPrevStmtPrefix = SlowLogPrevStmt + SlowLogSpaceMarkStr
)
const (
    CodeUnknownStatusVar            terror.ErrCode = 1
    CodeUnknownSystemVar            terror.ErrCode = mysql.ErrUnknownSystemVariable
    CodeIncorrectScope              terror.ErrCode = mysql.ErrIncorrectGlobalLocalVar
    CodeUnknownTimeZone             terror.ErrCode = mysql.ErrUnknownTimeZone
    CodeReadOnly                    terror.ErrCode = mysql.ErrVariableIsReadonly
    CodeWrongValueForVar            terror.ErrCode = mysql.ErrWrongValueForVar
    CodeWrongTypeForVar             terror.ErrCode = mysql.ErrWrongTypeForVar
    CodeTruncatedWrongValue         terror.ErrCode = mysql.ErrTruncatedWrongValue
    CodeMaxPreparedStmtCountReached terror.ErrCode = mysql.ErrMaxPreparedStmtCountReached
)

Variable error codes.

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 it the name of 'auto_increment_increment' system variable.
    AutoIncrementIncrement = "auto_increment_increment"
    // 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"
)
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"

    // 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.
    // "tidb_mem_quota_hashjoin": 			control the memory quota of "HashJoinExec".
    // "tidb_mem_quota_mergejoin": 			control the memory quota of "MergeJoinExec".
    // "tidb_mem_quota_sort":     			control the memory quota of "SortExec".
    // "tidb_mem_quota_topn":     			control the memory quota of "TopNExec".
    // "tidb_mem_quota_indexlookupreader":	control the memory quota of "IndexLookUpExecutor".
    // "tidb_mem_quota_indexlookupjoin":	control the memory quota of "IndexLookUpJoin".
    // "tidb_mem_quota_nestedloopapply": 	control the memory quota of "NestedLoopApplyExec".
    TIDBMemQuotaQuery             = "tidb_mem_quota_query"             // Bytes.
    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_slow_log_threshold is used to set the slow log threshold in the server.
    TiDBSlowLogThreshold = "tidb_slow_log_threshold"

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

    // 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_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_enable_table_partition is used to control table partition feature.
    // The valid value include auto/on/off:
    // auto: enable table partition when that feature is implemented.
    // on: always enable table partition.
    // off: always disable table partition.
    TiDBEnableTablePartition = "tidb_enable_table_partition"

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

    // 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"
)

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.
    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_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.
    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.
    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"

    // 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_hash_join_concurrency is used for hash join executor.
    // The hash join outer executor starts multiple concurrent join workers to probe the hash table.
    TiDBHashJoinConcurrency = "tidb_hash_join_concurrency"

    // tidb_projection_concurrency is used for projection operator.
    // This variable controls the worker number of projection operator.
    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.
    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.
    TiDBHashAggFinalConcurrency = "tidb_hashagg_final_concurrency"

    // 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_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"
)

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

const (
    DefHostname                        = "localhost"
    DefIndexLookupConcurrency          = 4
    DefIndexLookupJoinConcurrency      = 4
    DefIndexSerialScanConcurrency      = 1
    DefIndexJoinBatchSize              = 25000
    DefIndexLookupSize                 = 20000
    DefDistSQLScanConcurrency          = 15
    DefBuildStatsConcurrency           = 4
    DefAutoAnalyzeRatio                = 0.5
    DefAutoAnalyzeStartTime            = "00:00 +0000"
    DefAutoAnalyzeEndTime              = "23:59 +0000"
    DefChecksumTableConcurrency        = 4
    DefSkipUTF8Check                   = false
    DefOptAggPushDown                  = false
    DefOptWriteRowID                   = false
    DefOptCorrelationThreshold         = 0.9
    DefOptCorrelationExpFactor         = 1
    DefOptInSubqToJoinAndAgg           = true
    DefBatchInsert                     = false
    DefBatchDelete                     = false
    DefBatchCommit                     = false
    DefCurretTS                        = 0
    DefInitChunkSize                   = 32
    DefMaxChunkSize                    = 1024
    DefDMLBatchSize                    = 20000
    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
    DefTiDBRetryLimit                  = 10
    DefTiDBDisableTxnAutoRetry         = true
    DefTiDBConstraintCheckInPlace      = false
    DefTiDBHashJoinConcurrency         = 5
    DefTiDBProjectionConcurrency       = 4
    DefTiDBOptimizerSelectivityLevel   = 0
    DefTiDBTxnMode                     = ""
    DefTiDBDDLReorgWorkerCount         = 4
    DefTiDBDDLReorgBatchSize           = 256
    DefTiDBDDLErrorCountLimit          = 512
    DefTiDBHashAggPartialConcurrency   = 4
    DefTiDBHashAggFinalConcurrency     = 4
    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
)

Default TiDB system variable values.

const (

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

Variables

var (
    ErrCantSetToNull  = terror.ClassVariable.New(codeCantSetToNull, "cannot set variable to null")
    ErrSnapshotTooOld = terror.ClassVariable.New(codeSnapshotTooOld, "snapshot is older than GC safe point %s")
)

Error instances.

var (
    UnknownStatusVar               = terror.ClassVariable.New(CodeUnknownStatusVar, "unknown status variable")
    UnknownSystemVar               = terror.ClassVariable.New(CodeUnknownSystemVar, mysql.MySQLErrName[mysql.ErrUnknownSystemVariable])
    ErrIncorrectScope              = terror.ClassVariable.New(CodeIncorrectScope, mysql.MySQLErrName[mysql.ErrIncorrectGlobalLocalVar])
    ErrUnknownTimeZone             = terror.ClassVariable.New(CodeUnknownTimeZone, mysql.MySQLErrName[mysql.ErrUnknownTimeZone])
    ErrReadOnly                    = terror.ClassVariable.New(CodeReadOnly, "variable is read only")
    ErrWrongValueForVar            = terror.ClassVariable.New(CodeWrongValueForVar, mysql.MySQLErrName[mysql.ErrWrongValueForVar])
    ErrWrongTypeForVar             = terror.ClassVariable.New(CodeWrongTypeForVar, mysql.MySQLErrName[mysql.ErrWrongTypeForVar])
    ErrTruncatedWrongValue         = terror.ClassVariable.New(CodeTruncatedWrongValue, mysql.MySQLErrName[mysql.ErrTruncatedWrongValue])
    ErrMaxPreparedStmtCountReached = terror.ClassVariable.New(CodeMaxPreparedStmtCountReached, mysql.MySQLErrName[mysql.ErrMaxPreparedStmtCountReached])
    ErrUnsupportedValueForVar      = terror.ClassVariable.New(CodeUnknownStatusVar, "variable '%s' does not yet support value: %s")
    ErrUnsupportedIsolationLevel   = terror.ClassVariable.New(CodeUnknownStatusVar, "The isolation level '%s' is not supported. Set tidb_skip_isolation_level_check=1 to skip this error")
)

Variable errors

var (
    ProcessGeneralLog uint32

    // 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
)

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 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 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 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 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) (string, error)

ValidateSetSystemVar checks if system variable satisfies specific restriction.

type BatchSize Uses

type BatchSize struct {
    // DMLBatchSize indicates the size of batches for DML.
    // It will be used when BatchInsert or BatchDelete is on.
    DMLBatchSize int

    // 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 {
    // IndexLookupConcurrency is the number of concurrent index lookup worker.
    IndexLookupConcurrency int

    // IndexLookupJoinConcurrency is the number of concurrent index lookup join inner worker.
    IndexLookupJoinConcurrency int

    // DistSQLScanConcurrency is the number of concurrent dist SQL scan worker.
    DistSQLScanConcurrency int

    // HashJoinConcurrency is the number of concurrent hash join outer worker.
    HashJoinConcurrency int

    // ProjectionConcurrency is the number of concurrent projection worker.
    ProjectionConcurrency int64

    // HashAggPartialConcurrency is the number of concurrent hash aggregation partial worker.
    HashAggPartialConcurrency int

    // HashAggFinalConcurrency is the number of concurrent hash aggregation final worker.
    HashAggFinalConcurrency int

    // IndexSerialScanConcurrency is the number of concurrent index serial scan worker.
    IndexSerialScanConcurrency int
}

Concurrency defines concurrency values.

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
    // 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 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) 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) ResetOffset Uses

func (r *RetryInfo) ResetOffset()

ResetOffset resets the current retry offset.

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 SessionVars Uses

type SessionVars struct {
    Concurrency
    MemQuota
    BatchSize
    RetryLimit          int64
    DisableTxnAutoRetry bool
    // UsersLock is a lock for user defined variables.
    UsersLock sync.RWMutex
    // Users are user defined variables.
    Users map[string]string

    // PreparedStmts stores prepared statement.
    PreparedStmts        map[uint32]*ast.Prepared
    PreparedStmtNameToID map[string]uint32

    // PreparedParams params for prepared statements
    PreparedParams []types.Datum

    // 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

    // TxnIsolationLevelOneShot is used to implements "set transaction isolation level ..."
    TxnIsolationLevelOneShot struct {
        // State 0 means default
        // State 1 means it's set in current transaction.
        // State 2 means it should be used in current transaction.
        State int
        Value string
    }

    // 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

    // 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

    // 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

    // 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

    // 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

    // LightningMode is true when the lightning use the kvencoder to transfer sql to raw kv.
    LightningMode 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

    // 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

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

    // AllowRemoveAutoInc indicates whether a user can drop the auto_increment column attribute or not.
    AllowRemoveAutoInc bool
    // 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 *ast.Prepared) 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) GetEnableIndexMerge Uses

func (s *SessionVars) GetEnableIndexMerge() bool

GetEnableIndexMerge get EnableIndexMerge from sql hints and SessionVars.enableIndexMerge.

func (*SessionVars) GetExecuteArgumentsInfo Uses

func (s *SessionVars) GetExecuteArgumentsInfo() string

GetExecuteArgumentsInfo gets the argument list as a string of execute statement.

func (*SessionVars) GetNextPreparedStmtID Uses

func (s *SessionVars) GetNextPreparedStmtID() uint32

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

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) 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) 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) 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) 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: root@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 # 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
    IndexNames  string
    StatsInfos  map[string]uint64
    CopTasks    *stmtctx.CopTasksDetails
    ExecDetail  execdetails.ExecDetails
    MemMax      int64
    Succ        bool
    PrevStmt    string
}

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.

type TransactionContext Uses

type TransactionContext struct {
    DirtyDB       interface{}
    Binlog        interface{}
    InfoSchema    interface{}
    History       interface{}
    SchemaVersion int64
    StartTS       uint64
    Shard         *int64
    TableDeltaMap map[int64]TableDelta

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

TransactionContext is used to store variables that has transaction scope.

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) GetForUpdateTS Uses

func (tc *TransactionContext) GetForUpdateTS() uint64

GetForUpdateTS returns the ts for update.

func (*TransactionContext) SetForUpdateTS Uses

func (tc *TransactionContext) SetForUpdateTS(forUpdateTS uint64)

SetForUpdateTS sets the ts for update.

func (*TransactionContext) UpdateDeltaForTable Uses

func (tc *TransactionContext) UpdateDeltaForTable(tableID 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
    // BufStore stores temp KVs for a row when executing insert statement.
    // We could reuse a BufStore for multiple rows of a session to reduce memory allocations.
    BufStore *kv.BufferStore
    // 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 28 packages (graph) and is imported by 469 packages. Updated 2019-09-18. Refresh now. Tools for package owners.