executor: Migrate dataForStatistics, dataForTikVRegionPeers, dataForTiDBHotRegions from package infoschema to executor

executor/builder.go

@@ -1408,6 +1408,7 @@ func (b *executorBuilder) buildMemTable(v *plannercore.PhysicalMemTable) Executo
 				},
 			}
 		case strings.ToLower(infoschema.TableSchemata),
+			strings.ToLower(infoschema.TableStatistics),
 			strings.ToLower(infoschema.TableTiDBIndexes),
 			strings.ToLower(infoschema.TableViews),
 			strings.ToLower(infoschema.TableTables),
@@ -1417,7 +1418,9 @@ func (b *executorBuilder) buildMemTable(v *plannercore.PhysicalMemTable) Executo
 			strings.ToLower(infoschema.TableCharacterSets),
 			strings.ToLower(infoschema.TableKeyColumn),
 			strings.ToLower(infoschema.TableUserPrivileges),
-			strings.ToLower(infoschema.TableCollationCharacterSetApplicability):
+			strings.ToLower(infoschema.TableCollationCharacterSetApplicability),
+			strings.ToLower(infoschema.TableTiKVRegionPeers),
+			strings.ToLower(infoschema.TableTiDBHotRegions):
 			return &MemTableReaderExec{
 				baseExecutor: newBaseExecutor(b.ctx, v.Schema(), v.ExplainID()),
 				retriever: &memtableRetriever{

executor/infoschema_reader.go

@@ -20,15 +20,20 @@ import (
 	"sync"
 	"time"
 
+	"github.com/pingcap/errors"
 	"github.com/pingcap/parser/charset"
 	"github.com/pingcap/parser/model"
 	"github.com/pingcap/parser/mysql"
 	"github.com/pingcap/tidb/infoschema"
 	"github.com/pingcap/tidb/meta/autoid"
 	"github.com/pingcap/tidb/privilege"
 	"github.com/pingcap/tidb/sessionctx"
+	"github.com/pingcap/tidb/store/helper"
+	"github.com/pingcap/tidb/store/tikv"
 	"github.com/pingcap/tidb/types"
 	"github.com/pingcap/tidb/util"
+	"github.com/pingcap/tidb/util/pdapi"
+	"github.com/pingcap/tidb/util/set"
 	"github.com/pingcap/tidb/util/sqlexec"
 )
 
@@ -57,6 +62,8 @@ func (e *memtableRetriever) retrieve(ctx context.Context, sctx sessionctx.Contex
 		switch e.table.Name.O {
 		case infoschema.TableSchemata:
 			e.setDataFromSchemata(sctx, dbs)
+		case infoschema.TableStatistics:
+			e.setDataForStatistics(sctx, dbs)
 		case infoschema.TableTables:
 			err = e.dataForTables(sctx, dbs)
 		case infoschema.TablePartitions:
@@ -77,6 +84,10 @@ func (e *memtableRetriever) retrieve(ctx context.Context, sctx sessionctx.Contex
 			e.dataForCollationCharacterSetApplicability()
 		case infoschema.TableUserPrivileges:
 			e.setDataFromUserPrivileges(sctx)
+		case infoschema.TableTiKVRegionPeers:
+			err = e.dataForTikVRegionPeers(sctx)
+		case infoschema.TableTiDBHotRegions:
+			err = e.dataForTiDBHotRegions(sctx)
 		}
 		if err != nil {
 			return nil, err
@@ -270,6 +281,97 @@ func (e *memtableRetriever) setDataFromSchemata(ctx sessionctx.Context, schemas
 	e.rows = rows
 }
 
+func (e *memtableRetriever) setDataForStatistics(ctx sessionctx.Context, schemas []*model.DBInfo) {
+	checker := privilege.GetPrivilegeManager(ctx)
+	var rows [][]types.Datum
+	for _, schema := range schemas {
+		for _, table := range schema.Tables {
+			if checker != nil && !checker.RequestVerification(ctx.GetSessionVars().ActiveRoles, schema.Name.L, table.Name.L, "", mysql.AllPrivMask) {
+				continue
+			}
+
+			rs := dataForStatisticsInTable(schema, table)
+			rows = append(rows, rs...)
+		}
+	}
+	e.rows = rows
+}
+
+func dataForStatisticsInTable(schema *model.DBInfo, table *model.TableInfo) [][]types.Datum {
+	var rows [][]types.Datum
+	if table.PKIsHandle {
+		for _, col := range table.Columns {
+			if mysql.HasPriKeyFlag(col.Flag) {
+				record := types.MakeDatums(
+					infoschema.CatalogVal, // TABLE_CATALOG
+					schema.Name.O,         // TABLE_SCHEMA
+					table.Name.O,          // TABLE_NAME
+					"0",                   // NON_UNIQUE
+					schema.Name.O,         // INDEX_SCHEMA
+					"PRIMARY",             // INDEX_NAME
+					1,                     // SEQ_IN_INDEX
+					col.Name.O,            // COLUMN_NAME
+					"A",                   // COLLATION
+					0,                     // CARDINALITY
+					nil,                   // SUB_PART
+					nil,                   // PACKED
+					"",                    // NULLABLE
+					"BTREE",               // INDEX_TYPE
+					"",                    // COMMENT
+					"NULL",                // Expression
+					"",                    // INDEX_COMMENT
+				)
+				rows = append(rows, record)
+			}
+		}
+	}
+	nameToCol := make(map[string]*model.ColumnInfo, len(table.Columns))
+	for _, c := range table.Columns {
+		nameToCol[c.Name.L] = c
+	}
+	for _, index := range table.Indices {
+		nonUnique := "1"
+		if index.Unique {
+			nonUnique = "0"
+		}
+		for i, key := range index.Columns {
+			col := nameToCol[key.Name.L]
+			nullable := "YES"
+			if mysql.HasNotNullFlag(col.Flag) {
+				nullable = ""
+			}
+			colName := col.Name.O
+			expression := "NULL"
+			tblCol := table.Columns[col.Offset]
+			if tblCol.Hidden {
+				colName = "NULL"
+				expression = fmt.Sprintf("(%s)", tblCol.GeneratedExprString)
+			}
+			record := types.MakeDatums(
+				infoschema.CatalogVal, // TABLE_CATALOG
+				schema.Name.O,         // TABLE_SCHEMA
+				table.Name.O,          // TABLE_NAME
+				nonUnique,             // NON_UNIQUE
+				schema.Name.O,         // INDEX_SCHEMA
+				index.Name.O,          // INDEX_NAME
+				i+1,                   // SEQ_IN_INDEX
+				colName,               // COLUMN_NAME
+				"A",                   // COLLATION
+				0,                     // CARDINALITY
+				nil,                   // SUB_PART
+				nil,                   // PACKED
+				nullable,              // NULLABLE
+				"BTREE",               // INDEX_TYPE
+				"",                    // COMMENT
+				expression,            // Expression
+				"",                    // INDEX_COMMENT
+			)
+			rows = append(rows, record)
+		}
+	}
+	return rows
+}
+
 func (e *memtableRetriever) dataForTables(ctx sessionctx.Context, schemas []*model.DBInfo) error {
 	tableRowsMap, colLengthMap, err := tableStatsCache.get(ctx)
 	if err != nil {
@@ -757,3 +859,124 @@ func keyColumnUsageInTable(schema *model.DBInfo, table *model.TableInfo) [][]typ
 	}
 	return rows
 }
+
+func (e *memtableRetriever) dataForTikVRegionPeers(ctx sessionctx.Context) (err error) {
+	tikvStore, ok := ctx.GetStore().(tikv.Storage)
+	if !ok {
+		return errors.New("Information about TiKV region status can be gotten only when the storage is TiKV")
+	}
+	tikvHelper := &helper.Helper{
+		Store:       tikvStore,
+		RegionCache: tikvStore.GetRegionCache(),
+	}
+	regionsInfo, err := tikvHelper.GetRegionsInfo()
+	if err != nil {
+		return err
+	}
+	var records [][]types.Datum
+	for _, region := range regionsInfo.Regions {
+		rows := newTiKVRegionPeersCols(&region)
+		records = append(records, rows...)
+	}
+	e.rows = records
+	return nil
+}
+
+func newTiKVRegionPeersCols(region *helper.RegionInfo) [][]types.Datum {
+	records := make([][]types.Datum, 0, len(region.Peers))
+	pendingPeerIDSet := set.NewInt64Set()
+	for _, peer := range region.PendingPeers {
+		pendingPeerIDSet.Insert(peer.ID)
+	}
+	downPeerMap := make(map[int64]int64, len(region.DownPeers))
+	for _, peerStat := range region.DownPeers {
+		downPeerMap[peerStat.ID] = peerStat.DownSec
+	}
+	for _, peer := range region.Peers {
+		row := make([]types.Datum, len(infoschema.TableTiKVRegionPeersCols))
+		row[0].SetInt64(region.ID)
+		row[1].SetInt64(peer.ID)
+		row[2].SetInt64(peer.StoreID)
+		if peer.IsLearner {
+			row[3].SetInt64(1)
+		} else {
+			row[3].SetInt64(0)
+		}
+		if peer.ID == region.Leader.ID {
+			row[4].SetInt64(1)
+		} else {
+			row[4].SetInt64(0)
+		}
+		if pendingPeerIDSet.Exist(peer.ID) {
+			row[5].SetString(pendingPeer, mysql.DefaultCollationName)
+		} else if downSec, ok := downPeerMap[peer.ID]; ok {
+			row[5].SetString(downPeer, mysql.DefaultCollationName)
+			row[6].SetInt64(downSec)
+		} else {
+			row[5].SetString(normalPeer, mysql.DefaultCollationName)
+		}
+		records = append(records, row)
+	}
+	return records
+}
+
+const (
+	normalPeer  = "NORMAL"
+	pendingPeer = "PENDING"
+	downPeer    = "DOWN"
+)
+
+func (e *memtableRetriever) dataForTiDBHotRegions(ctx sessionctx.Context) (err error) {
+	tikvStore, ok := ctx.GetStore().(tikv.Storage)
+	if !ok {
+		return errors.New("Information about hot region can be gotten only when the storage is TiKV")
+	}
+	allSchemas := ctx.GetSessionVars().TxnCtx.InfoSchema.(infoschema.InfoSchema).AllSchemas()
+	tikvHelper := &helper.Helper{
+		Store:       tikvStore,
+		RegionCache: tikvStore.GetRegionCache(),
+	}
+	metrics, err := tikvHelper.ScrapeHotInfo(pdapi.HotRead, allSchemas)
+	if err != nil {
+		return err
+	}
+	var records [][]types.Datum
+	records = append(records, dataForHotRegionByMetrics(metrics, "read")...)
+	metrics, err = tikvHelper.ScrapeHotInfo(pdapi.HotWrite, allSchemas)
+	if err != nil {
+		return err
+	}
+	records = append(records, dataForHotRegionByMetrics(metrics, "write")...)
+
+	e.rows = records
+	return nil
+}
+
+func dataForHotRegionByMetrics(metrics []helper.HotTableIndex, tp string) [][]types.Datum {
+	rows := make([][]types.Datum, 0, len(metrics))
+	for _, tblIndex := range metrics {
+		row := make([]types.Datum, len(infoschema.TableTiDBHotRegionsCols))
+		if tblIndex.IndexName != "" {
+			row[1].SetInt64(tblIndex.IndexID)
+			row[4].SetString(tblIndex.IndexName, mysql.DefaultCollationName)
+		} else {
+			row[1].SetNull()
+			row[4].SetNull()
+		}
+		row[0].SetInt64(tblIndex.TableID)
+		row[2].SetString(tblIndex.DbName, mysql.DefaultCollationName)
+		row[3].SetString(tblIndex.TableName, mysql.DefaultCollationName)
+		row[5].SetUint64(tblIndex.RegionID)
+		row[6].SetString(tp, mysql.DefaultCollationName)
+		if tblIndex.RegionMetric == nil {
+			row[7].SetNull()
+			row[8].SetNull()
+		} else {
+			row[7].SetInt64(int64(tblIndex.RegionMetric.MaxHotDegree))
+			row[8].SetInt64(int64(tblIndex.RegionMetric.Count))
+		}
+		row[9].SetUint64(tblIndex.RegionMetric.FlowBytes)
+		rows = append(rows, row)
+	}
+	return rows
+}