diff --git a/Makefile b/Makefile
index cb0a4dd9c191fb313a189f6c5e65c0c18eba6498..96d2f63173eb8d81a45ec6a095625f51068f9a19 100644
--- a/Makefile
+++ b/Makefile
@@ -134,13 +134,13 @@ vendor: vitess tidb
 .PHONY: tidb-parser
 tidb-parser: tidb
 	@echo "\033[92mimporting tidb sql parser ...\033[0m"
-	@cd ${GOPATH}/src/github.com/pingcap/tidb && git checkout ec9672cea6612481b1da845dbab620b7a5581ca4  && make parser
+	@cd ${GOPATH}/src/github.com/pingcap/tidb && git checkout --quiet ec9672cea6612481b1da845dbab620b7a5581ca4  && make parser
 
 # gometalinter
 # 如果有不想改的lint问题可以使用metalinter.sh加黑名单
 #@bash doc/example/metalinter.sh
 .PHONY: lint
-lint: build
+lint: fast
 	@echo "\033[92mRun linter check ...\033[0m"
 	CGO_ENABLED=0 retool do gometalinter.v2 -j 1 --config doc/example/metalinter.json ./...
 	retool do revive -formatter friendly --exclude vendor/... -config doc/example/revive.toml ./...
@@ -196,6 +196,11 @@ main_test: install
 daily: | deps fmt vendor tidb-parser docker cover doc lint release install main_test clean logo
 	@echo "\033[92mdaily build finished\033[0m"
 
+# vendor, tidb-parser, docker will cost long time, if all those are ready, daily-quick will much more fast.
+.PHONY: daily-quick
+daily-quick: | deps fmt cover doc lint logo
+	@echo "\033[92mdaily-quick build finished\033[0m"
+
 .PHONY: logo
 logo:
 	@echo "\033[93m"
diff --git a/advisor/heuristic.go b/advisor/heuristic.go
index baf27ce9e9b1b2a4bda9b86332ac186bde1b6763..c9f6f8321afeb92fdffa43f11888643efad6ed0b 100644
--- a/advisor/heuristic.go
+++ b/advisor/heuristic.go
@@ -2181,9 +2181,40 @@ func (q *Query4Audit) RuleDataDrop() Rule {
 func (q *Query4Audit) RuleCompareWithFunction() Rule {
 	var rule = q.RuleOK()
 	err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
+		// Vitess 中有些函数进行了单独定义不在 FuncExpr 中，如: substring。所以不能直接用 FuncExpr 判断。
 		switch n := node.(type) {
 		case *sqlparser.ComparisonExpr:
-			if strings.HasSuffix(sqlparser.String(n.Left), ")") {
+			switch n.Left.(type) {
+			case *sqlparser.SQLVal, *sqlparser.ColName:
+			default:
+				rule = HeuristicRules["FUN.001"]
+				return false, nil
+			}
+			/*
+				// func always has bracket
+				if strings.HasSuffix(sqlparser.String(n.Left), ")") {
+					rule = HeuristicRules["FUN.001"]
+					return false, nil
+				}
+			*/
+
+		// func(a) between func(c) and func(d)
+		case *sqlparser.RangeCond:
+			switch n.Left.(type) {
+			case *sqlparser.SQLVal, *sqlparser.ColName:
+			default:
+				rule = HeuristicRules["FUN.001"]
+				return false, nil
+			}
+			switch n.From.(type) {
+			case *sqlparser.SQLVal, *sqlparser.ColName:
+			default:
+				rule = HeuristicRules["FUN.001"]
+				return false, nil
+			}
+			switch n.To.(type) {
+			case *sqlparser.SQLVal, *sqlparser.ColName:
+			default:
 				rule = HeuristicRules["FUN.001"]
 				return false, nil
 			}
diff --git a/advisor/heuristic_test.go b/advisor/heuristic_test.go
index 2ebcf399f25d7c5be85bf9b48be91330e4ce8093..ef4f8503aa7c23d95539c003a9bd80e816f0d114 100644
--- a/advisor/heuristic_test.go
+++ b/advisor/heuristic_test.go
@@ -679,7 +679,7 @@ func TestRuleNoDeterministicGroupby(t *testing.T) {
 func TestRuleNoDeterministicLimit(t *testing.T) {
 	common.Log.Debug("Entering function: %s", common.GetFunctionName())
 	sqls := []string{
-		"select col1,col2 from tbl where name='zhangsan' limit 10",
+		"select col1,col2 from tbl where name='tony' limit 10",
 	}
 	for _, sql := range sqls {
 		q, err := NewQuery4Audit(sql)
@@ -1194,7 +1194,7 @@ func TestRuleImpreciseDataType(t *testing.T) {
 			`select * from tb where col = 0.00001;`,
 		},
 		{
-			"REPLACE INTO `binks3` (`hostname`,`storagehost`, `filename`, `starttime`, `binlogstarttime`, `uploadname`, `binlogsize`, `filesize`, `md5`, `status`) VALUES (1, 1, 1, 1, 1, 1, ?, ?);",
+			"REPLACE INTO `storage` (`hostname`,`storagehost`, `filename`, `starttime`, `binlogstarttime`, `uploadname`, `binlogsize`, `filesize`, `md5`, `status`) VALUES (1, 1, 1, 1, 1, 1, ?, ?);",
 		},
 	}
 	for _, sql := range sqls[0] {
@@ -1249,8 +1249,8 @@ func TestRuleValuesInDefinition(t *testing.T) {
 func TestRuleIndexAttributeOrder(t *testing.T) {
 	common.Log.Debug("Entering function: %s", common.GetFunctionName())
 	sqls := []string{
-		`create index idx1 on tabl(last_name,first_name);`,
-		`alter table tabl add index idx1 (last_name,first_name);`,
+		`create index idx1 on tab(last_name,first_name);`,
+		`alter table tab add index idx1 (last_name,first_name);`,
 		`CREATE TABLE test (id int,blob_col BLOB, INDEX(blob_col(10),id));`,
 	}
 	for _, sql := range sqls {
@@ -1271,7 +1271,7 @@ func TestRuleIndexAttributeOrder(t *testing.T) {
 func TestRuleNullUsage(t *testing.T) {
 	common.Log.Debug("Entering function: %s", common.GetFunctionName())
 	sqls := []string{
-		`select c1,c2,c3 from tabl where c4 is null or c4 <> 1;`,
+		`select c1,c2,c3 from tab where c4 is null or c4 <> 1;`,
 	}
 	for _, sql := range sqls {
 		q, err := NewQuery4Audit(sql)
@@ -1291,7 +1291,7 @@ func TestRuleNullUsage(t *testing.T) {
 func TestRuleStringConcatenation(t *testing.T) {
 	common.Log.Debug("Entering function: %s", common.GetFunctionName())
 	sqls := []string{
-		`select c1 || coalesce(' ' || c2 || ' ', ' ') || c3 as c from tabl;`,
+		`select c1 || coalesce(' ' || c2 || ' ', ' ') || c3 as c from tab;`,
 	}
 	for _, sql := range sqls {
 		q, err := NewQuery4Audit(sql)
@@ -1609,7 +1609,7 @@ func TestRuleForbiddenSyntax(t *testing.T) {
 func TestRuleNestedSubQueries(t *testing.T) {
 	common.Log.Debug("Entering function: %s", common.GetFunctionName())
 	sqls := []string{
-		`SELECT s,p,d FROM tabl WHERE p.p_id = (SELECT s.p_id FROM tabl WHERE s.c_id = 100996 AND s.q = 1 );`,
+		`SELECT s,p,d FROM tab WHERE p.p_id = (SELECT s.p_id FROM tab WHERE s.c_id = 100996 AND s.q = 1 );`,
 	}
 	for _, sql := range sqls {
 		q, err := NewQuery4Audit(sql)
@@ -1672,7 +1672,7 @@ func TestRuleMultiDBJoin(t *testing.T) {
 func TestRuleORUsage(t *testing.T) {
 	common.Log.Debug("Entering function: %s", common.GetFunctionName())
 	sqls := []string{
-		`SELECT c1,c2,c3 FROM tabl WHERE c1 = 14 OR c2 = 17;`,
+		`SELECT c1,c2,c3 FROM tab WHERE c1 = 14 OR c2 = 17;`,
 	}
 	for _, sql := range sqls {
 		q, err := NewQuery4Audit(sql)
@@ -1969,9 +1969,15 @@ func TestRuleDataDrop(t *testing.T) {
 func TestCompareWithFunction(t *testing.T) {
 	common.Log.Debug("Entering function: %s", common.GetFunctionName())
 	sqls := [][]string{
-		{`select id from t where substring(name,1,3)='abc';`},
+		{
+			`select id from t where substring(name,1,3)='abc';`,
+			`SELECT * FROM tbl WHERE UNIX_TIMESTAMP(loginTime) BETWEEN UNIX_TIMESTAMP('2018-11-16 09:46:00 +0800 CST') AND UNIX_TIMESTAMP('2018-11-22 00:00:00 +0800 CST')`,
+		},
 		// TODO: 右侧使用函数比较
-		{`select id from t where 'abc'=substring(name,1,3);`},
+		{
+			`select id from t where 'abc'=substring(name,1,3);`,
+			`select id from t where col = (select 1)`,
+		},
 	}
 	for _, sql := range sqls[0] {
 		q, err := NewQuery4Audit(sql)
@@ -2062,7 +2068,7 @@ func TestRuleIn(t *testing.T) {
 }
 
 // ARG.006
-func TestRuleisNullIsNotNull(t *testing.T) {
+func TestRuleIsNullIsNotNull(t *testing.T) {
 	common.Log.Debug("Entering function: %s", common.GetFunctionName())
 	sqls := []string{
 		`select id from t where num is null;`,
@@ -2249,10 +2255,10 @@ func TestRuleAlterDropKey(t *testing.T) {
 func TestRuleCantBeNull(t *testing.T) {
 	common.Log.Debug("Entering function: %s", common.GetFunctionName())
 	sqls := []string{
-		"CREATE TABLE `sbtest` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `c` longblob, PRIMARY KEY (`id`));",
-		"alter TABLE `sbtest` add column `c` longblob;",
-		"alter TABLE `sbtest` add column `c` text;",
-		"alter TABLE `sbtest` add column `c` blob;",
+		"CREATE TABLE `tbl` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `c` longblob, PRIMARY KEY (`id`));",
+		"alter TABLE `tbl` add column `c` longblob;",
+		"alter TABLE `tbl` add column `c` text;",
+		"alter TABLE `tbl` add column `c` blob;",
 	}
 	for _, sql := range sqls {
 		q, err := NewQuery4Audit(sql)
diff --git a/advisor/rules.go b/advisor/rules.go
index c1ff9b9c0ab9ea73f97db365d6e4606d931ec9b6..eda36777ab36a69fcf2992477dce580b7ce161f7 100644
--- a/advisor/rules.go
+++ b/advisor/rules.go
@@ -212,7 +212,7 @@ func init() {
 			Item:     "ARG.005",
 			Severity: "L1",
 			Summary:  "IN要慎用，元素过多会导致全表扫描",
-			Content:  ` 如：select id from t where num in(1,2,3)对于连续的数值，能用BETWEEN就不要用IN了：select id from t where num between 1 and 3。而当IN值过多时MySQL也可能会进入全表扫描导致性能急剧下降。`,
+			Content:  ` 如：select id from t where num in(1,2,3)对于连续的数值，能用 BETWEEN 就不要用 IN 了：select id from t where num between 1 and 3。而当IN值过多时MySQL也可能会进入全表扫描导致性能急剧下降。`,
 			Case:     "select id from t where num in(1,2,3)",
 			Func:     (*Query4Audit).RuleIn,
 		},
@@ -228,14 +228,14 @@ func init() {
 			Item:     "ARG.007",
 			Severity: "L3",
 			Summary:  "避免使用模式匹配",
-			Content:  `性能问题是使用模式匹配操作符的最大缺点。使用LIKE或正则表达式进行模式匹配进行查询的另一个问题，是可能会返回意料之外的结果。最好的方案就是使用特殊的搜索引擎技术来替代SQL，比如Apache Lucene。另一个可选方案是将结果保存起来从而减少重复的搜索开销。如果一定要使用SQL，请考虑在MySQL中使用像FULLTEXT索引这样的第三方扩展。但更广泛地说，您不一定要使用SQL来解决所有问题。`,
+			Content:  `性能问题是使用模式匹配操作符的最大缺点。使用LIKE或正则表达式进行模式匹配进行查询的另一个问题，是可能会返回意料之外的结果。最好的方案就是使用特殊的搜索引擎技术来替代SQL，比如 Apache Lucene。另一个可选方案是将结果保存起来从而减少重复的搜索开销。如果一定要使用SQL，请考虑在 MySQL 中使用像 FULLTEXT 索引这样的第三方扩展。但更广泛地说，您不一定要使用SQL来解决所有问题。`,
 			Case:     "select c_id,c2,c3 from tbl where c2 like 'test%'",
 			Func:     (*Query4Audit).RulePatternMatchingUsage,
 		},
 		"ARG.008": {
 			Item:     "ARG.008",
 			Severity: "L1",
-			Summary:  "OR查询索引列时请尽量使用IN谓词",
+			Summary:  "OR 查询索引列时请尽量使用 IN 谓词",
 			Content:  `IN-list谓词可以用于索引检索，并且优化器可以对IN-list进行排序，以匹配索引的排序序列，从而获得更有效的检索。请注意，IN-list必须只包含常量，或在查询块执行期间保持常量的值，例如外引用。`,
 			Case:     "SELECT c1,c2,c3 FROM tbl WHERE c1 = 14 OR c1 = 17",
 			Func:     (*Query4Audit).RuleORUsage,
@@ -244,7 +244,7 @@ func init() {
 			Item:     "ARG.009",
 			Severity: "L1",
 			Summary:  "引号中的字符串开头或结尾包含空格",
-			Content:  `如果VARCHAR列的前后存在空格将可能引起逻辑问题，如在MySQL 5.5中'a'和'a '可能会在查询中被认为是相同的值。`,
+			Content:  `如果VARCHAR列的前后存在空格将可能引起逻辑问题，如在MySQL 5.5中 'a' 和 'a ' 可能会在查询中被认为是相同的值。`,
 			Case:     "SELECT 'abc '",
 			Func:     (*Query4Audit).RuleSpaceWithQuote,
 		},
@@ -252,7 +252,7 @@ func init() {
 			Item:     "ARG.010",
 			Severity: "L1",
 			Summary:  "不要使用hint，如sql_no_cache, force index, ignore key, straight join等",
-			Content:  `hint是用来强制SQL按照某个执行计划来执行，但随着数据量变化我们无法保证自己当初的预判是正确的。`,
+			Content:  `hint 是用来强制 SQL 按照某个执行计划来执行，但随着数据量变化我们无法保证自己当初的预判是正确的。`,
 			Case:     "SELECT * FROM t1 USE INDEX (i1) ORDER BY a;",
 			Func:     (*Query4Audit).RuleHint,
 		},
@@ -569,28 +569,28 @@ func init() {
 			Case:     "SELECT COUNT(DISTINCT col, col2) FROM tbl;",
 			Func:     (*Query4Audit).RuleCountDistinctMultiCol,
 		},
-		// DIS.003灵感来源于如下链接
+		// DIS.003 灵感来源于如下链接
 		// http://www.ijstr.org/final-print/oct2015/Query-Optimization-Techniques-Tips-For-Writing-Efficient-And-Faster-Sql-Queries.pdf
 		"DIS.003": {
 			Item:     "DIS.003",
 			Severity: "L3",
 			Summary:  "DISTINCT *对有主键的表没有意义",
-			Content:  `当表已经有主键时，对所有列进行DISTINCT的输出结果与不进行DISTINCT操作的结果相同，请不要画蛇添足。`,
+			Content:  `当表已经有主键时，对所有列进行 DISTINCT 的输出结果与不进行 DISTINCT 操作的结果相同，请不要画蛇添足。`,
 			Case:     "SELECT DISTINCT * FROM film;",
 			Func:     (*Query4Audit).RuleDistinctStar,
 		},
 		"FUN.001": {
 			Item:     "FUN.001",
 			Severity: "L2",
-			Summary:  "避免在WHERE条件中使用函数或其他运算符",
-			Content:  `虽然在SQL中使用函数可以简化很多复杂的查询，但使用了函数的查询无法利用表中已经建立的索引，该查询将会是全表扫描，性能较差。通常建议将列名写在比较运算符左侧，将查询过滤条件放在比较运算符右侧。`,
+			Summary:  "避免在 WHERE 条件中使用函数或其他运算符",
+			Content:  `虽然在 SQL 中使用函数可以简化很多复杂的查询，但使用了函数的查询无法利用表中已经建立的索引，该查询将会是全表扫描，性能较差。通常建议将列名写在比较运算符左侧，将查询过滤条件放在比较运算符右侧。也不建议在查询比较条件两侧书写多余的括号，这会对阅读产生比较大的困扰。`,
 			Case:     "select id from t where substring(name,1,3)='abc'",
 			Func:     (*Query4Audit).RuleCompareWithFunction,
 		},
 		"FUN.002": {
 			Item:     "FUN.002",
 			Severity: "L1",
-			Summary:  "指定了WHERE条件或非MyISAM引擎时使用COUNT(*)操作性能不佳",
+			Summary:  "指定了 WHERE 条件或非 MyISAM 引擎时使用 COUNT(*) 操作性能不佳",
 			Content:  `COUNT(*)的作用是统计表行数，COUNT(COL)的作用是统计指定列非NULL的行数。MyISAM表对于COUNT(*)统计全表行数进行了特殊的优化，通常情况下非常快。但对于非MyISAM表或指定了某些WHERE条件，COUNT(*)操作需要扫描大量的行才能获取精确的结果，性能也因此不佳。有时候某些业务场景并不需要完全精确的COUNT值，此时可以用近似值来代替。EXPLAIN出来的优化器估算的行数就是一个不错的近似值，执行EXPLAIN并不需要真正去执行查询，所以成本很低。`,
 			Case:     "SELECT c3, COUNT(*) AS accounts FROM tab where c2 < 10000 GROUP BY c3 ORDER BY num",
 			Func:     (*Query4Audit).RuleCountStar,
@@ -631,14 +631,14 @@ func init() {
 			Item:     "GRP.001",
 			Severity: "L2",
 			Summary:  "不建议对等值查询列使用GROUP BY",
-			Content:  `GROUP BY中的列在前面的WHERE条件中使用了等值查询，对这样的列进行GROUP BY意义不大。`,
+			Content:  `GROUP BY 中的列在前面的 WHERE 条件中使用了等值查询，对这样的列进行GROUP BY意义不大。`,
 			Case:     "select film_id, title from film where release_year='2006' group by release_year",
 			Func:     (*Query4Audit).RuleOK, // 该建议在indexAdvisor中给
 		},
 		"JOI.001": {
 			Item:     "JOI.001",
 			Severity: "L2",
-			Summary:  "JOIN语句混用逗号和ANSI模式",
+			Summary:  "JOIN 语句混用逗号和 ANSI 模式",
 			Content:  `表连接的时候混用逗号和ANSI JOIN不便于人类理解，并且MySQL不同版本的表连接行为和优先级均有所不同，当MySQL版本变化后可能会引入错误。`,
 			Case:     "select c1,c2,c3 from t1,t2 join t3 on t1.c1=t2.c1,t1.c3=t3,c1 where id>1000",
 			Func:     (*Query4Audit).RuleCommaAnsiJoin,
@@ -655,7 +655,7 @@ func init() {
 			Item:     "JOI.003",
 			Severity: "L4",
 			Summary:  "OUTER JOIN失效",
-			Content:  `由于WHERE条件错误使得OUTER JOIN的外部表无数据返回，这会将查询隐式转换为 INNER JOIN 。如：select c from L left join R using(c) where L.a=5 and R.b=10。这种SQL逻辑上可能存在错误或程序员对OUTER JOIN如何工作存在误解，因为LEFT/RIGHT JOIN是LEFT/RIGHT OUTER JOIN的缩写。`,
+			Content:  `由于 WHERE 条件错误使得 OUTER JOIN 的外部表无数据返回，这会将查询隐式转换为 INNER JOIN 。如：select c from L left join R using(c) where L.a=5 and R.b=10。这种SQL逻辑上可能存在错误或程序员对OUTER JOIN如何工作存在误解，因为LEFT/RIGHT JOIN是LEFT/RIGHT OUTER JOIN的缩写。`,
 			Case:     "select c1,c2,c3 from t1 left outer join t2 using(c1) where t1.c2=2 and t2.c3=4",
 			Func:     (*Query4Audit).RuleOK, // TODO
 		},
@@ -663,7 +663,7 @@ func init() {
 			Item:     "JOI.004",
 			Severity: "L4",
 			Summary:  "不建议使用排它JOIN",
-			Content:  `只在右侧表为NULL的带WHERE子句的LEFT OUTER JOIN语句，有可能是在WHERE子句中使用错误的列，如：“... FROM l LEFT OUTER JOIN r ON l.l = r.r WHERE r.z IS NULL”，这个查询正确的逻辑可能是 WHERE r.r IS NULL。`,
+			Content:  `只在右侧表为 NULL 的带 WHERE 子句的LEFT OUTER JOIN语句，有可能是在WHERE子句中使用错误的列，如：“... FROM l LEFT OUTER JOIN r ON l.l = r.r WHERE r.z IS NULL”，这个查询正确的逻辑可能是 WHERE r.r IS NULL。`,
 			Case:     "select c1,c2,c3 from t1 left outer join t2 on t1.c1=t2.c1 where t2.c2 is null",
 			Func:     (*Query4Audit).RuleOK, // TODO
 		},
@@ -679,7 +679,7 @@ func init() {
 			Item:     "JOI.006",
 			Severity: "L4",
 			Summary:  "将嵌套查询重写为JOIN通常会导致更高效的执行和更有效的优化",
-			Content:  `一般来说，非嵌套子查询总是用于关联子查询，最多是来自FROM子句中的一个表，这些子查询用于ANY、ALL和EXISTS的谓词。如果可以根据查询语义决定子查询最多返回一个行，那么一个不相关的子查询或来自FROM子句中的多个表的子查询就被压平了。`,
+			Content:  `一般来说，非嵌套子查询总是用于关联子查询，最多是来自FROM子句中的一个表，这些子查询用于 ANY, ALL 和 EXISTS 的谓词。如果可以根据查询语义决定子查询最多返回一个行，那么一个不相关的子查询或来自FROM子句中的多个表的子查询就被压平了。`,
 			Case:     "SELECT s,p,d FROM tbl WHERE p.p_id = (SELECT s.p_id FROM tbl WHERE s.c_id = 100996 AND s.q = 1 )",
 			Func:     (*Query4Audit).RuleNestedSubQueries,
 		},
@@ -694,8 +694,8 @@ func init() {
 		"JOI.008": {
 			Item:     "JOI.008",
 			Severity: "L4",
-			Summary:  "不要使用跨DB的Join查询",
-			Content:  `一般来说，跨DB的Join查询意味着查询语句跨越了两个不同的子系统，这可能意味着系统耦合度过高或库表结构设计不合理。`,
+			Summary:  "不要使用跨数据库的 JOIN 查询",
+			Content:  `一般来说，跨数据库的 JOIN 查询意味着查询语句跨越了两个不同的子系统，这可能意味着系统耦合度过高或库表结构设计不合理。`,
 			Case:     "SELECT s,p,d FROM tbl WHERE p.p_id = (SELECT s.p_id FROM tbl WHERE s.c_id = 100996 AND s.q = 1 )",
 			Func:     (*Query4Audit).RuleMultiDBJoin,
 		},
@@ -752,8 +752,8 @@ func init() {
 		"KEY.007": {
 			Item:     "KEY.007",
 			Severity: "L4",
-			Summary:  "未指定主键或主键非int或bigint",
-			Content:  `未指定主键或主键非int或bigint，建议将主键设置为int unsigned或bigint unsigned。`,
+			Summary:  "未指定主键或主键非 int 或 bigint",
+			Content:  `未指定主键或主键非 int 或 bigint，建议将主键设置为 int unsigned 或 bigint unsigned。`,
 			Case:     "CREATE TABLE tbl (a int);",
 			Func:     (*Query4Audit).RulePKNotInt,
 		},
@@ -776,7 +776,7 @@ func init() {
 		"KWR.001": {
 			Item:     "KWR.001",
 			Severity: "L2",
-			Summary:  "SQL_CALC_FOUND_ROWS效率低下",
+			Summary:  "SQL_CALC_FOUND_ROWS 效率低下",
 			Content:  `因为SQL_CALC_FOUND_ROWS不能很好地扩展，所以可能导致性能问题; 建议业务使用其他策略来替代SQL_CALC_FOUND_ROWS提供的计数功能，比如：分页结果展示等。`,
 			Case:     "select SQL_CALC_FOUND_ROWS col from tbl where id>1000",
 			Func:     (*Query4Audit).RuleSQLCalcFoundRows,
@@ -841,7 +841,7 @@ func init() {
 			Item:     "LIT.004",
 			Severity: "L1",
 			Summary:  "请使用分号或已设定的DELIMITER结尾",
-			Content:  `USE database, SHOW DATABASES等命令也需要使用使用分号或已设定的DELIMITER结尾。`,
+			Content:  `USE database, SHOW DATABASES 等命令也需要使用使用分号或已设定的 DELIMITER 结尾。`,
 			Case:     "USE db",
 			Func:     (*Query4Audit).RuleOK, // TODO: RuleAddDelimiter
 		},
@@ -856,8 +856,8 @@ func init() {
 		"RES.002": {
 			Item:     "RES.002",
 			Severity: "L4",
-			Summary:  "未使用ORDER BY的LIMIT查询",
-			Content:  `没有ORDER BY的LIMIT会导致非确定性的结果，这取决于查询执行计划。`,
+			Summary:  "未使用 ORDER BY 的 LIMIT 查询",
+			Content:  `没有 ORDER BY 的 LIMIT 会导致非确定性的结果，这取决于查询执行计划。`,
 			Case:     "select col1,col2 from tbl where name=xx limit 10",
 			Func:     (*Query4Audit).RuleNoDeterministicLimit,
 		},
@@ -897,7 +897,7 @@ func init() {
 			Item:     "RES.007",
 			Severity: "L4",
 			Summary:  "永远为真的比较条件",
-			Content:  "查询条件永远为真，这将导致WHERE条件失效进行全表查询。",
+			Content:  "查询条件永远为真，可能导致 WHERE 条件失效进行全表查询。",
 			Case:     "select * from tbl where 1 = 1;",
 			Func:     (*Query4Audit).RuleMeaninglessWhere,
 		},
@@ -905,7 +905,7 @@ func init() {
 			Item:     "RES.008",
 			Severity: "L2",
 			Summary:  "不建议使用LOAD DATA/SELECT ... INTO OUTFILE",
-			Content:  "SELECT INTO OUTFILE需要授予FILE权限，这通过会引入安全问题。LOAD DATA虽然可以提高数据导入速度，但同时也可能导致从库同步延迟过大。",
+			Content:  "SELECT INTO OUTFILE 需要授予 FILE 权限，这通过会引入安全问题。LOAD DATA 虽然可以提高数据导入速度，但同时也可能导致从库同步延迟过大。",
 			Case:     "LOAD DATA INFILE 'data.txt' INTO TABLE db2.my_table;",
 			Func:     (*Query4Audit).RuleLoadFile,
 		},
@@ -945,7 +945,7 @@ func init() {
 			Item:     "STA.002",
 			Severity: "L1",
 			Summary:  "库名或表名点后建议不要加空格",
-			Content:  `当使用db.table或table.column格式访问表或字段时，请不要在点号后面添加空格，虽然这样语法正确。`,
+			Content:  `当使用 db.table 或 table.column 格式访问表或字段时，请不要在点号后面添加空格，虽然这样语法正确。`,
 			Case:     "select col from sakila. film",
 			Func:     (*Query4Audit).RuleSpaceAfterDot,
 		},
@@ -976,7 +976,7 @@ func init() {
 		"SUB.002": {
 			Item:     "SUB.002",
 			Severity: "L2",
-			Summary:  "如果您不在乎重复的话，建议使用UNION ALL替代UNION",
+			Summary:  "如果您不在乎重复的话，建议使用 UNION ALL 替代 UNION",
 			Content:  `与去除重复的UNION不同，UNION ALL允许重复元组。如果您不关心重复元组，那么使用UNION ALL将是一个更快的选项。`,
 			Case:     "select teacher_id as id,people_name as name from t1,t2 where t1.teacher_id=t2.people_id union select student_id as id,people_name as name from t1,t2 where t1.student_id=t2.people_id",
 			Func:     (*Query4Audit).RuleUNIONUsage,
@@ -984,8 +984,8 @@ func init() {
 		"SUB.003": {
 			Item:     "SUB.003",
 			Severity: "L3",
-			Summary:  "考虑使用EXISTS而不是DISTINCT子查询",
-			Content:  `DISTINCT关键字在对元组排序后删除重复。相反，考虑使用一个带有EXISTS关键字的子查询，您可以避免返回整个表。`,
+			Summary:  "考虑使用 EXISTS 而不是 DISTINCT 子查询",
+			Content:  `DISTINCT 关键字在对元组排序后删除重复。相反，考虑使用一个带有 EXISTS 关键字的子查询，您可以避免返回整个表。`,
 			Case:     "SELECT DISTINCT c.c_id, c.c_name FROM c,e WHERE e.c_id = c.c_id",
 			Func:     (*Query4Audit).RuleDistinctJoinUsage,
 		},
@@ -1005,7 +1005,7 @@ func init() {
 			Item:     "SUB.005",
 			Severity: "L8",
 			Summary:  "子查询不支持LIMIT",
-			Content:  `当前MySQL版本不支持在子查询中进行'LIMIT & IN/ALL/ANY/SOME'。`,
+			Content:  `当前 MySQL 版本不支持在子查询中进行 'LIMIT & IN/ALL/ANY/SOME'。`,
 			Case:     "SELECT * FROM staff WHERE name IN (SELECT NAME FROM customer ORDER BY name LIMIT 1)",
 			Func:     (*Query4Audit).RuleSubQueryLimit,
 		},
diff --git a/advisor/testdata/TestListHeuristicRules.golden b/advisor/testdata/TestListHeuristicRules.golden
index 2a03fab09cafa69491c687598ba4446214a182d1..6fec346fef0802cee2db18f1b5e1a4043faa7703 100644
--- a/advisor/testdata/TestListHeuristicRules.golden
+++ b/advisor/testdata/TestListHeuristicRules.golden
@@ -116,7 +116,7 @@ SELECT * FROM tb WHERE col IN (NULL);
 
 * **Item**:ARG.005
 * **Severity**:L1
-* **Content**: 如：select id from t where num in(1,2,3)对于连续的数值，能用BETWEEN就不要用IN了：select id from t where num between 1 and 3。而当IN值过多时MySQL也可能会进入全表扫描导致性能急剧下降。
+* **Content**: 如：select id from t where num in(1,2,3)对于连续的数值，能用 BETWEEN 就不要用 IN 了：select id from t where num between 1 and 3。而当IN值过多时MySQL也可能会进入全表扫描导致性能急剧下降。
 * **Case**:
 
 ```sql
@@ -136,13 +136,13 @@ select id from t where num is null
 
 * **Item**:ARG.007
 * **Severity**:L3
-* **Content**:性能问题是使用模式匹配操作符的最大缺点。使用LIKE或正则表达式进行模式匹配进行查询的另一个问题，是可能会返回意料之外的结果。最好的方案就是使用特殊的搜索引擎技术来替代SQL，比如Apache Lucene。另一个可选方案是将结果保存起来从而减少重复的搜索开销。如果一定要使用SQL，请考虑在MySQL中使用像FULLTEXT索引这样的第三方扩展。但更广泛地说，您不一定要使用SQL来解决所有问题。
+* **Content**:性能问题是使用模式匹配操作符的最大缺点。使用LIKE或正则表达式进行模式匹配进行查询的另一个问题，是可能会返回意料之外的结果。最好的方案就是使用特殊的搜索引擎技术来替代SQL，比如 Apache Lucene。另一个可选方案是将结果保存起来从而减少重复的搜索开销。如果一定要使用SQL，请考虑在 MySQL 中使用像 FULLTEXT 索引这样的第三方扩展。但更广泛地说，您不一定要使用SQL来解决所有问题。
 * **Case**:
 
 ```sql
 select c_id,c2,c3 from tbl where c2 like 'test%'
 ```
-## OR查询索引列时请尽量使用IN谓词
+## OR 查询索引列时请尽量使用 IN 谓词
 
 * **Item**:ARG.008
 * **Severity**:L1
@@ -156,7 +156,7 @@ SELECT c1,c2,c3 FROM tbl WHERE c1 = 14 OR c1 = 17
 
 * **Item**:ARG.009
 * **Severity**:L1
-* **Content**:如果VARCHAR列的前后存在空格将可能引起逻辑问题，如在MySQL 5.5中'a'和'a '可能会在查询中被认为是相同的值。
+* **Content**:如果VARCHAR列的前后存在空格将可能引起逻辑问题，如在MySQL 5.5中 'a' 和 'a ' 可能会在查询中被认为是相同的值。
 * **Case**:
 
 ```sql
@@ -166,7 +166,7 @@ SELECT 'abc '
 
 * **Item**:ARG.010
 * **Severity**:L1
-* **Content**:hint是用来强制SQL按照某个执行计划来执行，但随着数据量变化我们无法保证自己当初的预判是正确的。
+* **Content**:hint 是用来强制 SQL 按照某个执行计划来执行，但随着数据量变化我们无法保证自己当初的预判是正确的。
 * **Case**:
 
 ```sql
@@ -536,23 +536,23 @@ SELECT COUNT(DISTINCT col, col2) FROM tbl;
 
 * **Item**:DIS.003
 * **Severity**:L3
-* **Content**:当表已经有主键时，对所有列进行DISTINCT的输出结果与不进行DISTINCT操作的结果相同，请不要画蛇添足。
+* **Content**:当表已经有主键时，对所有列进行 DISTINCT 的输出结果与不进行 DISTINCT 操作的结果相同，请不要画蛇添足。
 * **Case**:
 
 ```sql
 SELECT DISTINCT * FROM film;
 ```
-## 避免在WHERE条件中使用函数或其他运算符
+## 避免在 WHERE 条件中使用函数或其他运算符
 
 * **Item**:FUN.001
 * **Severity**:L2
-* **Content**:虽然在SQL中使用函数可以简化很多复杂的查询，但使用了函数的查询无法利用表中已经建立的索引，该查询将会是全表扫描，性能较差。通常建议将列名写在比较运算符左侧，将查询过滤条件放在比较运算符右侧。
+* **Content**:虽然在 SQL 中使用函数可以简化很多复杂的查询，但使用了函数的查询无法利用表中已经建立的索引，该查询将会是全表扫描，性能较差。通常建议将列名写在比较运算符左侧，将查询过滤条件放在比较运算符右侧。也不建议在查询比较条件两侧书写多余的括号，这会对阅读产生比较大的困扰。
 * **Case**:
 
 ```sql
 select id from t where substring(name,1,3)='abc'
 ```
-## 指定了WHERE条件或非MyISAM引擎时使用COUNT(\*)操作性能不佳
+## 指定了 WHERE 条件或非 MyISAM 引擎时使用 COUNT(\*) 操作性能不佳
 
 * **Item**:FUN.002
 * **Severity**:L1
@@ -606,13 +606,13 @@ SELECT SUM(COL) FROM tbl;
 
 * **Item**:GRP.001
 * **Severity**:L2
-* **Content**:GROUP BY中的列在前面的WHERE条件中使用了等值查询，对这样的列进行GROUP BY意义不大。
+* **Content**:GROUP BY 中的列在前面的 WHERE 条件中使用了等值查询，对这样的列进行GROUP BY意义不大。
 * **Case**:
 
 ```sql
 select film_id, title from film where release_year='2006' group by release_year
 ```
-## JOIN语句混用逗号和ANSI模式
+## JOIN 语句混用逗号和 ANSI 模式
 
 * **Item**:JOI.001
 * **Severity**:L2
@@ -636,7 +636,7 @@ select tb1.col from (tb1, tb2) join tb2 on tb1.id=tb.id where tb1.id=1
 
 * **Item**:JOI.003
 * **Severity**:L4
-* **Content**:由于WHERE条件错误使得OUTER JOIN的外部表无数据返回，这会将查询隐式转换为 INNER JOIN 。如：select c from L left join R using(c) where L.a=5 and R.b=10。这种SQL逻辑上可能存在错误或程序员对OUTER JOIN如何工作存在误解，因为LEFT/RIGHT JOIN是LEFT/RIGHT OUTER JOIN的缩写。
+* **Content**:由于 WHERE 条件错误使得 OUTER JOIN 的外部表无数据返回，这会将查询隐式转换为 INNER JOIN 。如：select c from L left join R using(c) where L.a=5 and R.b=10。这种SQL逻辑上可能存在错误或程序员对OUTER JOIN如何工作存在误解，因为LEFT/RIGHT JOIN是LEFT/RIGHT OUTER JOIN的缩写。
 * **Case**:
 
 ```sql
@@ -646,7 +646,7 @@ select c1,c2,c3 from t1 left outer join t2 using(c1) where t1.c2=2 and t2.c3=4
 
 * **Item**:JOI.004
 * **Severity**:L4
-* **Content**:只在右侧表为NULL的带WHERE子句的LEFT OUTER JOIN语句，有可能是在WHERE子句中使用错误的列，如：“... FROM l LEFT OUTER JOIN r ON l.l = r.r WHERE r.z IS NULL”，这个查询正确的逻辑可能是 WHERE r.r IS NULL。
+* **Content**:只在右侧表为 NULL 的带 WHERE 子句的LEFT OUTER JOIN语句，有可能是在WHERE子句中使用错误的列，如：“... FROM l LEFT OUTER JOIN r ON l.l = r.r WHERE r.z IS NULL”，这个查询正确的逻辑可能是 WHERE r.r IS NULL。
 * **Case**:
 
 ```sql
@@ -666,7 +666,7 @@ select bp1.p_id, b1.d_d as l, b1.b_id from b1 join bp1 on (b1.b_id = bp1.b_id) l
 
 * **Item**:JOI.006
 * **Severity**:L4
-* **Content**:一般来说，非嵌套子查询总是用于关联子查询，最多是来自FROM子句中的一个表，这些子查询用于ANY、ALL和EXISTS的谓词。如果可以根据查询语义决定子查询最多返回一个行，那么一个不相关的子查询或来自FROM子句中的多个表的子查询就被压平了。
+* **Content**:一般来说，非嵌套子查询总是用于关联子查询，最多是来自FROM子句中的一个表，这些子查询用于 ANY, ALL 和 EXISTS 的谓词。如果可以根据查询语义决定子查询最多返回一个行，那么一个不相关的子查询或来自FROM子句中的多个表的子查询就被压平了。
 * **Case**:
 
 ```sql
@@ -682,11 +682,11 @@ SELECT s,p,d FROM tbl WHERE p.p_id = (SELECT s.p_id FROM tbl WHERE s.c_id = 1009
 ```sql
 UPDATE users u LEFT JOIN hobby h ON u.id = h.uid SET u.name = 'pianoboy' WHERE h.hobby = 'piano';
 ```
-## 不要使用跨DB的Join查询
+## 不要使用跨数据库的 JOIN 查询
 
 * **Item**:JOI.008
 * **Severity**:L4
-* **Content**:一般来说，跨DB的Join查询意味着查询语句跨越了两个不同的子系统，这可能意味着系统耦合度过高或库表结构设计不合理。
+* **Content**:一般来说，跨数据库的 JOIN 查询意味着查询语句跨越了两个不同的子系统，这可能意味着系统耦合度过高或库表结构设计不合理。
 * **Case**:
 
 ```sql
@@ -752,11 +752,11 @@ CREATE TABLE tbl ( a int, b int, c int, KEY idx_a (`a`),KEY idx_b(`b`),KEY idx_c
 ```sql
 CREATE TABLE tbl ( a int, b int, c int, PRIMARY KEY(`a`,`b`,`c`));
 ```
-## 未指定主键或主键非int或bigint
+## 未指定主键或主键非 int 或 bigint
 
 * **Item**:KEY.007
 * **Severity**:L4
-* **Content**:未指定主键或主键非int或bigint，建议将主键设置为int unsigned或bigint unsigned。
+* **Content**:未指定主键或主键非 int 或 bigint，建议将主键设置为 int unsigned 或 bigint unsigned。
 * **Case**:
 
 ```sql
@@ -782,7 +782,7 @@ SELECT * FROM tbl ORDER BY a DESC, b ASC;
 ```sql
 CREATE UNIQUE INDEX part_of_name ON customer (name(10));
 ```
-## SQL\_CALC\_FOUND\_ROWS效率低下
+## SQL\_CALC\_FOUND\_ROWS 效率低下
 
 * **Item**:KWR.001
 * **Severity**:L2
@@ -866,7 +866,7 @@ select c1,c2,c3,c4 from tab1 where col_id REGEXP '[[:<:]]12[[:>:]]'
 
 * **Item**:LIT.004
 * **Severity**:L1
-* **Content**:USE database, SHOW DATABASES等命令也需要使用使用分号或已设定的DELIMITER结尾。
+* **Content**:USE database, SHOW DATABASES 等命令也需要使用使用分号或已设定的 DELIMITER 结尾。
 * **Case**:
 
 ```sql
@@ -882,11 +882,11 @@ USE db
 ```sql
 select c1,c2,c3 from t1 where c2='foo' group by c2
 ```
-## 未使用ORDER BY的LIMIT查询
+## 未使用 ORDER BY 的 LIMIT 查询
 
 * **Item**:RES.002
 * **Severity**:L4
-* **Content**:没有ORDER BY的LIMIT会导致非确定性的结果，这取决于查询执行计划。
+* **Content**:没有 ORDER BY 的 LIMIT 会导致非确定性的结果，这取决于查询执行计划。
 * **Case**:
 
 ```sql
@@ -936,7 +936,7 @@ select * from tbl where 1 != 1;
 
 * **Item**:RES.007
 * **Severity**:L4
-* **Content**:查询条件永远为真，这将导致WHERE条件失效进行全表查询。
+* **Content**:查询条件永远为真，可能导致 WHERE 条件失效进行全表查询。
 * **Case**:
 
 ```sql
@@ -946,7 +946,7 @@ select * from tbl where 1 = 1;
 
 * **Item**:RES.008
 * **Severity**:L2
-* **Content**:SELECT INTO OUTFILE需要授予FILE权限，这通过会引入安全问题。LOAD DATA虽然可以提高数据导入速度，但同时也可能导致从库同步延迟过大。
+* **Content**:SELECT INTO OUTFILE 需要授予 FILE 权限，这通过会引入安全问题。LOAD DATA 虽然可以提高数据导入速度，但同时也可能导致从库同步延迟过大。
 * **Case**:
 
 ```sql
@@ -996,7 +996,7 @@ select col1,col2 from tbl where type!=0
 
 * **Item**:STA.002
 * **Severity**:L1
-* **Content**:当使用db.table或table.column格式访问表或字段时，请不要在点号后面添加空格，虽然这样语法正确。
+* **Content**:当使用 db.table 或 table.column 格式访问表或字段时，请不要在点号后面添加空格，虽然这样语法正确。
 * **Case**:
 
 ```sql
@@ -1032,7 +1032,7 @@ CREATE TABLE ` abc` (a int);
 ```sql
 select col1,col2,col3 from table1 where col2 in(select col from table2)
 ```
-## 如果您不在乎重复的话，建议使用UNION ALL替代UNION
+## 如果您不在乎重复的话，建议使用 UNION ALL 替代 UNION
 
 * **Item**:SUB.002
 * **Severity**:L2
@@ -1042,11 +1042,11 @@ select col1,col2,col3 from table1 where col2 in(select col from table2)
 ```sql
 select teacher_id as id,people_name as name from t1,t2 where t1.teacher_id=t2.people_id union select student_id as id,people_name as name from t1,t2 where t1.student_id=t2.people_id
 ```
-## 考虑使用EXISTS而不是DISTINCT子查询
+## 考虑使用 EXISTS 而不是 DISTINCT 子查询
 
 * **Item**:SUB.003
 * **Severity**:L3
-* **Content**:DISTINCT关键字在对元组排序后删除重复。相反，考虑使用一个带有EXISTS关键字的子查询，您可以避免返回整个表。
+* **Content**:DISTINCT 关键字在对元组排序后删除重复。相反，考虑使用一个带有 EXISTS 关键字的子查询，您可以避免返回整个表。
 * **Case**:
 
 ```sql
@@ -1066,7 +1066,7 @@ SELECT * from tb where id in (select id from (select id from tb))
 
 * **Item**:SUB.005
 * **Severity**:L8
-* **Content**:当前MySQL版本不支持在子查询中进行'LIMIT & IN/ALL/ANY/SOME'。
+* **Content**:当前 MySQL 版本不支持在子查询中进行 'LIMIT & IN/ALL/ANY/SOME'。
 * **Case**:
 
 ```sql
diff --git a/advisor/testdata/TestMergeConflictHeuristicRules.golden b/advisor/testdata/TestMergeConflictHeuristicRules.golden
index d7d2ce08aa0d2432efd42472d4b0f7f081976b28..6b393ee7953c703217bd1d7aea02cbd8a0f3ca7d 100644
--- a/advisor/testdata/TestMergeConflictHeuristicRules.golden
+++ b/advisor/testdata/TestMergeConflictHeuristicRules.golden
@@ -10,10 +10,10 @@ advisor.Rule{Item:"ARG.002", Severity:"L1", Summary:"没有通配符的LIKE查
 advisor.Rule{Item:"ARG.003", Severity:"L4", Summary:"参数比较包含隐式转换，无法使用索引", Content:"隐式类型转换有无法命中索引的风险，在高并发、大数据量的情况下，命不中索引带来的后果非常严重。", Case:"SELECT * FROM sakila.film WHERE length >= '60';", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"ARG.004", Severity:"L4", Summary:"IN (NULL)/NOT IN (NULL)永远非真", Content:"正确的作法是col IN ('val1', 'val2', 'val3') OR col IS NULL", Case:"SELECT * FROM tb WHERE col IN (NULL);", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"ARG.006", Severity:"L1", Summary:"应尽量避免在WHERE子句中对字段进行NULL值判断", Content:"使用IS NULL或IS NOT NULL将可能导致引擎放弃使用索引而进行全表扫描，如：select id from t where num is null;可以在num上设置默认值0，确保表中num列没有null值，然后这样查询： select id from t where num=0;", Case:"select id from t where num is null", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"ARG.007", Severity:"L3", Summary:"避免使用模式匹配", Content:"性能问题是使用模式匹配操作符的最大缺点。使用LIKE或正则表达式进行模式匹配进行查询的另一个问题，是可能会返回意料之外的结果。最好的方案就是使用特殊的搜索引擎技术来替代SQL，比如Apache Lucene。另一个可选方案是将结果保存起来从而减少重复的搜索开销。如果一定要使用SQL，请考虑在MySQL中使用像FULLTEXT索引这样的第三方扩展。但更广泛地说，您不一定要使用SQL来解决所有问题。", Case:"select c_id,c2,c3 from tbl where c2 like 'test%'", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"ARG.008", Severity:"L1", Summary:"OR查询索引列时请尽量使用IN谓词", Content:"IN-list谓词可以用于索引检索，并且优化器可以对IN-list进行排序，以匹配索引的排序序列，从而获得更有效的检索。请注意，IN-list必须只包含常量，或在查询块执行期间保持常量的值，例如外引用。", Case:"SELECT c1,c2,c3 FROM tbl WHERE c1 = 14 OR c1 = 17", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"ARG.009", Severity:"L1", Summary:"引号中的字符串开头或结尾包含空格", Content:"如果VARCHAR列的前后存在空格将可能引起逻辑问题，如在MySQL 5.5中'a'和'a '可能会在查询中被认为是相同的值。", Case:"SELECT 'abc '", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"ARG.010", Severity:"L1", Summary:"不要使用hint，如sql_no_cache, force index, ignore key, straight join等", Content:"hint是用来强制SQL按照某个执行计划来执行，但随着数据量变化我们无法保证自己当初的预判是正确的。", Case:"SELECT * FROM t1 USE INDEX (i1) ORDER BY a;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"ARG.007", Severity:"L3", Summary:"避免使用模式匹配", Content:"性能问题是使用模式匹配操作符的最大缺点。使用LIKE或正则表达式进行模式匹配进行查询的另一个问题，是可能会返回意料之外的结果。最好的方案就是使用特殊的搜索引擎技术来替代SQL，比如 Apache Lucene。另一个可选方案是将结果保存起来从而减少重复的搜索开销。如果一定要使用SQL，请考虑在 MySQL 中使用像 FULLTEXT 索引这样的第三方扩展。但更广泛地说，您不一定要使用SQL来解决所有问题。", Case:"select c_id,c2,c3 from tbl where c2 like 'test%'", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"ARG.008", Severity:"L1", Summary:"OR 查询索引列时请尽量使用 IN 谓词", Content:"IN-list谓词可以用于索引检索，并且优化器可以对IN-list进行排序，以匹配索引的排序序列，从而获得更有效的检索。请注意，IN-list必须只包含常量，或在查询块执行期间保持常量的值，例如外引用。", Case:"SELECT c1,c2,c3 FROM tbl WHERE c1 = 14 OR c1 = 17", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"ARG.009", Severity:"L1", Summary:"引号中的字符串开头或结尾包含空格", Content:"如果VARCHAR列的前后存在空格将可能引起逻辑问题，如在MySQL 5.5中 'a' 和 'a ' 可能会在查询中被认为是相同的值。", Case:"SELECT 'abc '", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"ARG.010", Severity:"L1", Summary:"不要使用hint，如sql_no_cache, force index, ignore key, straight join等", Content:"hint 是用来强制 SQL 按照某个执行计划来执行，但随着数据量变化我们无法保证自己当初的预判是正确的。", Case:"SELECT * FROM t1 USE INDEX (i1) ORDER BY a;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"ARG.011", Severity:"L3", Summary:"不要使用负向查询，如：NOT IN/NOT LIKE", Content:"请尽量不要使用负向查询，这将导致全表扫描，对查询性能影响较大。", Case:"select id from t where num not in(1,2,3);", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"CLA.001", Severity:"L4", Summary:"最外层SELECT未指定WHERE条件", Content:"SELECT语句没有WHERE子句，可能检查比预期更多的行(全表扫描)。对于SELECT COUNT(*)类型的请求如果不要求精度，建议使用SHOW TABLE STATUS或EXPLAIN替代。", Case:"select id from tbl", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"CLA.002", Severity:"L3", Summary:"不建议使用ORDER BY RAND()", Content:"ORDER BY RAND()是从结果集中检索随机行的一种非常低效的方法，因为它会对整个结果进行排序并丢弃其大部分数据。", Case:"select name from tbl where id < 1000 order by rand(number)", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
@@ -50,29 +50,29 @@ advisor.Rule{Item:"COL.016", Severity:"L1", Summary:"整型定义建议采用INT
 advisor.Rule{Item:"COL.017", Severity:"L2", Summary:"varchar定义长度过长", Content:"varchar 是可变长字符串，不预先分配存储空间，长度不要超过1024，如果存储长度过长MySQL将定义字段类型为text，独立出来一张表，用主键来对应，避免影响其它字段索引效率。", Case:"CREATE TABLE tab (a varchar(3500));", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"DIS.001", Severity:"L1", Summary:"消除不必要的DISTINCT条件", Content:"太多DISTINCT条件是复杂的裹脚布式查询的症状。考虑将复杂查询分解成许多简单的查询，并减少DISTINCT条件的数量。如果主键列是列的结果集的一部分，则DISTINCT条件可能没有影响。", Case:"SELECT DISTINCT c.c_id,count(DISTINCT c.c_name),count(DISTINCT c.c_e),count(DISTINCT c.c_n),count(DISTINCT c.c_me),c.c_d FROM (select distinct xing, name from B) as e WHERE e.country_id = c.country_id", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"DIS.002", Severity:"L3", Summary:"COUNT(DISTINCT)多列时结果可能和你预想的不同", Content:"COUNT(DISTINCT col)计算该列除NULL之外的不重复行数，注意COUNT(DISTINCT col, col2)如果其中一列全为NULL那么即使另一列有不同的值，也返回0。", Case:"SELECT COUNT(DISTINCT col, col2) FROM tbl;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"DIS.003", Severity:"L3", Summary:"DISTINCT *对有主键的表没有意义", Content:"当表已经有主键时，对所有列进行DISTINCT的输出结果与不进行DISTINCT操作的结果相同，请不要画蛇添足。", Case:"SELECT DISTINCT * FROM film;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"FUN.001", Severity:"L2", Summary:"避免在WHERE条件中使用函数或其他运算符", Content:"虽然在SQL中使用函数可以简化很多复杂的查询，但使用了函数的查询无法利用表中已经建立的索引，该查询将会是全表扫描，性能较差。通常建议将列名写在比较运算符左侧，将查询过滤条件放在比较运算符右侧。", Case:"select id from t where substring(name,1,3)='abc'", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"FUN.002", Severity:"L1", Summary:"指定了WHERE条件或非MyISAM引擎时使用COUNT(*)操作性能不佳", Content:"COUNT(*)的作用是统计表行数，COUNT(COL)的作用是统计指定列非NULL的行数。MyISAM表对于COUNT(*)统计全表行数进行了特殊的优化，通常情况下非常快。但对于非MyISAM表或指定了某些WHERE条件，COUNT(*)操作需要扫描大量的行才能获取精确的结果，性能也因此不佳。有时候某些业务场景并不需要完全精确的COUNT值，此时可以用近似值来代替。EXPLAIN出来的优化器估算的行数就是一个不错的近似值，执行EXPLAIN并不需要真正去执行查询，所以成本很低。", Case:"SELECT c3, COUNT(*) AS accounts FROM tab where c2 < 10000 GROUP BY c3 ORDER BY num", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"DIS.003", Severity:"L3", Summary:"DISTINCT *对有主键的表没有意义", Content:"当表已经有主键时，对所有列进行 DISTINCT 的输出结果与不进行 DISTINCT 操作的结果相同，请不要画蛇添足。", Case:"SELECT DISTINCT * FROM film;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"FUN.001", Severity:"L2", Summary:"避免在 WHERE 条件中使用函数或其他运算符", Content:"虽然在 SQL 中使用函数可以简化很多复杂的查询，但使用了函数的查询无法利用表中已经建立的索引，该查询将会是全表扫描，性能较差。通常建议将列名写在比较运算符左侧，将查询过滤条件放在比较运算符右侧。也不建议在查询比较条件两侧书写多余的括号，这会对阅读产生比较大的困扰。", Case:"select id from t where substring(name,1,3)='abc'", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"FUN.002", Severity:"L1", Summary:"指定了 WHERE 条件或非 MyISAM 引擎时使用 COUNT(*) 操作性能不佳", Content:"COUNT(*)的作用是统计表行数，COUNT(COL)的作用是统计指定列非NULL的行数。MyISAM表对于COUNT(*)统计全表行数进行了特殊的优化，通常情况下非常快。但对于非MyISAM表或指定了某些WHERE条件，COUNT(*)操作需要扫描大量的行才能获取精确的结果，性能也因此不佳。有时候某些业务场景并不需要完全精确的COUNT值，此时可以用近似值来代替。EXPLAIN出来的优化器估算的行数就是一个不错的近似值，执行EXPLAIN并不需要真正去执行查询，所以成本很低。", Case:"SELECT c3, COUNT(*) AS accounts FROM tab where c2 < 10000 GROUP BY c3 ORDER BY num", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"FUN.003", Severity:"L3", Summary:"使用了合并为可空列的字符串连接", Content:"在一些查询请求中，您需要强制让某一列或者某个表达式返回非NULL的值，从而让查询逻辑变得更简单，担忧不想将这个值存下来。使用COALESCE()函数来构造连接的表达式，这样即使是空值列也不会使整表达式变为NULL。", Case:"select c1 || coalesce(' ' || c2 || ' ', ' ') || c3 as c from tbl", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"FUN.004", Severity:"L4", Summary:"不建议使用SYSDATE()函数", Content:"SYSDATE()函数可能导致主从数据不一致，请使用NOW()函数替代SYSDATE()。", Case:"SELECT SYSDATE();", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"FUN.005", Severity:"L1", Summary:"不建议使用COUNT(col)或COUNT(常量)", Content:"不要使用COUNT(col)或COUNT(常量)来替代COUNT(*),COUNT(*)是SQL92定义的标准统计行数的方法，跟数据无关，跟NULL和非NULL也无关。", Case:"SELECT COUNT(1) FROM tbl;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"FUN.006", Severity:"L1", Summary:"使用SUM(COL)时需注意NPE问题", Content:"当某一列的值全是NULL时，COUNT(COL)的返回结果为0,但SUM(COL)的返回结果为NULL,因此使用SUM()时需注意NPE问题。可以使用如下方式来避免SUM的NPE问题: SELECT IF(ISNULL(SUM(COL)), 0, SUM(COL)) FROM tbl", Case:"SELECT SUM(COL) FROM tbl;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"GRP.001", Severity:"L2", Summary:"不建议对等值查询列使用GROUP BY", Content:"GROUP BY中的列在前面的WHERE条件中使用了等值查询，对这样的列进行GROUP BY意义不大。", Case:"select film_id, title from film where release_year='2006' group by release_year", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"JOI.001", Severity:"L2", Summary:"JOIN语句混用逗号和ANSI模式", Content:"表连接的时候混用逗号和ANSI JOIN不便于人类理解，并且MySQL不同版本的表连接行为和优先级均有所不同，当MySQL版本变化后可能会引入错误。", Case:"select c1,c2,c3 from t1,t2 join t3 on t1.c1=t2.c1,t1.c3=t3,c1 where id>1000", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"GRP.001", Severity:"L2", Summary:"不建议对等值查询列使用GROUP BY", Content:"GROUP BY 中的列在前面的 WHERE 条件中使用了等值查询，对这样的列进行GROUP BY意义不大。", Case:"select film_id, title from film where release_year='2006' group by release_year", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"JOI.001", Severity:"L2", Summary:"JOIN 语句混用逗号和 ANSI 模式", Content:"表连接的时候混用逗号和ANSI JOIN不便于人类理解，并且MySQL不同版本的表连接行为和优先级均有所不同，当MySQL版本变化后可能会引入错误。", Case:"select c1,c2,c3 from t1,t2 join t3 on t1.c1=t2.c1,t1.c3=t3,c1 where id>1000", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"JOI.002", Severity:"L4", Summary:"同一张表被连接两次", Content:"相同的表在FROM子句中至少出现两次，可以简化为对该表的单次访问。", Case:"select tb1.col from (tb1, tb2) join tb2 on tb1.id=tb.id where tb1.id=1", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"JOI.003", Severity:"L4", Summary:"OUTER JOIN失效", Content:"由于WHERE条件错误使得OUTER JOIN的外部表无数据返回，这会将查询隐式转换为 INNER JOIN 。如：select c from L left join R using(c) where L.a=5 and R.b=10。这种SQL逻辑上可能存在错误或程序员对OUTER JOIN如何工作存在误解，因为LEFT/RIGHT JOIN是LEFT/RIGHT OUTER JOIN的缩写。", Case:"select c1,c2,c3 from t1 left outer join t2 using(c1) where t1.c2=2 and t2.c3=4", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"JOI.004", Severity:"L4", Summary:"不建议使用排它JOIN", Content:"只在右侧表为NULL的带WHERE子句的LEFT OUTER JOIN语句，有可能是在WHERE子句中使用错误的列，如：“... FROM l LEFT OUTER JOIN r ON l.l = r.r WHERE r.z IS NULL”，这个查询正确的逻辑可能是 WHERE r.r IS NULL。", Case:"select c1,c2,c3 from t1 left outer join t2 on t1.c1=t2.c1 where t2.c2 is null", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"JOI.003", Severity:"L4", Summary:"OUTER JOIN失效", Content:"由于 WHERE 条件错误使得 OUTER JOIN 的外部表无数据返回，这会将查询隐式转换为 INNER JOIN 。如：select c from L left join R using(c) where L.a=5 and R.b=10。这种SQL逻辑上可能存在错误或程序员对OUTER JOIN如何工作存在误解，因为LEFT/RIGHT JOIN是LEFT/RIGHT OUTER JOIN的缩写。", Case:"select c1,c2,c3 from t1 left outer join t2 using(c1) where t1.c2=2 and t2.c3=4", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"JOI.004", Severity:"L4", Summary:"不建议使用排它JOIN", Content:"只在右侧表为 NULL 的带 WHERE 子句的LEFT OUTER JOIN语句，有可能是在WHERE子句中使用错误的列，如：“... FROM l LEFT OUTER JOIN r ON l.l = r.r WHERE r.z IS NULL”，这个查询正确的逻辑可能是 WHERE r.r IS NULL。", Case:"select c1,c2,c3 from t1 left outer join t2 on t1.c1=t2.c1 where t2.c2 is null", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"JOI.005", Severity:"L2", Summary:"减少JOIN的数量", Content:"太多的JOIN是复杂的裹脚布式查询的症状。考虑将复杂查询分解成许多简单的查询，并减少JOIN的数量。", Case:"select bp1.p_id, b1.d_d as l, b1.b_id from b1 join bp1 on (b1.b_id = bp1.b_id) left outer join (b1 as b2 join bp2 on (b2.b_id = bp2.b_id)) on (bp1.p_id = bp2.p_id ) join bp21 on (b1.b_id = bp1.b_id) join bp31 on (b1.b_id = bp1.b_id) join bp41 on (b1.b_id = bp1.b_id) where b2.b_id = 0", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"JOI.008", Severity:"L4", Summary:"不要使用跨DB的Join查询", Content:"一般来说，跨DB的Join查询意味着查询语句跨越了两个不同的子系统，这可能意味着系统耦合度过高或库表结构设计不合理。", Case:"SELECT s,p,d FROM tbl WHERE p.p_id = (SELECT s.p_id FROM tbl WHERE s.c_id = 100996 AND s.q = 1 )", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"JOI.008", Severity:"L4", Summary:"不要使用跨数据库的 JOIN 查询", Content:"一般来说，跨数据库的 JOIN 查询意味着查询语句跨越了两个不同的子系统，这可能意味着系统耦合度过高或库表结构设计不合理。", Case:"SELECT s,p,d FROM tbl WHERE p.p_id = (SELECT s.p_id FROM tbl WHERE s.c_id = 100996 AND s.q = 1 )", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"KEY.001", Severity:"L2", Summary:"建议使用自增列作为主键，如使用联合自增主键时请将自增键作为第一列", Content:"建议使用自增列作为主键，如使用联合自增主键时请将自增键作为第一列", Case:"create table test(`id` int(11) NOT NULL PRIMARY KEY (`id`))", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"KEY.003", Severity:"L4", Summary:"避免外键等递归关系", Content:"存在递归关系的数据很常见，数据常会像树或者以层级方式组织。然而，创建一个外键约束来强制执行同一表中两列之间的关系，会导致笨拙的查询。树的每一层对应着另一个连接。您将需要发出递归查询，以获得节点的所有后代或所有祖先。解决方案是构造一个附加的闭包表。它记录了树中所有节点间的关系，而不仅仅是那些具有直接的父子关系。您也可以比较不同层次的数据设计：闭包表，路径枚举，嵌套集。然后根据应用程序的需要选择一个。", Case:"CREATE TABLE tab2 (p_id  BIGINT UNSIGNED NOT NULL,a_id  BIGINT UNSIGNED NOT NULL,PRIMARY KEY (p_id, a_id),FOREIGN KEY (p_id) REFERENCES tab1(p_id),FOREIGN KEY (a_id) REFERENCES tab3(a_id))", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"KEY.004", Severity:"L0", Summary:"提醒：请将索引属性顺序与查询对齐", Content:"如果为列创建复合索引，请确保查询属性与索引属性的顺序相同，以便DBMS在处理查询时使用索引。如果查询和索引属性订单没有对齐，那么DBMS可能无法在查询处理期间使用索引。", Case:"create index idx1 on tbl (last_name,first_name)", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"KEY.005", Severity:"L2", Summary:"表建的索引过多", Content:"表建的索引过多", Case:"CREATE TABLE tbl ( a int, b int, c int, KEY idx_a (`a`),KEY idx_b(`b`),KEY idx_c(`c`));", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"KEY.006", Severity:"L4", Summary:"主键中的列过多", Content:"主键中的列过多", Case:"CREATE TABLE tbl ( a int, b int, c int, PRIMARY KEY(`a`,`b`,`c`));", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"KEY.007", Severity:"L4", Summary:"未指定主键或主键非int或bigint", Content:"未指定主键或主键非int或bigint，建议将主键设置为int unsigned或bigint unsigned。", Case:"CREATE TABLE tbl (a int);", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"KEY.007", Severity:"L4", Summary:"未指定主键或主键非 int 或 bigint", Content:"未指定主键或主键非 int 或 bigint，建议将主键设置为 int unsigned 或 bigint unsigned。", Case:"CREATE TABLE tbl (a int);", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"KEY.008", Severity:"L4", Summary:"ORDER BY多个列但排序方向不同时可能无法使用索引", Content:"在MySQL 8.0之前当ORDER BY多个列指定的排序方向不同时将无法使用已经建立的索引。", Case:"SELECT * FROM tbl ORDER BY a DESC, b ASC;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"KEY.009", Severity:"L0", Summary:"添加唯一索引前请注意检查数据唯一性", Content:"请提前检查添加唯一索引列的数据唯一性，如果数据不唯一在线表结构调整时将有可能自动将重复列删除，这有可能导致数据丢失。", Case:"CREATE UNIQUE INDEX part_of_name ON customer (name(10));", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"KWR.001", Severity:"L2", Summary:"SQL_CALC_FOUND_ROWS效率低下", Content:"因为SQL_CALC_FOUND_ROWS不能很好地扩展，所以可能导致性能问题; 建议业务使用其他策略来替代SQL_CALC_FOUND_ROWS提供的计数功能，比如：分页结果展示等。", Case:"select SQL_CALC_FOUND_ROWS col from tbl where id>1000", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"KWR.001", Severity:"L2", Summary:"SQL_CALC_FOUND_ROWS 效率低下", Content:"因为SQL_CALC_FOUND_ROWS不能很好地扩展，所以可能导致性能问题; 建议业务使用其他策略来替代SQL_CALC_FOUND_ROWS提供的计数功能，比如：分页结果展示等。", Case:"select SQL_CALC_FOUND_ROWS col from tbl where id>1000", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"KWR.002", Severity:"L2", Summary:"不建议使用MySQL关键字做列名或表名", Content:"当使用关键字做为列名或表名时程序需要对列名和表名进行转义，如果疏忽被将导致请求无法执行。", Case:"CREATE TABLE tbl ( `select` int )", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"KWR.003", Severity:"L1", Summary:"不建议使用复数做列名或表名", Content:"表名应该仅仅表示表里面的实体内容，不应该表示实体数量，对应于 DO 类名也是单数形式，符合表达习惯。", Case:"CREATE TABLE tbl ( `books` int )", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"LCK.001", Severity:"L3", Summary:"INSERT INTO xx SELECT加锁粒度较大请谨慎", Content:"INSERT INTO xx SELECT加锁粒度较大请谨慎", Case:"INSERT INTO tbl SELECT * FROM tbl2;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
@@ -80,27 +80,27 @@ advisor.Rule{Item:"LCK.002", Severity:"L3", Summary:"请慎用INSERT ON DUPLICAT
 advisor.Rule{Item:"LIT.001", Severity:"L2", Summary:"用字符类型存储IP地址", Content:"字符串字面上看起来像IP地址，但不是INET_ATON()的参数，表示数据被存储为字符而不是整数。将IP地址存储为整数更为有效。", Case:"insert into tbl (IP,name) values('10.20.306.122','test')", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"LIT.002", Severity:"L4", Summary:"日期/时间未使用引号括起", Content:"诸如“WHERE col <2010-02-12”之类的查询是有效的SQL，但可能是一个错误，因为它将被解释为“WHERE col <1996”; 日期/时间文字应该加引号。", Case:"select col1,col2 from tbl where time < 2018-01-10", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"LIT.003", Severity:"L3", Summary:"一列中存储一系列相关数据的集合", Content:"将ID存储为一个列表，作为VARCHAR/TEXT列，这样能导致性能和数据完整性问题。查询这样的列需要使用模式匹配的表达式。使用逗号分隔的列表来做多表联结查询定位一行数据是极不优雅和耗时的。这将使验证ID更加困难。考虑一下，列表最多支持存放多少数据呢？将ID存储在一张单独的表中，代替使用多值属性，从而每个单独的属性值都可以占据一行。这样交叉表实现了两张表之间的多对多关系。这将更好地简化查询，也更有效地验证ID。", Case:"select c1,c2,c3,c4 from tab1 where col_id REGEXP '[[:<:]]12[[:>:]]'", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"LIT.004", Severity:"L1", Summary:"请使用分号或已设定的DELIMITER结尾", Content:"USE database, SHOW DATABASES等命令也需要使用使用分号或已设定的DELIMITER结尾。", Case:"USE db", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"LIT.004", Severity:"L1", Summary:"请使用分号或已设定的DELIMITER结尾", Content:"USE database, SHOW DATABASES 等命令也需要使用使用分号或已设定的 DELIMITER 结尾。", Case:"USE db", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"OK", Severity:"L0", Summary:"OK", Content:"OK", Case:"OK", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"RES.001", Severity:"L4", Summary:"非确定性的GROUP BY", Content:"SQL返回的列既不在聚合函数中也不是GROUP BY表达式的列中，因此这些值的结果将是非确定性的。如：select a, b, c from tbl where foo=\"bar\" group by a，该SQL返回的结果就是不确定的。", Case:"select c1,c2,c3 from t1 where c2='foo' group by c2", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"RES.002", Severity:"L4", Summary:"未使用ORDER BY的LIMIT查询", Content:"没有ORDER BY的LIMIT会导致非确定性的结果，这取决于查询执行计划。", Case:"select col1,col2 from tbl where name=xx limit 10", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"RES.002", Severity:"L4", Summary:"未使用 ORDER BY 的 LIMIT 查询", Content:"没有 ORDER BY 的 LIMIT 会导致非确定性的结果，这取决于查询执行计划。", Case:"select col1,col2 from tbl where name=xx limit 10", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"RES.003", Severity:"L4", Summary:"UPDATE/DELETE操作使用了LIMIT条件", Content:"UPDATE/DELETE操作使用LIMIT条件和不添加WHERE条件一样危险，它可将会导致主从数据不一致或从库同步中断。", Case:"UPDATE film SET length = 120 WHERE title = 'abc' LIMIT 1;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"RES.004", Severity:"L4", Summary:"UPDATE/DELETE操作指定了ORDER BY条件", Content:"UPDATE/DELETE操作不要指定ORDER BY条件。", Case:"UPDATE film SET length = 120 WHERE title = 'abc' ORDER BY title", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"RES.005", Severity:"L4", Summary:"UPDATE可能存在逻辑错误，导致数据损坏", Content:"在一条UPDATE语句中，如果要更新多个字段，字段间不能使用 AND ，而应该用逗号分隔。", Case:"update tbl set col = 1 and cl = 2 where col=3;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"RES.006", Severity:"L4", Summary:"永远不真的比较条件", Content:"查询条件永远非真，这将导致查询无匹配到的结果。", Case:"select * from tbl where 1 != 1;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"RES.007", Severity:"L4", Summary:"永远为真的比较条件", Content:"查询条件永远为真，这将导致WHERE条件失效进行全表查询。", Case:"select * from tbl where 1 = 1;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"RES.008", Severity:"L2", Summary:"不建议使用LOAD DATA/SELECT ... INTO OUTFILE", Content:"SELECT INTO OUTFILE需要授予FILE权限，这通过会引入安全问题。LOAD DATA虽然可以提高数据导入速度，但同时也可能导致从库同步延迟过大。", Case:"LOAD DATA INFILE 'data.txt' INTO TABLE db2.my_table;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"RES.007", Severity:"L4", Summary:"永远为真的比较条件", Content:"查询条件永远为真，可能导致 WHERE 条件失效进行全表查询。", Case:"select * from tbl where 1 = 1;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"RES.008", Severity:"L2", Summary:"不建议使用LOAD DATA/SELECT ... INTO OUTFILE", Content:"SELECT INTO OUTFILE 需要授予 FILE 权限，这通过会引入安全问题。LOAD DATA 虽然可以提高数据导入速度，但同时也可能导致从库同步延迟过大。", Case:"LOAD DATA INFILE 'data.txt' INTO TABLE db2.my_table;", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"SEC.001", Severity:"L0", Summary:"请谨慎使用TRUNCATE操作", Content:"一般来说想清空一张表最快速的做法就是使用TRUNCATE TABLE tbl_name;语句。但TRUNCATE操作也并非是毫无代价的，TRUNCATE TABLE无法返回被删除的准确行数，如果需要返回被删除的行数建议使用DELETE语法。TRUNCATE操作还会重置AUTO_INCREMENT，如果不想重置该值建议使用DELETE FROM tbl_name WHERE 1;替代。TRUNCATE操作会对数据字典添加源数据锁(MDL)，当一次需要TRUNCATE很多表时会影响整个实例的所有请求，因此如果要TRUNCATE多个表建议用DROP+CREATE的方式以减少锁时长。", Case:"TRUNCATE TABLE tbl_name", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"SEC.002", Severity:"L0", Summary:"不使用明文存储密码", Content:"使用明文存储密码或者使用明文在网络上传递密码都是不安全的。如果攻击者能够截获您用来插入密码的SQL语句，他们就能直接读到密码。另外，将用户输入的字符串以明文的形式插入到纯SQL语句中，也会让攻击者发现它。如果您能够读取密码，黑客也可以。解决方案是使用单向哈希函数对原始密码进行加密编码。哈希是指将输入字符串转化成另一个新的、不可识别的字符串的函数。对密码加密表达式加点随机串来防御“字典攻击”。不要将明文密码输入到SQL查询语句中。在应用程序代码中计算哈希串，只在SQL查询中使用哈希串。", Case:"create table test(id int,name varchar(20) not null,password varchar(200)not null)", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"SEC.003", Severity:"L0", Summary:"使用DELETE/DROP/TRUNCATE等操作时注意备份", Content:"在执行高危操作之前对数据进行备份是十分有必要的。", Case:"delete from table where col = 'condition'", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"STA.001", Severity:"L0", Summary:"'!=' 运算符是非标准的", Content:"\"<>\"才是标准SQL中的不等于运算符。", Case:"select col1,col2 from tbl where type!=0", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"STA.002", Severity:"L1", Summary:"库名或表名点后建议不要加空格", Content:"当使用db.table或table.column格式访问表或字段时，请不要在点号后面添加空格，虽然这样语法正确。", Case:"select col from sakila. film", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"STA.002", Severity:"L1", Summary:"库名或表名点后建议不要加空格", Content:"当使用 db.table 或 table.column 格式访问表或字段时，请不要在点号后面添加空格，虽然这样语法正确。", Case:"select col from sakila. film", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"STA.003", Severity:"L1", Summary:"索引起名不规范", Content:"建议普通二级索引以idx_为前缀，唯一索引以uk_为前缀。", Case:"select col from now where type!=0", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"STA.004", Severity:"L1", Summary:"起名时请不要使用字母、数字和下划线之外的字符", Content:"以字母或下划线开头，名字只允许使用字母、数字和下划线。请统一大小写，不要使用驼峰命名法。不要在名字中出现连续下划线'__'，这样很难辨认。", Case:"CREATE TABLE ` abc` (a int);", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"SUB.002", Severity:"L2", Summary:"如果您不在乎重复的话，建议使用UNION ALL替代UNION", Content:"与去除重复的UNION不同，UNION ALL允许重复元组。如果您不关心重复元组，那么使用UNION ALL将是一个更快的选项。", Case:"select teacher_id as id,people_name as name from t1,t2 where t1.teacher_id=t2.people_id union select student_id as id,people_name as name from t1,t2 where t1.student_id=t2.people_id", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"SUB.003", Severity:"L3", Summary:"考虑使用EXISTS而不是DISTINCT子查询", Content:"DISTINCT关键字在对元组排序后删除重复。相反，考虑使用一个带有EXISTS关键字的子查询，您可以避免返回整个表。", Case:"SELECT DISTINCT c.c_id, c.c_name FROM c,e WHERE e.c_id = c.c_id", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"SUB.002", Severity:"L2", Summary:"如果您不在乎重复的话，建议使用 UNION ALL 替代 UNION", Content:"与去除重复的UNION不同，UNION ALL允许重复元组。如果您不关心重复元组，那么使用UNION ALL将是一个更快的选项。", Case:"select teacher_id as id,people_name as name from t1,t2 where t1.teacher_id=t2.people_id union select student_id as id,people_name as name from t1,t2 where t1.student_id=t2.people_id", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"SUB.003", Severity:"L3", Summary:"考虑使用 EXISTS 而不是 DISTINCT 子查询", Content:"DISTINCT 关键字在对元组排序后删除重复。相反，考虑使用一个带有 EXISTS 关键字的子查询，您可以避免返回整个表。", Case:"SELECT DISTINCT c.c_id, c.c_name FROM c,e WHERE e.c_id = c.c_id", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"SUB.004", Severity:"L3", Summary:"执行计划中嵌套连接深度过深", Content:"MySQL对子查询的优化效果不佳,MySQL将外部查询中的每一行作为依赖子查询执行子查询。 这是导致严重性能问题的常见原因。", Case:"SELECT * from tb where id in (select id from (select id from tb))", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
-advisor.Rule{Item:"SUB.005", Severity:"L8", Summary:"子查询不支持LIMIT", Content:"当前MySQL版本不支持在子查询中进行'LIMIT & IN/ALL/ANY/SOME'。", Case:"SELECT * FROM staff WHERE name IN (SELECT NAME FROM customer ORDER BY name LIMIT 1)", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
+advisor.Rule{Item:"SUB.005", Severity:"L8", Summary:"子查询不支持LIMIT", Content:"当前 MySQL 版本不支持在子查询中进行 'LIMIT & IN/ALL/ANY/SOME'。", Case:"SELECT * FROM staff WHERE name IN (SELECT NAME FROM customer ORDER BY name LIMIT 1)", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"SUB.006", Severity:"L2", Summary:"不建议在子查询中使用函数", Content:"MySQL将外部查询中的每一行作为依赖子查询执行子查询，如果在子查询中使用函数，即使是semi-join也很难进行高效的查询。可以将子查询重写为OUTER JOIN语句并用连接条件对数据进行过滤。", Case:"SELECT * FROM staff WHERE name IN (SELECT max(NAME) FROM customer)", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"TBL.001", Severity:"L4", Summary:"不建议使用分区表", Content:"不建议使用分区表", Case:"CREATE TABLE trb3(id INT, name VARCHAR(50), purchased DATE) PARTITION BY RANGE(YEAR(purchased)) (PARTITION p0 VALUES LESS THAN (1990), PARTITION p1 VALUES LESS THAN (1995), PARTITION p2 VALUES LESS THAN (2000), PARTITION p3 VALUES LESS THAN (2005) );", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
 advisor.Rule{Item:"TBL.002", Severity:"L4", Summary:"请为表选择合适的存储引擎", Content:"建表或修改表的存储引擎时建议使用推荐的存储引擎，如：innodb", Case:"create table test(`id` int(11) NOT NULL AUTO_INCREMENT)", Position:0, Func:func(*advisor.Query4Audit) advisor.Rule {...}}
diff --git a/doc/heuristic.md b/doc/heuristic.md
index 2a03fab09cafa69491c687598ba4446214a182d1..6fec346fef0802cee2db18f1b5e1a4043faa7703 100644
--- a/doc/heuristic.md
+++ b/doc/heuristic.md
@@ -116,7 +116,7 @@ SELECT * FROM tb WHERE col IN (NULL);
 
 * **Item**:ARG.005
 * **Severity**:L1
-* **Content**: 如：select id from t where num in(1,2,3)对于连续的数值，能用BETWEEN就不要用IN了：select id from t where num between 1 and 3。而当IN值过多时MySQL也可能会进入全表扫描导致性能急剧下降。
+* **Content**: 如：select id from t where num in(1,2,3)对于连续的数值，能用 BETWEEN 就不要用 IN 了：select id from t where num between 1 and 3。而当IN值过多时MySQL也可能会进入全表扫描导致性能急剧下降。
 * **Case**:
 
 ```sql
@@ -136,13 +136,13 @@ select id from t where num is null
 
 * **Item**:ARG.007
 * **Severity**:L3
-* **Content**:性能问题是使用模式匹配操作符的最大缺点。使用LIKE或正则表达式进行模式匹配进行查询的另一个问题，是可能会返回意料之外的结果。最好的方案就是使用特殊的搜索引擎技术来替代SQL，比如Apache Lucene。另一个可选方案是将结果保存起来从而减少重复的搜索开销。如果一定要使用SQL，请考虑在MySQL中使用像FULLTEXT索引这样的第三方扩展。但更广泛地说，您不一定要使用SQL来解决所有问题。
+* **Content**:性能问题是使用模式匹配操作符的最大缺点。使用LIKE或正则表达式进行模式匹配进行查询的另一个问题，是可能会返回意料之外的结果。最好的方案就是使用特殊的搜索引擎技术来替代SQL，比如 Apache Lucene。另一个可选方案是将结果保存起来从而减少重复的搜索开销。如果一定要使用SQL，请考虑在 MySQL 中使用像 FULLTEXT 索引这样的第三方扩展。但更广泛地说，您不一定要使用SQL来解决所有问题。
 * **Case**:
 
 ```sql
 select c_id,c2,c3 from tbl where c2 like 'test%'
 ```
-## OR查询索引列时请尽量使用IN谓词
+## OR 查询索引列时请尽量使用 IN 谓词
 
 * **Item**:ARG.008
 * **Severity**:L1
@@ -156,7 +156,7 @@ SELECT c1,c2,c3 FROM tbl WHERE c1 = 14 OR c1 = 17
 
 * **Item**:ARG.009
 * **Severity**:L1
-* **Content**:如果VARCHAR列的前后存在空格将可能引起逻辑问题，如在MySQL 5.5中'a'和'a '可能会在查询中被认为是相同的值。
+* **Content**:如果VARCHAR列的前后存在空格将可能引起逻辑问题，如在MySQL 5.5中 'a' 和 'a ' 可能会在查询中被认为是相同的值。
 * **Case**:
 
 ```sql
@@ -166,7 +166,7 @@ SELECT 'abc '
 
 * **Item**:ARG.010
 * **Severity**:L1
-* **Content**:hint是用来强制SQL按照某个执行计划来执行，但随着数据量变化我们无法保证自己当初的预判是正确的。
+* **Content**:hint 是用来强制 SQL 按照某个执行计划来执行，但随着数据量变化我们无法保证自己当初的预判是正确的。
 * **Case**:
 
 ```sql
@@ -536,23 +536,23 @@ SELECT COUNT(DISTINCT col, col2) FROM tbl;
 
 * **Item**:DIS.003
 * **Severity**:L3
-* **Content**:当表已经有主键时，对所有列进行DISTINCT的输出结果与不进行DISTINCT操作的结果相同，请不要画蛇添足。
+* **Content**:当表已经有主键时，对所有列进行 DISTINCT 的输出结果与不进行 DISTINCT 操作的结果相同，请不要画蛇添足。
 * **Case**:
 
 ```sql
 SELECT DISTINCT * FROM film;
 ```
-## 避免在WHERE条件中使用函数或其他运算符
+## 避免在 WHERE 条件中使用函数或其他运算符
 
 * **Item**:FUN.001
 * **Severity**:L2
-* **Content**:虽然在SQL中使用函数可以简化很多复杂的查询，但使用了函数的查询无法利用表中已经建立的索引，该查询将会是全表扫描，性能较差。通常建议将列名写在比较运算符左侧，将查询过滤条件放在比较运算符右侧。
+* **Content**:虽然在 SQL 中使用函数可以简化很多复杂的查询，但使用了函数的查询无法利用表中已经建立的索引，该查询将会是全表扫描，性能较差。通常建议将列名写在比较运算符左侧，将查询过滤条件放在比较运算符右侧。也不建议在查询比较条件两侧书写多余的括号，这会对阅读产生比较大的困扰。
 * **Case**:
 
 ```sql
 select id from t where substring(name,1,3)='abc'
 ```
-## 指定了WHERE条件或非MyISAM引擎时使用COUNT(\*)操作性能不佳
+## 指定了 WHERE 条件或非 MyISAM 引擎时使用 COUNT(\*) 操作性能不佳
 
 * **Item**:FUN.002
 * **Severity**:L1
@@ -606,13 +606,13 @@ SELECT SUM(COL) FROM tbl;
 
 * **Item**:GRP.001
 * **Severity**:L2
-* **Content**:GROUP BY中的列在前面的WHERE条件中使用了等值查询，对这样的列进行GROUP BY意义不大。
+* **Content**:GROUP BY 中的列在前面的 WHERE 条件中使用了等值查询，对这样的列进行GROUP BY意义不大。
 * **Case**:
 
 ```sql
 select film_id, title from film where release_year='2006' group by release_year
 ```
-## JOIN语句混用逗号和ANSI模式
+## JOIN 语句混用逗号和 ANSI 模式
 
 * **Item**:JOI.001
 * **Severity**:L2
@@ -636,7 +636,7 @@ select tb1.col from (tb1, tb2) join tb2 on tb1.id=tb.id where tb1.id=1
 
 * **Item**:JOI.003
 * **Severity**:L4
-* **Content**:由于WHERE条件错误使得OUTER JOIN的外部表无数据返回，这会将查询隐式转换为 INNER JOIN 。如：select c from L left join R using(c) where L.a=5 and R.b=10。这种SQL逻辑上可能存在错误或程序员对OUTER JOIN如何工作存在误解，因为LEFT/RIGHT JOIN是LEFT/RIGHT OUTER JOIN的缩写。
+* **Content**:由于 WHERE 条件错误使得 OUTER JOIN 的外部表无数据返回，这会将查询隐式转换为 INNER JOIN 。如：select c from L left join R using(c) where L.a=5 and R.b=10。这种SQL逻辑上可能存在错误或程序员对OUTER JOIN如何工作存在误解，因为LEFT/RIGHT JOIN是LEFT/RIGHT OUTER JOIN的缩写。
 * **Case**:
 
 ```sql
@@ -646,7 +646,7 @@ select c1,c2,c3 from t1 left outer join t2 using(c1) where t1.c2=2 and t2.c3=4
 
 * **Item**:JOI.004
 * **Severity**:L4
-* **Content**:只在右侧表为NULL的带WHERE子句的LEFT OUTER JOIN语句，有可能是在WHERE子句中使用错误的列，如：“... FROM l LEFT OUTER JOIN r ON l.l = r.r WHERE r.z IS NULL”，这个查询正确的逻辑可能是 WHERE r.r IS NULL。
+* **Content**:只在右侧表为 NULL 的带 WHERE 子句的LEFT OUTER JOIN语句，有可能是在WHERE子句中使用错误的列，如：“... FROM l LEFT OUTER JOIN r ON l.l = r.r WHERE r.z IS NULL”，这个查询正确的逻辑可能是 WHERE r.r IS NULL。
 * **Case**:
 
 ```sql
@@ -666,7 +666,7 @@ select bp1.p_id, b1.d_d as l, b1.b_id from b1 join bp1 on (b1.b_id = bp1.b_id) l
 
 * **Item**:JOI.006
 * **Severity**:L4
-* **Content**:一般来说，非嵌套子查询总是用于关联子查询，最多是来自FROM子句中的一个表，这些子查询用于ANY、ALL和EXISTS的谓词。如果可以根据查询语义决定子查询最多返回一个行，那么一个不相关的子查询或来自FROM子句中的多个表的子查询就被压平了。
+* **Content**:一般来说，非嵌套子查询总是用于关联子查询，最多是来自FROM子句中的一个表，这些子查询用于 ANY, ALL 和 EXISTS 的谓词。如果可以根据查询语义决定子查询最多返回一个行，那么一个不相关的子查询或来自FROM子句中的多个表的子查询就被压平了。
 * **Case**:
 
 ```sql
@@ -682,11 +682,11 @@ SELECT s,p,d FROM tbl WHERE p.p_id = (SELECT s.p_id FROM tbl WHERE s.c_id = 1009
 ```sql
 UPDATE users u LEFT JOIN hobby h ON u.id = h.uid SET u.name = 'pianoboy' WHERE h.hobby = 'piano';
 ```
-## 不要使用跨DB的Join查询
+## 不要使用跨数据库的 JOIN 查询
 
 * **Item**:JOI.008
 * **Severity**:L4
-* **Content**:一般来说，跨DB的Join查询意味着查询语句跨越了两个不同的子系统，这可能意味着系统耦合度过高或库表结构设计不合理。
+* **Content**:一般来说，跨数据库的 JOIN 查询意味着查询语句跨越了两个不同的子系统，这可能意味着系统耦合度过高或库表结构设计不合理。
 * **Case**:
 
 ```sql
@@ -752,11 +752,11 @@ CREATE TABLE tbl ( a int, b int, c int, KEY idx_a (`a`),KEY idx_b(`b`),KEY idx_c
 ```sql
 CREATE TABLE tbl ( a int, b int, c int, PRIMARY KEY(`a`,`b`,`c`));
 ```
-## 未指定主键或主键非int或bigint
+## 未指定主键或主键非 int 或 bigint
 
 * **Item**:KEY.007
 * **Severity**:L4
-* **Content**:未指定主键或主键非int或bigint，建议将主键设置为int unsigned或bigint unsigned。
+* **Content**:未指定主键或主键非 int 或 bigint，建议将主键设置为 int unsigned 或 bigint unsigned。
 * **Case**:
 
 ```sql
@@ -782,7 +782,7 @@ SELECT * FROM tbl ORDER BY a DESC, b ASC;
 ```sql
 CREATE UNIQUE INDEX part_of_name ON customer (name(10));
 ```
-## SQL\_CALC\_FOUND\_ROWS效率低下
+## SQL\_CALC\_FOUND\_ROWS 效率低下
 
 * **Item**:KWR.001
 * **Severity**:L2
@@ -866,7 +866,7 @@ select c1,c2,c3,c4 from tab1 where col_id REGEXP '[[:<:]]12[[:>:]]'
 
 * **Item**:LIT.004
 * **Severity**:L1
-* **Content**:USE database, SHOW DATABASES等命令也需要使用使用分号或已设定的DELIMITER结尾。
+* **Content**:USE database, SHOW DATABASES 等命令也需要使用使用分号或已设定的 DELIMITER 结尾。
 * **Case**:
 
 ```sql
@@ -882,11 +882,11 @@ USE db
 ```sql
 select c1,c2,c3 from t1 where c2='foo' group by c2
 ```
-## 未使用ORDER BY的LIMIT查询
+## 未使用 ORDER BY 的 LIMIT 查询
 
 * **Item**:RES.002
 * **Severity**:L4
-* **Content**:没有ORDER BY的LIMIT会导致非确定性的结果，这取决于查询执行计划。
+* **Content**:没有 ORDER BY 的 LIMIT 会导致非确定性的结果，这取决于查询执行计划。
 * **Case**:
 
 ```sql
@@ -936,7 +936,7 @@ select * from tbl where 1 != 1;
 
 * **Item**:RES.007
 * **Severity**:L4
-* **Content**:查询条件永远为真，这将导致WHERE条件失效进行全表查询。
+* **Content**:查询条件永远为真，可能导致 WHERE 条件失效进行全表查询。
 * **Case**:
 
 ```sql
@@ -946,7 +946,7 @@ select * from tbl where 1 = 1;
 
 * **Item**:RES.008
 * **Severity**:L2
-* **Content**:SELECT INTO OUTFILE需要授予FILE权限，这通过会引入安全问题。LOAD DATA虽然可以提高数据导入速度，但同时也可能导致从库同步延迟过大。
+* **Content**:SELECT INTO OUTFILE 需要授予 FILE 权限，这通过会引入安全问题。LOAD DATA 虽然可以提高数据导入速度，但同时也可能导致从库同步延迟过大。
 * **Case**:
 
 ```sql
@@ -996,7 +996,7 @@ select col1,col2 from tbl where type!=0
 
 * **Item**:STA.002
 * **Severity**:L1
-* **Content**:当使用db.table或table.column格式访问表或字段时，请不要在点号后面添加空格，虽然这样语法正确。
+* **Content**:当使用 db.table 或 table.column 格式访问表或字段时，请不要在点号后面添加空格，虽然这样语法正确。
 * **Case**:
 
 ```sql
@@ -1032,7 +1032,7 @@ CREATE TABLE ` abc` (a int);
 ```sql
 select col1,col2,col3 from table1 where col2 in(select col from table2)
 ```
-## 如果您不在乎重复的话，建议使用UNION ALL替代UNION
+## 如果您不在乎重复的话，建议使用 UNION ALL 替代 UNION
 
 * **Item**:SUB.002
 * **Severity**:L2
@@ -1042,11 +1042,11 @@ select col1,col2,col3 from table1 where col2 in(select col from table2)
 ```sql
 select teacher_id as id,people_name as name from t1,t2 where t1.teacher_id=t2.people_id union select student_id as id,people_name as name from t1,t2 where t1.student_id=t2.people_id
 ```
-## 考虑使用EXISTS而不是DISTINCT子查询
+## 考虑使用 EXISTS 而不是 DISTINCT 子查询
 
 * **Item**:SUB.003
 * **Severity**:L3
-* **Content**:DISTINCT关键字在对元组排序后删除重复。相反，考虑使用一个带有EXISTS关键字的子查询，您可以避免返回整个表。
+* **Content**:DISTINCT 关键字在对元组排序后删除重复。相反，考虑使用一个带有 EXISTS 关键字的子查询，您可以避免返回整个表。
 * **Case**:
 
 ```sql
@@ -1066,7 +1066,7 @@ SELECT * from tb where id in (select id from (select id from tb))
 
 * **Item**:SUB.005
 * **Severity**:L8
-* **Content**:当前MySQL版本不支持在子查询中进行'LIMIT & IN/ALL/ANY/SOME'。
+* **Content**:当前 MySQL 版本不支持在子查询中进行 'LIMIT & IN/ALL/ANY/SOME'。
 * **Case**:
 
 ```sql
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 64fb2dbceb0a2a5dd4ba3a72e7cfea1cdaf3885b..3765fc7fbfd9b0b9cdade88611a711a3c8989a01 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -1016,68 +1016,68 @@
 		{
 			"checksumSHA1": "w8FCRjH70gM6QttB9QrEh9Y1x64=",
 			"path": "vitess.io/vitess",
-			"revision": "5b3aedd79bd1488060ae5c0551b31685892c6eed",
-			"revisionTime": "2018-11-14T21:08:06Z"
+			"revision": "088b121f3ef2d0f0631499fcdf77eed9b701b5fe",
+			"revisionTime": "2018-11-16T06:46:05Z"
 		},
 		{
 			"checksumSHA1": "aKn1oKcY74N8TRLm3Ayt7Q4bbI4=",
 			"path": "vitess.io/vitess/go/bytes2",
-			"revision": "5b3aedd79bd1488060ae5c0551b31685892c6eed",
-			"revisionTime": "2018-11-14T21:08:06Z"
+			"revision": "088b121f3ef2d0f0631499fcdf77eed9b701b5fe",
+			"revisionTime": "2018-11-16T06:46:05Z"
 		},
 		{
 			"checksumSHA1": "JVCEN4UGRmg3TofIBdzZMZ3G0Ww=",
 			"path": "vitess.io/vitess/go/hack",
-			"revision": "5b3aedd79bd1488060ae5c0551b31685892c6eed",
-			"revisionTime": "2018-11-14T21:08:06Z"
+			"revision": "088b121f3ef2d0f0631499fcdf77eed9b701b5fe",
+			"revisionTime": "2018-11-16T06:46:05Z"
 		},
 		{
 			"checksumSHA1": "e1WJ7vCnVrlQQQlc6n/FewCDMso=",
 			"path": "vitess.io/vitess/go/sqltypes",
-			"revision": "5b3aedd79bd1488060ae5c0551b31685892c6eed",
-			"revisionTime": "2018-11-14T21:08:06Z"
+			"revision": "088b121f3ef2d0f0631499fcdf77eed9b701b5fe",
+			"revisionTime": "2018-11-16T06:46:05Z"
 		},
 		{
 			"checksumSHA1": "ntFIQYkBS51G6y+FEkjFW40+HOU=",
 			"path": "vitess.io/vitess/go/vt/log",
-			"revision": "5b3aedd79bd1488060ae5c0551b31685892c6eed",
-			"revisionTime": "2018-11-14T21:08:06Z"
+			"revision": "088b121f3ef2d0f0631499fcdf77eed9b701b5fe",
+			"revisionTime": "2018-11-16T06:46:05Z"
 		},
 		{
 			"checksumSHA1": "XozR8bmeSR5KTe/nlUJkpJY2HKI=",
 			"path": "vitess.io/vitess/go/vt/proto/query",
-			"revision": "5b3aedd79bd1488060ae5c0551b31685892c6eed",
-			"revisionTime": "2018-11-14T21:08:06Z"
+			"revision": "088b121f3ef2d0f0631499fcdf77eed9b701b5fe",
+			"revisionTime": "2018-11-16T06:46:05Z"
 		},
 		{
 			"checksumSHA1": "OnWsUHLDKcO3spwH0jD55SvKD24=",
 			"path": "vitess.io/vitess/go/vt/proto/topodata",
-			"revision": "5b3aedd79bd1488060ae5c0551b31685892c6eed",
-			"revisionTime": "2018-11-14T21:08:06Z"
+			"revision": "088b121f3ef2d0f0631499fcdf77eed9b701b5fe",
+			"revisionTime": "2018-11-16T06:46:05Z"
 		},
 		{
 			"checksumSHA1": "sBAuZ/itMR8U8qbK4yLHxkP6Cpc=",
 			"path": "vitess.io/vitess/go/vt/proto/vtgate",
-			"revision": "5b3aedd79bd1488060ae5c0551b31685892c6eed",
-			"revisionTime": "2018-11-14T21:08:06Z"
+			"revision": "088b121f3ef2d0f0631499fcdf77eed9b701b5fe",
+			"revisionTime": "2018-11-16T06:46:05Z"
 		},
 		{
 			"checksumSHA1": "pLWM+SPGZs3k+IhjktE/cGUlpM0=",
 			"path": "vitess.io/vitess/go/vt/proto/vtrpc",
-			"revision": "5b3aedd79bd1488060ae5c0551b31685892c6eed",
-			"revisionTime": "2018-11-14T21:08:06Z"
+			"revision": "088b121f3ef2d0f0631499fcdf77eed9b701b5fe",
+			"revisionTime": "2018-11-16T06:46:05Z"
 		},
 		{
 			"checksumSHA1": "3ggEFYVEhMPxyhkKhRGw3x1eZ9M=",
 			"path": "vitess.io/vitess/go/vt/sqlparser",
-			"revision": "5b3aedd79bd1488060ae5c0551b31685892c6eed",
-			"revisionTime": "2018-11-14T21:08:06Z"
+			"revision": "088b121f3ef2d0f0631499fcdf77eed9b701b5fe",
+			"revisionTime": "2018-11-16T06:46:05Z"
 		},
 		{
 			"checksumSHA1": "oF4XzuOzwvj1iduX/lYqNSyY/HM=",
 			"path": "vitess.io/vitess/go/vt/vterrors",
-			"revision": "5b3aedd79bd1488060ae5c0551b31685892c6eed",
-			"revisionTime": "2018-11-14T21:08:06Z"
+			"revision": "088b121f3ef2d0f0631499fcdf77eed9b701b5fe",
+			"revisionTime": "2018-11-16T06:46:05Z"
 		}
 	],
 	"rootPath": "github.com/XiaoMi/soar"