update

r/example.result

@@ -3,3 +3,11 @@ insert into t values(1, 1), (2, 2), (3, 3), (4, 4), (5, 5);
 select * from t where a = 1;
 a	b
 1	1
+explain analyze format='brief' select * from t;
+id	estRows	actRows	task	access object	execution info	operator info	memory	disk
+TableReader	10000.00	5	root	NULL	time:<num>, loops:<num>, RU:<num>, cop_task: {num:<num>, max:<num>, proc_keys:<num>, rpc_num:<num>, rpc_time:<num>, copr_cache_hit_ratio:<num>, build_task_duration:<num>, max_distsql_concurrency:<num>}	data:TableFullScan	<num> Bytes	N/A
+└─TableFullScan	10000.00	5	cop[tikv]	table:t	tikv_task:{time:<num>, loops:<num>}	keep order:false, stats:pseudo	N/A	N/A
+explain analyze select * from t;
+id	estRows	actRows	task	access object	execution info	operator info	memory	disk
+TableReader_5	10000.00	5	root	NULL	time:<num>, loops:<num>, RU:<num>, cop_task: {num:<num>, max:<num>, proc_keys:<num>, rpc_num:<num>, rpc_time:<num>, copr_cache_hit_ratio:<num>, build_task_duration:<num>, max_distsql_concurrency:<num>}	data:TableFullScan_4	<num> Bytes	N/A
+└─TableFullScan_4	10000.00	5	cop[tikv]	table:t	tikv_task:{time:<num>, loops:<num>}	keep order:false, stats:pseudo	N/A	N/A

src/main.go

@@ -438,14 +438,11 @@ func (t *tester) Run() error {
 			}
 		case Q_REPLACE_REGEX:
 			t.replaceRegex = nil
-			originalStrings := strings.Fields(q.Query)
-			for _, originalString := range originalStrings {
-				regex, err := ParseReplaceRegex(strings.TrimSpace(originalString))
-				if err != nil {
-					return errors.Annotate(err, fmt.Sprintf("Could not parse regex in --replace_regex: sql:%v", q.Query))
-				}
-				t.replaceRegex = append(t.replaceRegex, regex)
+			regex, err := ParseReplaceRegex(q.Query)
+			if err != nil {
+				return errors.Annotate(err, fmt.Sprintf("Could not parse regex in --replace_regex: sql:%v", q.Query))
 			}
+			t.replaceRegex = regex
 		default:
 			log.WithFields(log.Fields{"command": q.firstWord, "arguments": q.Query, "line": q.Line}).Warn("command not implemented")
 		}

src/util.go

@@ -16,7 +16,6 @@ package main
 import (
 	"database/sql"
 	"regexp"
-	"strings"
 	"time"
 
 	"github.com/pingcap/errors"
@@ -52,32 +51,36 @@ func OpenDBWithRetry(driverName, dataSourceName string, retryCount int) (mdb *sq
 	return
 }
 
-func ParseReplaceRegex(originalString string) (*ReplaceRegex, error) {
-	if len(originalString) == 0 || originalString[0] != '/' || originalString[len(originalString)-1] != '/' {
-		return nil, errors.Errorf("Can not parse regex %s", originalString)
-	}
-	idx := 1
-	var regexpStr, replaceStr string
-	for {
-		tmp := strings.Index(originalString[idx:], "/")
-		if tmp == -1 {
-			return nil, errors.Errorf("Can not parse regex %s", originalString)
+func ParseReplaceRegex(originalString string) ([]*ReplaceRegex, error) {
+	var begin, middle, end, cnt int
+	ret := make([]*ReplaceRegex, 0)
+	for i, c := range originalString {
+		if c != '/' {
+			continue
 		}
-		idx += tmp
-		if originalString[idx-1] != '\\' {
-			regexpStr = originalString[1:idx]
-			replaceStr = originalString[idx+1 : len(originalString)-1]
-			break
-		} else {
-			idx += 1
+		if i != 0 && originalString[i-1] == '\\' {
+			continue
+		}
+		cnt++
+		switch cnt % 3 {
+		case 1:
+			begin = i
+		case 2:
+			middle = i
+		case 0:
+			end = i
+			reg, err := regexp.Compile(originalString[begin+1 : middle])
+			if err != nil {
+				return nil, err
+			}
+			ret = append(ret, &ReplaceRegex{
+				regex:   reg,
+				replace: originalString[middle+1 : end],
+			})
 		}
 	}
-	reg, err := regexp.Compile(regexpStr)
-	if err != nil {
-		return nil, err
+	if cnt%3 != 0 {
+		return nil, errors.Errorf("Could not parse regex in --replace_regex: sql:%v", originalString)
 	}
-	return &ReplaceRegex{
-		regex:   reg,
-		replace: replaceStr,
-	}, nil
+	return ret, nil
 }

src/util_test.go

@@ -56,12 +56,14 @@ func TestParseReplaceRegex(t *testing.T) {
 			input:     "Some infos [conn=xxx]",
 			output:    "Some infos [conn=xxx]",
 		},
+		/* TODO: support replaced with '\t', '\n', '\/' etc
 		{
 			succ:      true,
-			regexpStr: `/\/a//b//`,
-			input:     "/a",
-			output:    "/b/",
+			regexpStr: `/a/\/b/`,
+			input:     "a",
+			output:    "/b",
 		},
+		*/
 		{
 			succ:      false,
 			regexpStr: `/conn=[0-9]+/conn=<num>`,
@@ -89,14 +91,18 @@ func TestParseReplaceRegex(t *testing.T) {
 	}
 
 	for _, testCase := range testCases {
-		reg, err := ParseReplaceRegex(testCase.regexpStr)
+		regexs, err := ParseReplaceRegex(testCase.regexpStr)
 		if !testCase.succ {
 			require.NotNil(t, err)
 			continue
 		}
 		require.Nil(t, err)
-		require.NotNil(t, reg)
+		require.NotNil(t, regexs)
 
-		require.Equal(t, testCase.output, reg.regex.ReplaceAllString(testCase.input, reg.replace))
+		result := testCase.input
+		for _, reg := range regexs {
+			result = reg.regex.ReplaceAllString(result, reg.replace)
+		}
+		require.Equal(t, testCase.output, result)
 	}
 }

t/example.test

@@ -1,3 +1,9 @@
 create table t(a bigint, b bigint);
 insert into t values(1, 1), (2, 2), (3, 3), (4, 4), (5, 5);
 select * from t where a = 1;
+
+--replace_regex /:[ ]?[.0-9]+.*?,/:<num>,/ /:[ ]?[.0-9]+.*?}/:<num>}/ /[0-9]+ Bytes/<num> Bytes/
+explain analyze format='brief' select * from t;
+
+--replace_regex /:[ ]?[.0-9]+.*?,/:<num>,/ /:[ ]?[.0-9]+.*?}/:<num>}/ /[0-9]+ Bytes/<num> Bytes/
+explain analyze select * from t;