tidb: github.com/pingcap/tidb/config Index | Files

package config

import "github.com/pingcap/tidb/config"

Index

Package Files

config.go

Constants

const (
    MaxLogFileSize    = 4096 // MB
    MinPessimisticTTL = time.Second * 15
    MaxPessimisticTTL = time.Second * 120
    // DefTxnTotalSizeLimit is the default value of TxnTxnTotalSizeLimit.
    DefTxnTotalSizeLimit = 100 * 1024 * 1024
)

Config number limitations

const (
    OOMActionCancel = "cancel"
    OOMActionLog    = "log"
)

The following constants represents the valid action configurations for OOMAction. NOTE: Although the values is case insensitive, we should use lower-case strings because the configuration value will be transformed to lower-case string and compared with these constants in the further usage.

Variables

var (
    ValidStorage = map[string]bool{
        "mocktikv": true,
        "tikv":     true,
    }
    // checkTableBeforeDrop enable to execute `admin check table` before `drop table`.
    CheckTableBeforeDrop = false
)

Valid config maps

var TableLockDelayClean = func() uint64 {
    return GetGlobalConfig().DelayCleanTableLock
}

TableLockDelayClean uses to get the time of delay clean table lock.

func ReloadGlobalConfig Uses

func ReloadGlobalConfig() error

ReloadGlobalConfig reloads global configuration for this server.

func SetConfReloader Uses

func SetConfReloader(cpath string, reloader func(nc, c *Config), confItems ...string)

SetConfReloader sets reload config path and a reloader. It should be called only once at start time.

func StoreGlobalConfig Uses

func StoreGlobalConfig(config *Config)

StoreGlobalConfig stores a new config to the globalConf. It mostly uses in the test to avoid some data races.

func TableLockEnabled Uses

func TableLockEnabled() bool

TableLockEnabled uses to check whether enabled the table lock feature.

type Binlog Uses

type Binlog struct {
    Enable bool `toml:"enable" json:"enable"`
    // If IgnoreError is true, when writing binlog meets error, TiDB would
    // ignore the error.
    IgnoreError  bool   `toml:"ignore-error" json:"ignore-error"`
    WriteTimeout string `toml:"write-timeout" json:"write-timeout"`
    // Use socket file to write binlog, for compatible with kafka version tidb-binlog.
    BinlogSocket string `toml:"binlog-socket" json:"binlog-socket"`
    // The strategy for sending binlog to pump, value can be "range" or "hash" now.
    Strategy string `toml:"strategy" json:"strategy"`
}

Binlog is the config for binlog.

type Config Uses

type Config struct {
    Host             string          `toml:"host" json:"host"`
    AdvertiseAddress string          `toml:"advertise-address" json:"advertise-address"`
    Port             uint            `toml:"port" json:"port"`
    Cors             string          `toml:"cors" json:"cors"`
    Store            string          `toml:"store" json:"store"`
    Path             string          `toml:"path" json:"path"`
    Socket           string          `toml:"socket" json:"socket"`
    Lease            string          `toml:"lease" json:"lease"`
    RunDDL           bool            `toml:"run-ddl" json:"run-ddl"`
    SplitTable       bool            `toml:"split-table" json:"split-table"`
    TokenLimit       uint            `toml:"token-limit" json:"token-limit"`
    OOMAction        string          `toml:"oom-action" json:"oom-action"`
    MemQuotaQuery    int64           `toml:"mem-quota-query" json:"mem-quota-query"`
    EnableStreaming  bool            `toml:"enable-streaming" json:"enable-streaming"`
    TxnLocalLatches  TxnLocalLatches `toml:"txn-local-latches" json:"txn-local-latches"`
    // Set sys variable lower-case-table-names, ref: https://dev.mysql.com/doc/refman/5.7/en/identifier-case-sensitivity.html.
    // TODO: We actually only support mode 2, which keeps the original case, but the comparison is case-insensitive.
    LowerCaseTableNames int `toml:"lower-case-table-names" json:"lower-case-table-names"`

    Log                 Log               `toml:"log" json:"log"`
    Security            Security          `toml:"security" json:"security"`
    Status              Status            `toml:"status" json:"status"`
    Performance         Performance       `toml:"performance" json:"performance"`
    PreparedPlanCache   PreparedPlanCache `toml:"prepared-plan-cache" json:"prepared-plan-cache"`
    OpenTracing         OpenTracing       `toml:"opentracing" json:"opentracing"`
    ProxyProtocol       ProxyProtocol     `toml:"proxy-protocol" json:"proxy-protocol"`
    TiKVClient          TiKVClient        `toml:"tikv-client" json:"tikv-client"`
    Binlog              Binlog            `toml:"binlog" json:"binlog"`
    CompatibleKillQuery bool              `toml:"compatible-kill-query" json:"compatible-kill-query"`
    Plugin              Plugin            `toml:"plugin" json:"plugin"`
    PessimisticTxn      PessimisticTxn    `toml:"pessimistic-txn" json:"pessimistic-txn"`
    CheckMb4ValueInUTF8 bool              `toml:"check-mb4-value-in-utf8" json:"check-mb4-value-in-utf8"`
    // TreatOldVersionUTF8AsUTF8MB4 is use to treat old version table/column UTF8 charset as UTF8MB4. This is for compatibility.
    // Currently not support dynamic modify, because this need to reload all old version schema.
    TreatOldVersionUTF8AsUTF8MB4 bool `toml:"treat-old-version-utf8-as-utf8mb4" json:"treat-old-version-utf8-as-utf8mb4"`
    // EnableTableLock indicate whether enable table lock.
    // TODO: remove this after table lock features stable.
    EnableTableLock     bool        `toml:"enable-table-lock" json:"enable-table-lock"`
    DelayCleanTableLock uint64      `toml:"delay-clean-table-lock" json:"delay-clean-table-lock"`
    SplitRegionMaxNum   uint64      `toml:"split-region-max-num" json:"split-region-max-num"`
    StmtSummary         StmtSummary `toml:"stmt-summary" json:"stmt-summary"`
}

Config contains configuration options.

func GetGlobalConfig Uses

func GetGlobalConfig() *Config

GetGlobalConfig returns the global configuration for this server. It should store configuration from command line and configuration file. Other parts of the system can read the global configuration use this function.

func NewConfig Uses

func NewConfig() *Config

NewConfig creates a new config instance with default value.

func (*Config) Load Uses

func (c *Config) Load(confFile string) error

Load loads config options from a toml file.

func (*Config) Valid Uses

func (c *Config) Valid() error

Valid checks if this config is valid.

type ErrConfigValidationFailed Uses

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

The ErrConfigValidationFailed error is used so that external callers can do a type assertion to defer handling of this specific error when someone does not want strict type checking. This is needed only because logging hasn't been set up at the time we parse the config file. This should all be ripped out once strict config checking is made the default behavior.

func (*ErrConfigValidationFailed) Error Uses

func (e *ErrConfigValidationFailed) Error() string

type Log Uses

type Log struct {
    // Log level.
    Level string `toml:"level" json:"level"`
    // Log format. one of json, text, or console.
    Format string `toml:"format" json:"format"`
    // Disable automatic timestamps in output.
    DisableTimestamp bool `toml:"disable-timestamp" json:"disable-timestamp"`
    // DisableErrorStack stops annotating logs with the full stack error
    // message.
    DisableErrorStack bool `toml:"disable-error-stack" json:"disable-error-stack"`
    // File log config.
    File logutil.FileLogConfig `toml:"file" json:"file"`

    SlowQueryFile      string `toml:"slow-query-file" json:"slow-query-file"`
    SlowThreshold      uint64 `toml:"slow-threshold" json:"slow-threshold"`
    ExpensiveThreshold uint   `toml:"expensive-threshold" json:"expensive-threshold"`
    QueryLogMaxLen     uint64 `toml:"query-log-max-len" json:"query-log-max-len"`
}

Log is the log section of config.

func (*Log) ToLogConfig Uses

func (l *Log) ToLogConfig() *logutil.LogConfig

ToLogConfig converts *Log to *logutil.LogConfig.

type OpenTracing Uses

type OpenTracing struct {
    Enable     bool                `toml:"enable" json:"enable"`
    RPCMetrics bool                `toml:"rpc-metrics" json:"rpc-metrics"`
    Sampler    OpenTracingSampler  `toml:"sampler" json:"sampler"`
    Reporter   OpenTracingReporter `toml:"reporter" json:"reporter"`
}

OpenTracing is the opentracing section of the config.

func (*OpenTracing) ToTracingConfig Uses

func (t *OpenTracing) ToTracingConfig() *tracing.Configuration

ToTracingConfig converts *OpenTracing to *tracing.Configuration.

type OpenTracingReporter Uses

type OpenTracingReporter struct {
    QueueSize           int           `toml:"queue-size" json:"queue-size"`
    BufferFlushInterval time.Duration `toml:"buffer-flush-interval" json:"buffer-flush-interval"`
    LogSpans            bool          `toml:"log-spans" json:"log-spans"`
    LocalAgentHostPort  string        `toml:"local-agent-host-port" json:"local-agent-host-port"`
}

OpenTracingReporter is the config for opentracing reporter. See https://godoc.org/github.com/uber/jaeger-client-go/config#ReporterConfig

type OpenTracingSampler Uses

type OpenTracingSampler struct {
    Type                    string        `toml:"type" json:"type"`
    Param                   float64       `toml:"param" json:"param"`
    SamplingServerURL       string        `toml:"sampling-server-url" json:"sampling-server-url"`
    MaxOperations           int           `toml:"max-operations" json:"max-operations"`
    SamplingRefreshInterval time.Duration `toml:"sampling-refresh-interval" json:"sampling-refresh-interval"`
}

OpenTracingSampler is the config for opentracing sampler. See https://godoc.org/github.com/uber/jaeger-client-go/config#SamplerConfig

type Performance Uses

type Performance struct {
    MaxProcs            uint    `toml:"max-procs" json:"max-procs"`
    MaxMemory           uint64  `toml:"max-memory" json:"max-memory"`
    StatsLease          string  `toml:"stats-lease" json:"stats-lease"`
    StmtCountLimit      uint    `toml:"stmt-count-limit" json:"stmt-count-limit"`
    FeedbackProbability float64 `toml:"feedback-probability" json:"feedback-probability"`
    QueryFeedbackLimit  uint    `toml:"query-feedback-limit" json:"query-feedback-limit"`
    PseudoEstimateRatio float64 `toml:"pseudo-estimate-ratio" json:"pseudo-estimate-ratio"`
    ForcePriority       string  `toml:"force-priority" json:"force-priority"`
    BindInfoLease       string  `toml:"bind-info-lease" json:"bind-info-lease"`
    TxnTotalSizeLimit   uint64  `toml:"txn-total-size-limit" json:"txn-total-size-limit"`
    TCPKeepAlive        bool    `toml:"tcp-keep-alive" json:"tcp-keep-alive"`
    CrossJoin           bool    `toml:"cross-join" json:"cross-join"`
    RunAutoAnalyze      bool    `toml:"run-auto-analyze" json:"run-auto-analyze"`
}

Performance is the performance section of the config.

type PessimisticTxn Uses

type PessimisticTxn struct {
    // Enable must be true for 'begin lock' or session variable to start a pessimistic transaction.
    Enable bool `toml:"enable" json:"enable"`
    // The max count of retry for a single statement in a pessimistic transaction.
    MaxRetryCount uint `toml:"max-retry-count" json:"max-retry-count"`
    // The pessimistic lock ttl.
    TTL string `toml:"ttl" json:"ttl"`
}

PessimisticTxn is the config for pessimistic transaction.

type PlanCache Uses

type PlanCache struct {
    Enabled  bool `toml:"enabled" json:"enabled"`
    Capacity uint `toml:"capacity" json:"capacity"`
    Shards   uint `toml:"shards" json:"shards"`
}

PlanCache is the PlanCache section of the config.

type Plugin Uses

type Plugin struct {
    Dir  string `toml:"dir" json:"dir"`
    Load string `toml:"load" json:"load"`
}

Plugin is the config for plugin

type PreparedPlanCache Uses

type PreparedPlanCache struct {
    Enabled          bool    `toml:"enabled" json:"enabled"`
    Capacity         uint    `toml:"capacity" json:"capacity"`
    MemoryGuardRatio float64 `toml:"memory-guard-ratio" json:"memory-guard-ratio"`
}

PreparedPlanCache is the PreparedPlanCache section of the config.

type ProxyProtocol Uses

type ProxyProtocol struct {
    // PROXY protocol acceptable client networks.
    // Empty string means disable PROXY protocol,
    // * means all networks.
    Networks string `toml:"networks" json:"networks"`
    // PROXY protocol header read timeout, Unit is second.
    HeaderTimeout uint `toml:"header-timeout" json:"header-timeout"`
}

ProxyProtocol is the PROXY protocol section of the config.

type Security Uses

type Security struct {
    SkipGrantTable bool   `toml:"skip-grant-table" json:"skip-grant-table"`
    SSLCA          string `toml:"ssl-ca" json:"ssl-ca"`
    SSLCert        string `toml:"ssl-cert" json:"ssl-cert"`
    SSLKey         string `toml:"ssl-key" json:"ssl-key"`
    ClusterSSLCA   string `toml:"cluster-ssl-ca" json:"cluster-ssl-ca"`
    ClusterSSLCert string `toml:"cluster-ssl-cert" json:"cluster-ssl-cert"`
    ClusterSSLKey  string `toml:"cluster-ssl-key" json:"cluster-ssl-key"`
}

Security is the security section of the config.

func (*Security) ToTLSConfig Uses

func (s *Security) ToTLSConfig() (*tls.Config, error)

ToTLSConfig generates tls's config based on security section of the config.

type Status Uses

type Status struct {
    StatusHost      string `toml:"status-host" json:"status-host"`
    MetricsAddr     string `toml:"metrics-addr" json:"metrics-addr"`
    StatusPort      uint   `toml:"status-port" json:"status-port"`
    MetricsInterval uint   `toml:"metrics-interval" json:"metrics-interval"`
    ReportStatus    bool   `toml:"report-status" json:"report-status"`
    RecordQPSbyDB   bool   `toml:"record-db-qps" json:"record-db-qps"`
}

Status is the status section of the config.

type StmtSummary Uses

type StmtSummary struct {
    // The maximum number of statements kept in memory.
    MaxStmtCount uint `toml:"max-stmt-count" json:"max-stmt-count"`
    // The maximum length of displayed normalized SQL and sample SQL.
    MaxSQLLength uint `toml:"max-sql-length" json:"max-sql-length"`
}

StmtSummary is the config for statement summary.

type TiKVClient Uses

type TiKVClient struct {
    // GrpcConnectionCount is the max gRPC connections that will be established
    // with each tikv-server.
    GrpcConnectionCount uint `toml:"grpc-connection-count" json:"grpc-connection-count"`
    // After a duration of this time in seconds if the client doesn't see any activity it pings
    // the server to see if the transport is still alive.
    GrpcKeepAliveTime uint `toml:"grpc-keepalive-time" json:"grpc-keepalive-time"`
    // After having pinged for keepalive check, the client waits for a duration of Timeout in seconds
    // and if no activity is seen even after that the connection is closed.
    GrpcKeepAliveTimeout uint `toml:"grpc-keepalive-timeout" json:"grpc-keepalive-timeout"`
    // CommitTimeout is the max time which command 'commit' will wait.
    CommitTimeout string `toml:"commit-timeout" json:"commit-timeout"`

    // MaxTxnTimeUse is the max time a Txn may use (in seconds) from its startTS to commitTS.
    MaxTxnTimeUse uint `toml:"max-txn-time-use" json:"max-txn-time-use"`

    // MaxBatchSize is the max batch size when calling batch commands API.
    MaxBatchSize uint `toml:"max-batch-size" json:"max-batch-size"`
    // If TiKV load is greater than this, TiDB will wait for a while to avoid little batch.
    OverloadThreshold uint `toml:"overload-threshold" json:"overload-threshold"`
    // MaxBatchWaitTime in nanosecond is the max wait time for batch.
    MaxBatchWaitTime time.Duration `toml:"max-batch-wait-time" json:"max-batch-wait-time"`
    // BatchWaitSize is the max wait size for batch.
    BatchWaitSize uint `toml:"batch-wait-size" json:"batch-wait-size"`
}

TiKVClient is the config for tikv client.

type TxnLocalLatches Uses

type TxnLocalLatches struct {
    Enabled  bool `toml:"enabled" json:"enabled"`
    Capacity uint `toml:"capacity" json:"capacity"`
}

TxnLocalLatches is the TxnLocalLatches section of the config.

Package config imports 16 packages (graph) and is imported by 95 packages. Updated 2019-09-13. Refresh now. Tools for package owners.