const (
    PriorityNormal = iota
    PriorityLow
    PriorityHigh
)

const (
    ReqTypeSelect   = 101
    ReqTypeIndex    = 102
    ReqTypeDAG      = 103
    ReqTypeAnalyze  = 104
    ReqTypeChecksum = 105

    ReqSubTypeBasic      = 0
    ReqSubTypeDesc       = 10000
    ReqSubTypeGroupBy    = 10001
    ReqSubTypeTopN       = 10002
    ReqSubTypeSignature  = 10003
    ReqSubTypeAnalyzeIdx = 10004
    ReqSubTypeAnalyzeCol = 10005
)

const (
    DefBackoffLockFast = 100
    DefBackOffWeight   = 2
)

const MaxTxnTimeUse = 24 * 60 * 60 * 1000

const TxnRetryableMark = "[try again later]"

const UnCommitIndexKVFlag byte = '1'

var (
    // ErrNotExist is used when try to get an entry with an unexist key from KV store.
    ErrNotExist = terror.ClassKV.New(mysql.ErrNotExist, mysql.MySQLErrName[mysql.ErrNotExist])
    // ErrTxnRetryable is used when KV store occurs retryable error which SQL layer can safely retry the transaction.
    // When using TiKV as the storage node, the error is returned ONLY when lock not found (txnLockNotFound) in Commit,
    // subject to change it in the future.
    ErrTxnRetryable = terror.ClassKV.New(mysql.ErrTxnRetryable,
        mysql.MySQLErrName[mysql.ErrTxnRetryable]+TxnRetryableMark)
    // ErrCannotSetNilValue is the error when sets an empty value.
    ErrCannotSetNilValue = terror.ClassKV.New(mysql.ErrCannotSetNilValue, mysql.MySQLErrName[mysql.ErrCannotSetNilValue])
    // ErrInvalidTxn is the error when commits or rollbacks in an invalid transaction.
    ErrInvalidTxn = terror.ClassKV.New(mysql.ErrInvalidTxn, mysql.MySQLErrName[mysql.ErrInvalidTxn])
    // ErrTxnTooLarge is the error when transaction is too large, lock time reached the maximum value.
    ErrTxnTooLarge = terror.ClassKV.New(mysql.ErrTxnTooLarge, mysql.MySQLErrName[mysql.ErrTxnTooLarge])
    // ErrEntryTooLarge is the error when a key value entry is too large.
    ErrEntryTooLarge = terror.ClassKV.New(mysql.ErrEntryTooLarge, mysql.MySQLErrName[mysql.ErrEntryTooLarge])
    // ErrKeyExists returns when key is already exist.
    ErrKeyExists = terror.ClassKV.New(mysql.ErrDupEntry, mysql.MySQLErrName[mysql.ErrDupEntry])
    // ErrNotImplemented returns when a function is not implemented yet.
    ErrNotImplemented = terror.ClassKV.New(mysql.ErrNotImplemented, mysql.MySQLErrName[mysql.ErrNotImplemented])
    // ErrWriteConflict is the error when the commit meets an write conflict error.
    ErrWriteConflict = terror.ClassKV.New(mysql.ErrWriteConflict,
        mysql.MySQLErrName[mysql.ErrWriteConflict]+" "+TxnRetryableMark)
    // ErrWriteConflictInTiDB is the error when the commit meets an write conflict error when local latch is enabled.
    ErrWriteConflictInTiDB = terror.ClassKV.New(mysql.ErrWriteConflictInTiDB,
        mysql.MySQLErrName[mysql.ErrWriteConflictInTiDB]+" "+TxnRetryableMark)
)

var (
    // TxnEntrySizeLimit is limit of single entry size (len(key) + len(value)).
    TxnEntrySizeLimit = 6 * 1024 * 1024
    // TxnTotalSizeLimit is limit of the sum of all entry size.
    TxnTotalSizeLimit uint64 = config.DefTxnTotalSizeLimit
)

var (
    LockAlwaysWait = int64(0)
    LockNoWait     = int64(-1)
)

var (
    // MaxVersion is the maximum version, notice that it's not a valid version.
    MaxVersion = Version{Ver: math.MaxUint64}
    // MinVersion is the minimum version, it's not a valid version, too.
    MinVersion = Version{Ver: 0}
)

var DefaultVars = NewVariables(&ignoreKill)

type AssertionType int

const (
    None AssertionType = iota
    Exist
    NotExist
)

type BatchGetter interface {
    // BatchGet gets a batch of values.
    BatchGet(ctx context.Context, keys []Key) (map[string][]byte, error)
}

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

type BufferStore struct {
    MemBuffer
    // contains filtered or unexported fields
}

type Client interface {
    // Send sends request to KV layer, returns a Response.
    Send(ctx context.Context, req *Request, vars *Variables) Response

    // IsRequestTypeSupported checks if reqType and subType is supported.
    IsRequestTypeSupported(reqType, subType int64) bool
}

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

type Driver interface {
    // Open returns a new Storage.
    // The path is the string for storage specific format.
    Open(path string) (Storage, error)
}

type FnKeyCmp func(key Key) bool

type Getter interface {
    // Get gets the value for key k from kv store.
    // If corresponding kv pair does not exist, it returns nil and ErrNotExist.
    Get(ctx context.Context, k Key) ([]byte, error)
}

type Handle interface {
    // IsInt returns if the handle type is int64.
    IsInt() bool
    // IntValue returns the int64 value if IsInt is true, it panics if IsInt returns false.
    IntValue() int64
    // Next returns the minimum handle that is greater than this handle.
    Next() Handle
    // Equal returns if the handle equals to another handle, it panics if the types are different.
    Equal(h Handle) bool
    // Compare returns the comparison result of the two handles, it panics if the types are different.
    Compare(h Handle) int
    // Encoded returns the encoded bytes.
    Encoded() []byte
    // Len returns the length of the encoded bytes.
    Len() int
    // NumCols returns the number of columns of the handle,
    NumCols() int
    // EncodedCol returns the encoded column value at the given column index.
    EncodedCol(idx int) []byte
    // String implements the fmt.Stringer interface.
    String() string
}

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

type InjectedSnapshot struct {
    Snapshot
    // contains filtered or unexported fields
}

type InjectedStore struct {
    Storage
    // contains filtered or unexported fields
}

type InjectedTransaction struct {
    Transaction
    // contains filtered or unexported fields
}

type InjectionConfig struct {
    sync.RWMutex
    // contains filtered or unexported fields
}

type IntHandle int64

type IsoLevel int

const (
    // SI stands for 'snapshot isolation'.
    SI  IsoLevel = iota
    // RC stands for 'read committed'.
    RC
)

type Iterator interface {
    Valid() bool
    Key() Key
    Value() []byte
    Next() error
    Close()
}

type Key []byte

type KeyRange struct {
    StartKey Key
    EndKey   Key
}

type LockCtx struct {
    Killed                *uint32
    ForUpdateTS           uint64
    LockWaitTime          int64
    WaitStartTime         time.Time
    PessimisticLockWaited *int32
    LockKeysDuration      *time.Duration
    LockKeysCount         *int32
    ReturnValues          bool
    Values                map[string]ReturnedValue
    ValuesLock            sync.Mutex
    LockExpired           *uint32
}

type MemBuffer interface {
    RetrieverMutator
    // Size returns sum of keys and values length.
    Size() int
    // Len returns the number of entries in the DB.
    Len() int
    // NewStagingBuffer returns a new write buffer,
    // modifications in the returned buffer will not influence this buffer
    // until you call Flush, or you can use Discard to discard all of them.
    //
    // Note: you cannot modify this MemBuffer until the child buffer finished,
    // otherwise the Set operation will panic.
    NewStagingBuffer() MemBuffer
    // Flush flushes all kvs in this buffer to parrent buffer.
    Flush() (int, error)
    // Discard discads all kvs in this buffer.
    Discard()
}

type Mutator interface {
    // Set sets the value for key k as v into kv store.
    // v must NOT be nil or empty, otherwise it returns ErrCannotSetNilValue.
    Set(k Key, v []byte) error
    // Delete removes the entry for key k from kv store.
    Delete(k Key) error
}

type Option int

const (
    // PresumeKeyNotExists indicates that when dealing with a Get operation but failing to read data from cache,
    // we presume that the key does not exist in Store. The actual existence will be checked before the
    // transaction's commit.
    // This option is an optimization for frequent checks during a transaction, e.g. batch inserts.
    PresumeKeyNotExists Option = iota + 1
    // PresumeKeyNotExistsError is the option key for error.
    // When PresumeKeyNotExists is set and condition is not match, should throw the error.
    PresumeKeyNotExistsError
    // BinlogInfo contains the binlog data and client.
    BinlogInfo
    // SchemaChecker is used for checking schema-validity.
    SchemaChecker
    // IsolationLevel sets isolation level for current transaction. The default level is SI.
    IsolationLevel
    // Priority marks the priority of this transaction.
    Priority
    // NotFillCache makes this request do not touch the LRU cache of the underlying storage.
    NotFillCache
    // SyncLog decides whether the WAL(write-ahead log) of this request should be synchronized.
    SyncLog
    // KeyOnly retrieve only keys, it can be used in scan now.
    KeyOnly
    // Pessimistic is defined for pessimistic lock
    Pessimistic
    // SnapshotTS is defined to set snapshot ts.
    SnapshotTS
    // Set replica read
    ReplicaRead
    // Set task ID
    TaskID
)

type Options interface {
    // Get gets an option value.
    Get(opt Option) (v interface{}, ok bool)
}

type ReplicaReadType byte

const (
    // ReplicaReadLeader stands for 'read from leader'.
    ReplicaReadLeader ReplicaReadType = 1 << iota
    // ReplicaReadFollower stands for 'read from follower'.
    ReplicaReadFollower
    // ReplicaReadMixed stands for 'read from leader and follower and learner'.
    ReplicaReadMixed
)

type Request struct {
    // Tp is the request type.
    Tp        int64
    StartTs   uint64
    Data      []byte
    KeyRanges []KeyRange

    // Concurrency is 1, if it only sends the request to a single storage unit when
    // ResponseIterator.Next is called. If concurrency is greater than 1, the request will be
    // sent to multiple storage units concurrently.
    Concurrency int
    // IsolationLevel is the isolation level, default is SI.
    IsolationLevel IsoLevel
    // Priority is the priority of this KV request, its value may be PriorityNormal/PriorityLow/PriorityHigh.
    Priority int
    // memTracker is used to trace and control memory usage in co-processor layer.
    MemTracker *memory.Tracker
    // KeepOrder is true, if the response should be returned in order.
    KeepOrder bool
    // Desc is true, if the request is sent in descending order.
    Desc bool
    // NotFillCache makes this request do not touch the LRU cache of the underlying storage.
    NotFillCache bool
    // SyncLog decides whether the WAL(write-ahead log) of this request should be synchronized.
    SyncLog bool
    // Streaming indicates using streaming API for this request, result in that one Next()
    // call would not corresponds to a whole region result.
    Streaming bool
    // ReplicaRead is used for reading data from replicas, only follower is supported at this time.
    ReplicaRead ReplicaReadType
    // StoreType represents this request is sent to the which type of store.
    StoreType StoreType
    // Cacheable is true if the request can be cached. Currently only deterministic DAG requests can be cached.
    Cacheable bool
    // SchemaVer is for any schema-ful storage to validate schema correctness if necessary.
    SchemaVar int64
    // BatchCop indicates whether send batch coprocessor request to tiflash.
    BatchCop bool
    // TaskID is an unique ID for an execution of a statement
    TaskID uint64
}

type RequestTypeSupportedChecker struct{}

type Response interface {
    // Next returns a resultSubset from a single storage unit.
    // When full result set is returned, nil is returned.
    Next(ctx context.Context) (resultSubset ResultSubset, err error)
    // Close response.
    Close() error
}

type ResultSubset interface {
    // GetData gets the data.
    GetData() []byte
    // GetStartKey gets the start key.
    GetStartKey() Key
    // GetExecDetails gets the detail information.
    GetExecDetails() *execdetails.ExecDetails
    // MemSize returns how many bytes of memory this result use for tracing memory usage.
    MemSize() int64
    // RespTime returns the response time for the request.
    RespTime() time.Duration
}

type Retriever interface {
    Getter
    // Iter creates an Iterator positioned on the first entry that k <= entry's key.
    // If such entry is not found, it returns an invalid Iterator with no error.
    // It yields only keys that < upperBound. If upperBound is nil, it means the upperBound is unbounded.
    // The Iterator must be Closed after use.
    Iter(k Key, upperBound Key) (Iterator, error)

    // IterReverse creates a reversed Iterator positioned on the first entry which key is less than k.
    // The returned iterator will iterate from greater key to smaller key.
    // If k is nil, the returned iterator will be positioned at the last key.
    // TODO: Add lower bound limit
    IterReverse(k Key) (Iterator, error)
}

type RetrieverMutator interface {
    Retriever
    Mutator
}

type ReturnedValue struct {
    Value         []byte
    AlreadyLocked bool
}

type Snapshot interface {
    Retriever
    // BatchGet gets a batch of values from snapshot.
    BatchGet(ctx context.Context, keys []Key) (map[string][]byte, error)
    // SetOption sets an option with a value, when val is nil, uses the default
    // value of this option. Only ReplicaRead is supported for snapshot
    SetOption(opt Option, val interface{})
    // DelOption deletes an option.
    DelOption(opt Option)
}

type SplittableStore interface {
    SplitRegions(ctx context.Context, splitKey [][]byte, scatter bool) (regionID []uint64, err error)
    WaitScatterRegionFinish(regionID uint64, backOff int) error
    CheckRegionInScattering(regionID uint64) (bool, error)
}

type Storage interface {
    // Begin transaction
    Begin() (Transaction, error)
    // BeginWithStartTS begins transaction with startTS.
    BeginWithStartTS(startTS uint64) (Transaction, error)
    // GetSnapshot gets a snapshot that is able to read any data which data is <= ver.
    // if ver is MaxVersion or > current max committed version, we will use current version for this snapshot.
    GetSnapshot(ver Version) (Snapshot, error)
    // GetClient gets a client instance.
    GetClient() Client
    // Close store
    Close() error
    // UUID return a unique ID which represents a Storage.
    UUID() string
    // CurrentVersion returns current max committed version.
    CurrentVersion() (Version, error)
    // GetOracle gets a timestamp oracle client.
    GetOracle() oracle.Oracle
    // SupportDeleteRange gets the storage support delete range or not.
    SupportDeleteRange() (supported bool)
    // Name gets the name of the storage engine
    Name() string
    // Describe returns of brief introduction of the storage
    Describe() string
    // ShowStatus returns the specified status of the storage
    ShowStatus(ctx context.Context, key string) (interface{}, error)
}

type StoreType uint8

const (
    // TiKV means the type of a store is TiKV.
    TiKV StoreType = iota
    // TiFlash means the type of a store is TiFlash.
    TiFlash
    // TiDB means the type of a store is TiDB.
    TiDB
    // UnSpecified means the store type is unknown
    UnSpecified = 255
)

type Transaction interface {
    MemBuffer
    // Commit commits the transaction operations to KV store.
    Commit(context.Context) error
    // Rollback undoes the transaction operations to KV store.
    Rollback() error
    // String implements fmt.Stringer interface.
    String() string
    // LockKeys tries to lock the entries with the keys in KV store.
    LockKeys(ctx context.Context, lockCtx *LockCtx, keys ...Key) error
    // SetOption sets an option with a value, when val is nil, uses the default
    // value of this option.
    SetOption(opt Option, val interface{})
    // DelOption deletes an option.
    DelOption(opt Option)
    // IsReadOnly checks if the transaction has only performed read operations.
    IsReadOnly() bool
    // StartTS returns the transaction start timestamp.
    StartTS() uint64
    // Valid returns if the transaction is valid.
    // A transaction become invalid after commit or rollback.
    Valid() bool
    // GetMemBuffer return the MemBuffer binding to this transaction.
    GetMemBuffer() MemBuffer
    // GetSnapshot returns the Snapshot binding to this transaction.
    GetSnapshot() Snapshot
    // SetVars sets variables to the transaction.
    SetVars(vars *Variables)
    // BatchGet gets kv from the memory buffer of statement and transaction, and the kv storage.
    // Do not use len(value) == 0 or value == nil to represent non-exist.
    // If a key doesn't exist, there shouldn't be any corresponding entry in the result map.
    BatchGet(ctx context.Context, keys []Key) (map[string][]byte, error)
    IsPessimistic() bool
}

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

type UnionStore interface {
    MemBuffer
    // GetKeyExistErrInfo gets the key exist error info for the lazy check.
    GetKeyExistErrInfo(k Key) *existErrInfo
    // DeleteKeyExistErrInfo deletes the key exist error info for the lazy check.
    DeleteKeyExistErrInfo(k Key)
    // WalkBuffer iterates all buffered kv pairs.
    WalkBuffer(f func(k Key, v []byte) error) error
    // SetOption sets an option with a value, when val is nil, uses the default
    // value of this option.
    SetOption(opt Option, val interface{})
    // DelOption deletes an option.
    DelOption(opt Option)
    // GetOption gets an option.
    GetOption(opt Option) interface{}
    // GetMemBuffer return the MemBuffer binding to this UnionStore.
    GetMemBuffer() MemBuffer
}

type Variables struct {
    // BackoffLockFast specifies the LockFast backoff base duration in milliseconds.
    BackoffLockFast int

    // BackOffWeight specifies the weight of the max back off time duration.
    BackOffWeight int

    // Hook is used for test to verify the variable take effect.
    Hook func(name string, vars *Variables)

    // Pointer to SessionVars.Killed
    // Killed is a flag to indicate that this query is killed.
    Killed *uint32
}

type Version struct {
    Ver uint64
}

type VersionProvider interface {
    CurrentVersion() (Version, error)
}