server, tablecodec: show region key's record id or index values. (pin…

…gcap#6030)

server/http_handler.go

@@ -445,12 +445,14 @@ func (rt *RegionDetail) addTableInRange(dbName string, curTable *model.TableInfo
 
 // FrameItem includes a index's or record's meta data with table's info.
 type FrameItem struct {
-	DBName    string `json:"db_name"`
-	TableName string `json:"table_name"`
-	TableID   int64  `json:"table_id"`
-	IsRecord  bool   `json:"is_record"`
-	IndexName string `json:"index_name,omitempty"`
-	IndexID   int64  `json:"index_id,omitempty"`
+	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"`
 }
 
 // RegionFrameRange contains a frame range info which the region covered.
@@ -744,6 +746,14 @@ func NewFrameItemFromRegionKey(key []byte) (frame *FrameItem, err error) {
 	frame = &FrameItem{}
 	frame.TableID, frame.IndexID, frame.IsRecord, err = tablecodec.DecodeKeyHead(key)
 	if err == nil {
+		if frame.IsRecord {
+			_, frame.RecordID, err = tablecodec.DecodeRecordKey(key)
+		} else {
+			_, _, frame.IndexValues, err = tablecodec.DecodeIndexKey(key)
+		}
+		log.Warnf("decode region key %q fail: %v", key, err)
+		// Ignore decode errors.
+		err = nil
 		return
 	}
 	if bytes.HasPrefix(key, tablecodec.TablePrefix()) {
@@ -817,9 +827,11 @@ func NewRegionFrameRange(region *tikv.KeyLocation) (idxRange *RegionFrameRange,
 // are not covered by this frame range, it returns nil.
 func (r *RegionFrameRange) getRecordFrame(tableID int64, dbName, tableName string) *FrameItem {
 	if tableID == r.first.TableID && r.first.IsRecord {
+		r.first.DBName, r.first.TableName = dbName, tableName
 		return r.first
 	}
 	if tableID == r.last.TableID && r.last.IsRecord {
+		r.last.DBName, r.last.TableName = dbName, tableName
 		return r.last
 	}
 
@@ -836,11 +848,13 @@ func (r *RegionFrameRange) getRecordFrame(tableID int64, dbName, tableName strin
 
 // getIndexFrame returns the indnex frame of a table. If the table's indices are
 // not covered by this frame range, it returns nil.
-func (r *RegionFrameRange) getIndexFrame(tableID, indexID int64, dbName, tableName, indexname string) *FrameItem {
+func (r *RegionFrameRange) getIndexFrame(tableID, indexID int64, dbName, tableName, indexName string) *FrameItem {
 	if tableID == r.first.TableID && !r.first.IsRecord && indexID == r.first.IndexID {
+		r.first.DBName, r.first.TableName, r.first.IndexName = dbName, tableName, indexName
 		return r.first
 	}
 	if tableID == r.last.TableID && indexID == r.last.IndexID {
+		r.last.DBName, r.last.TableName, r.last.IndexName = dbName, tableName, indexName
 		return r.last
 	}
 
@@ -852,7 +866,7 @@ func (r *RegionFrameRange) getIndexFrame(tableID, indexID int64, dbName, tableNa
 			TableName: tableName,
 			TableID:   tableID,
 			IsRecord:  false,
-			IndexName: indexname,
+			IndexName: indexName,
 			IndexID:   indexID,
 		}
 	}

server/http_handler_test.go

@@ -50,9 +50,22 @@ func (ts *HTTPHandlerTestSuite) TestRegionIndexRange(c *C) {
 	sTableID := int64(3)
 	sIndex := int64(11)
 	eTableID := int64(9)
+	recordID := int64(133)
+	indexValues := []types.Datum{
+		types.NewIntDatum(100),
+		types.NewBytesDatum([]byte("foobar")),
+		types.NewFloat64Datum(-100.25),
+	}
+	var expectIndexValues []string
+	for _, v := range indexValues {
+		expectIndexValues = append(expectIndexValues, fmt.Sprintf("%d-%v", v.Kind(), v.GetValue()))
+	}
+	encodedValue, err := codec.EncodeKey(&stmtctx.StatementContext{TimeZone: time.Local}, nil, indexValues...)
+	c.Assert(err, IsNil)
 
-	startKey := tablecodec.EncodeTableIndexPrefix(sTableID, sIndex)
-	endKey := tablecodec.GenTableRecordPrefix(eTableID)
+	startKey := tablecodec.EncodeIndexSeekKey(sTableID, sIndex, encodedValue)
+	recordPrefix := tablecodec.GenTableRecordPrefix(eTableID)
+	endKey := tablecodec.EncodeRecordKey(recordPrefix, recordID)
 
 	region := &tikv.KeyLocation{
 		Region:   tikv.RegionVerID{},
@@ -63,7 +76,11 @@ func (ts *HTTPHandlerTestSuite) TestRegionIndexRange(c *C) {
 	c.Assert(err, IsNil)
 	c.Assert(r.first.IndexID, Equals, sIndex)
 	c.Assert(r.first.IsRecord, IsFalse)
+	c.Assert(r.first.RecordID, Equals, int64(0))
+	c.Assert(r.first.IndexValues, DeepEquals, expectIndexValues)
 	c.Assert(r.last.IsRecord, IsTrue)
+	c.Assert(r.last.RecordID, Equals, recordID)
+	c.Assert(r.last.IndexValues, IsNil)
 
 	testCases := []struct {
 		tableID int64

tablecodec/tablecodec.go

@@ -16,6 +16,7 @@ package tablecodec
 import (
 	"bytes"
 	"encoding/binary"
+	"fmt"
 	"math"
 	"time"
 
@@ -31,6 +32,7 @@ import (
 var (
 	errInvalidKey         = terror.ClassXEval.New(codeInvalidKey, "invalid key")
 	errInvalidRecordKey   = terror.ClassXEval.New(codeInvalidRecordKey, "invalid record key")
+	errInvalidIndexKey    = terror.ClassXEval.New(codeInvalidIndexKey, "invalid index key")
 	errInvalidColumnCount = terror.ClassXEval.New(codeInvalidColumnCount, "invalid column count")
 )
 
@@ -109,6 +111,32 @@ func DecodeRecordKey(key kv.Key) (tableID int64, handle int64, err error) {
 	return
 }
 
+// DecodeIndexKey decodes the key and gets the tableID, indexID, indexValues.
+func DecodeIndexKey(key kv.Key) (tableID int64, indexID int64, indexValues []string, err error) {
+	k := key
+
+	tableID, indexID, isRecord, err := DecodeKeyHead(key)
+	if err != nil {
+		return 0, 0, nil, errors.Trace(err)
+	}
+	if isRecord {
+		return 0, 0, nil, errInvalidIndexKey.Gen("invalid index key - %q", k)
+	}
+	key = key[prefixLen+idLen:]
+
+	for len(key) > 0 {
+		// FIXME: Without the schema information, we can only decode the raw kind of
+		// the column. For instance, MysqlTime is internally saved as uint64.
+		remain, d, e := codec.DecodeOne(key)
+		if e != nil {
+			return 0, 0, nil, errInvalidIndexKey.Gen("invalid index key - %q %v", k, e)
+		}
+		indexValues = append(indexValues, fmt.Sprintf("%d-%v", d.Kind(), d.GetValue()))
+		key = remain
+	}
+	return
+}
+
 // DecodeKeyHead decodes the key's head and gets the tableID, indexID. isRecordKey is true when is a record key.
 func DecodeKeyHead(key kv.Key) (tableID int64, indexID int64, isRecordKey bool, err error) {
 	isRecordKey = false
@@ -566,4 +594,5 @@ const (
 	codeInvalidRecordKey   = 4
 	codeInvalidColumnCount = 5
 	codeInvalidKey         = 6
+	codeInvalidIndexKey    = 7
 )

tablecodec/tablecodec_test.go

@@ -14,6 +14,7 @@
 package tablecodec
 
 import (
+	"fmt"
 	"math"
 	"testing"
 	"time"
@@ -323,3 +324,33 @@ func (s *testTableCodecSuite) TestReplaceRecordKeyTableID(c *C) {
 	c.Assert(err, IsNil)
 	c.Assert(tTableID, Equals, tableID)
 }
+
+func (s *testTableCodecSuite) TestDecodeIndexKey(c *C) {
+	tableID := int64(4)
+	indexID := int64(5)
+	values := []types.Datum{
+		types.NewIntDatum(1),
+		types.NewBytesDatum([]byte("abc")),
+		types.NewFloat64Datum(123.45),
+		// MysqlTime is not supported.
+		// types.NewTimeDatum(types.Time{
+		// 	Time: types.FromGoTime(time.Now()),
+		// 	Fsp:  6,
+		// 	Type: mysql.TypeTimestamp,
+		// }),
+	}
+	var valueStrs []string
+	for _, v := range values {
+		valueStrs = append(valueStrs, fmt.Sprintf("%d-%v", v.Kind(), v.GetValue()))
+	}
+	sc := &stmtctx.StatementContext{TimeZone: time.Local}
+	encodedValue, err := codec.EncodeKey(sc, nil, values...)
+	c.Assert(err, IsNil)
+	indexKey := EncodeIndexSeekKey(tableID, indexID, encodedValue)
+
+	decodeTableID, decodeIndexID, decodeValues, err := DecodeIndexKey(indexKey)
+	c.Assert(err, IsNil)
+	c.Assert(decodeTableID, Equals, tableID)
+	c.Assert(decodeIndexID, Equals, indexID)
+	c.Assert(decodeValues, DeepEquals, valueStrs)
+}