tidb: github.com/pingcap/tidb/store/helper Index | Files

package helper

import "github.com/pingcap/tidb/store/helper"


Package Files


type FrameItem Uses

type FrameItem struct {
    DBName      string   `json:"db_name"`
    TableName   string   `json:"table_name"`
    TableID     int64    `json:"table_id"`
    IsRecord    bool     `json:"is_record"`
    RecordID    int64    `json:"record_id,omitempty"`
    IndexName   string   `json:"index_name,omitempty"`
    IndexID     int64    `json:"index_id,omitempty"`
    IndexValues []string `json:"index_values,omitempty"`

FrameItem includes a index's or record's meta data with table's info.

func NewFrameItemFromRegionKey Uses

func NewFrameItemFromRegionKey(key []byte) (frame *FrameItem, err error)

NewFrameItemFromRegionKey creates a FrameItem with region's startKey or endKey, returns err when key is illegal.

type Helper Uses

type Helper struct {
    Store       tikv.Storage
    RegionCache *tikv.RegionCache

Helper is a middleware to get some information from tikv/pd. It can be used for TiDB's http api or mem table.

func NewHelper Uses

func NewHelper(store tikv.Storage) *Helper

NewHelper get a Helper from Storage

func (*Helper) FetchHotRegion Uses

func (h *Helper) FetchHotRegion(rw string) (map[uint64]RegionMetric, error)

FetchHotRegion fetches the hot region information from PD's http api.

func (*Helper) FetchRegionTableIndex Uses

func (h *Helper) FetchRegionTableIndex(metrics map[uint64]RegionMetric, allSchemas []*model.DBInfo) ([]HotTableIndex, error)

FetchRegionTableIndex constructs a map that maps a table to its hot region information by the given raw hot RegionMetric metrics.

func (*Helper) FindTableIndexOfRegion Uses

func (h *Helper) FindTableIndexOfRegion(allSchemas []*model.DBInfo, hotRange *RegionFrameRange) *FrameItem

FindTableIndexOfRegion finds what table is involved in this hot region. And constructs the new frame item for future use.

func (*Helper) GetMvccByEncodedKey Uses

func (h *Helper) GetMvccByEncodedKey(encodedKey kv.Key) (*kvrpcpb.MvccGetByKeyResponse, error)

GetMvccByEncodedKey get the MVCC value by the specific encoded key.

func (*Helper) GetRegionInfoByID Uses

func (h *Helper) GetRegionInfoByID(regionID uint64) (*RegionInfo, error)

GetRegionInfoByID gets the region information of the region ID by using PD's api.

func (*Helper) GetRegionsInfo Uses

func (h *Helper) GetRegionsInfo() (*RegionsInfo, error)

GetRegionsInfo gets the region information of current store by using PD's api.

func (*Helper) GetRegionsTableInfo Uses

func (h *Helper) GetRegionsTableInfo(regionsInfo *RegionsInfo, schemas []*model.DBInfo) map[int64][]TableInfo

GetRegionsTableInfo returns a map maps region id to its tables or indices. Assuming tables or indices key ranges never intersect. Regions key ranges can intersect.

func (*Helper) GetStoresStat Uses

func (h *Helper) GetStoresStat() (*StoresStat, error)

GetStoresStat gets the TiKV store information by accessing PD's api.

func (*Helper) ScrapeHotInfo Uses

func (h *Helper) ScrapeHotInfo(rw string, allSchemas []*model.DBInfo) ([]HotTableIndex, error)

ScrapeHotInfo gets the needed hot region information by the url given.

type HotRegionsStat Uses

type HotRegionsStat struct {
    RegionsStat []RegionStat `json:"statistics"`

HotRegionsStat records echo store's hot region. it's the response of PD.

type HotTableIndex Uses

type HotTableIndex struct {
    RegionID     uint64        `json:"region_id"`
    RegionMetric *RegionMetric `json:"region_metric"`
    DbName       string        `json:"db_name"`
    TableName    string        `json:"table_name"`
    TableID      int64         `json:"table_id"`
    IndexName    string        `json:"index_name"`
    IndexID      int64         `json:"index_id"`

HotTableIndex contains region and its table/index info.

type RegionEpoch Uses

type RegionEpoch struct {
    ConfVer int64 `json:"conf_ver"`
    Version int64 `json:"version"`

RegionEpoch stores the information about its epoch.

type RegionFrameRange Uses

type RegionFrameRange struct {
    First *FrameItem // start frame of the region
    Last  *FrameItem // end frame of the region
    // contains filtered or unexported fields

RegionFrameRange contains a frame range info which the region covered.

func NewRegionFrameRange Uses

func NewRegionFrameRange(region *tikv.KeyLocation) (idxRange *RegionFrameRange, err error)

NewRegionFrameRange init a NewRegionFrameRange with region info.

func (*RegionFrameRange) GetIndexFrame Uses

func (r *RegionFrameRange) GetIndexFrame(tableID, indexID int64, dbName, tableName, indexName string) *FrameItem

GetIndexFrame returns the indnex frame of a table. If the table's indices are not covered by this frame range, it returns nil.

func (*RegionFrameRange) GetRecordFrame Uses

func (r *RegionFrameRange) GetRecordFrame(tableID int64, dbName, tableName string) *FrameItem

GetRecordFrame returns the record frame of a table. If the table's records are not covered by this frame range, it returns nil.

type RegionInfo Uses

type RegionInfo struct {
    ID              int64            `json:"id"`
    StartKey        string           `json:"start_key"`
    EndKey          string           `json:"end_key"`
    Epoch           RegionEpoch      `json:"epoch"`
    Peers           []RegionPeer     `json:"peers"`
    Leader          RegionPeer       `json:"leader"`
    DownPeers       []RegionPeerStat `json:"down_peers"`
    PendingPeers    []RegionPeer     `json:"pending_peers"`
    WrittenBytes    int64            `json:"written_bytes"`
    ReadBytes       int64            `json:"read_bytes"`
    ApproximateSize int64            `json:"approximate_size"`
    ApproximateKeys int64            `json:"approximate_keys"`

    ReplicationStatus *ReplicationStatus `json:"replication_status,omitempty"`

RegionInfo stores the information of one region.

type RegionMetric Uses

type RegionMetric struct {
    FlowBytes    uint64 `json:"flow_bytes"`
    MaxHotDegree int    `json:"max_hot_degree"`
    Count        int    `json:"region_count"`

RegionMetric presents the final metric output entry.

type RegionPeer Uses

type RegionPeer struct {
    ID        int64 `json:"id"`
    StoreID   int64 `json:"store_id"`
    IsLearner bool  `json:"is_learner"`

RegionPeer stores information of one peer.

type RegionPeerStat Uses

type RegionPeerStat struct {
    DownSec int64 `json:"down_seconds"`

RegionPeerStat stores one field `DownSec` which indicates how long it's down than `RegionPeer`.

type RegionStat Uses

type RegionStat struct {
    RegionID  uint64  `json:"region_id"`
    FlowBytes float64 `json:"flow_bytes"`
    HotDegree int     `json:"hot_degree"`

RegionStat records each hot region's statistics it's the response of PD.

type RegionsInfo Uses

type RegionsInfo struct {
    Count   int64        `json:"count"`
    Regions []RegionInfo `json:"regions"`

RegionsInfo stores the information of regions.

type ReplicationStatus Uses

type ReplicationStatus struct {
    State   string `json:"state"`
    StateID int64  `json:"state_id"`

ReplicationStatus represents the replication mode status of the region.

type StoreBaseStat Uses

type StoreBaseStat struct {
    ID             int64        `json:"id"`
    Address        string       `json:"address"`
    State          int64        `json:"state"`
    StateName      string       `json:"state_name"`
    Version        string       `json:"version"`
    Labels         []StoreLabel `json:"labels"`
    StatusAddress  string       `json:"status_address"`
    GitHash        string       `json:"git_hash"`
    StartTimestamp int64        `json:"start_timestamp"`

StoreBaseStat stores the basic information of one store.

type StoreDetailStat Uses

type StoreDetailStat struct {
    Capacity        string    `json:"capacity"`
    Available       string    `json:"available"`
    LeaderCount     int64     `json:"leader_count"`
    LeaderWeight    float64   `json:"leader_weight"`
    LeaderScore     float64   `json:"leader_score"`
    LeaderSize      int64     `json:"leader_size"`
    RegionCount     int64     `json:"region_count"`
    RegionWeight    float64   `json:"region_weight"`
    RegionScore     float64   `json:"region_score"`
    RegionSize      int64     `json:"region_size"`
    StartTs         time.Time `json:"start_ts"`
    LastHeartbeatTs time.Time `json:"last_heartbeat_ts"`
    Uptime          string    `json:"uptime"`

StoreDetailStat stores the detail information of one store.

type StoreHotRegionInfos Uses

type StoreHotRegionInfos struct {
    AsPeer   map[uint64]*HotRegionsStat `json:"as_peer"`
    AsLeader map[uint64]*HotRegionsStat `json:"as_leader"`

StoreHotRegionInfos records all hog region stores. it's the response of PD.

type StoreLabel Uses

type StoreLabel struct {
    Key   string `json:"key"`
    Value string `json:"value"`

StoreLabel stores the information of one store label.

type StoreStat Uses

type StoreStat struct {
    Store  StoreBaseStat   `json:"store"`
    Status StoreDetailStat `json:"status"`

StoreStat stores information of one store.

type StoresStat Uses

type StoresStat struct {
    Count  int         `json:"count"`
    Stores []StoreStat `json:"stores"`

StoresStat stores all information get from PD's api.

type TableInfo Uses

type TableInfo struct {
    DB      *model.DBInfo
    Table   *model.TableInfo
    IsIndex bool
    Index   *model.IndexInfo

TableInfo stores the information of a table or an index

type TblIndex Uses

type TblIndex struct {
    DbName    string
    TableName string
    TableID   int64
    IndexName string
    IndexID   int64

TblIndex stores the things to index one table.

Package helper imports 24 packages (graph) and is imported by 15 packages. Updated 2020-05-30. Refresh now. Tools for package owners.