types: cache pathExpression to improve the JSON function performance

config/const.go

@@ -16,6 +16,3 @@ package config
 
 // DefRowsForSampleRate is default sample rows used to calculate samplerate.
 const DefRowsForSampleRate = 110000
-
-// TrackMemWhenExceeds is the threshold when memory usage needs to be tracked.
-const TrackMemWhenExceeds = 104857600 // 100MB

types/json/path_expr.go

@@ -15,11 +15,15 @@
 package json
 
 import (
+	"math"
 	"regexp"
 	"strconv"
 	"strings"
+	"sync"
 
 	"github.com/pingcap/errors"
+	"github.com/pingcap/tidb/util/hack"
+	"github.com/pingcap/tidb/util/kvcache"
 )
 
 /*
@@ -92,6 +96,20 @@ type PathExpression struct {
 	flags pathExpressionFlag
 }
 
+var peCache PathExpressionCache
+
+type pathExpressionKey string
+
+func (key pathExpressionKey) Hash() []byte {
+	return hack.Slice(string(key))
+}
+
+// PathExpressionCache is a cache for PathExpression.
+type PathExpressionCache struct {
+	mu    sync.Mutex
+	cache *kvcache.SimpleLRUCache
+}
+
 // popOneLeg returns a pathLeg, and a child PathExpression without that leg.
 func (pe PathExpression) popOneLeg() (pathLeg, PathExpression) {
 	newPe := PathExpression{
@@ -150,6 +168,22 @@ func (pe PathExpression) ContainsAnyAsterisk() bool {
 // ParseJSONPathExpr parses a JSON path expression. Returns a PathExpression
 // object which can be used in JSON_EXTRACT, JSON_SET and so on.
 func ParseJSONPathExpr(pathExpr string) (pe PathExpression, err error) {
+	peCache.mu.Lock()
+	val, ok := peCache.cache.Get(pathExpressionKey(pathExpr))
+	if ok {
+		peCache.mu.Unlock()
+		return val.(PathExpression), nil
+	}
+	peCache.mu.Unlock()
+
+	defer func() {
+		if err == nil {
+			peCache.mu.Lock()
+			peCache.cache.Put(pathExpressionKey(pathExpr), kvcache.Value(pe))
+			peCache.mu.Unlock()
+		}
+	}()
+
 	// Find the position of first '$'. If any no-blank characters in
 	// pathExpr[0: dollarIndex), return an ErrInvalidJSONPath error.
 	dollarIndex := strings.Index(pathExpr, "$")
@@ -261,3 +295,7 @@ func (pe PathExpression) String() string {
 	}
 	return s.String()
 }
+
+func init() {
+	peCache.cache = kvcache.NewSimpleLRUCache(1000, 0.1, math.MaxUint64)
+}

util/memory/tracker.go

@@ -22,11 +22,13 @@ import (
 	"sync"
 	"sync/atomic"
 
-	"github.com/pingcap/tidb/config"
 	"github.com/pingcap/tidb/metrics"
 	atomicutil "go.uber.org/atomic"
 )
 
+// TrackMemWhenExceeds is the threshold when memory usage needs to be tracked.
+const TrackMemWhenExceeds = 104857600 // 100MB
+
 // Tracker is used to track the memory usage during query execution.
 // It contains an optional limit and can be arranged into a tree structure
 // such that the consumption tracked by a Tracker is also tracked by
@@ -388,7 +390,7 @@ func (t *Tracker) Consume(bytes int64) {
 // BufferedConsume is used to buffer memory usage and do late consume
 func (t *Tracker) BufferedConsume(bufferedMemSize *int64, bytes int64) {
 	*bufferedMemSize += bytes
-	if *bufferedMemSize > int64(config.TrackMemWhenExceeds) {
+	if *bufferedMemSize > int64(TrackMemWhenExceeds) {
 		t.Consume(*bufferedMemSize)
 		*bufferedMemSize = int64(0)
 	}