Merge release-3.0 to release-3.1

bindinfo/bind.go

@@ -15,155 +15,62 @@ package bindinfo
 
 import "github.com/pingcap/parser/ast"
 
-// BindHint will add hints for originStmt according to hintedStmt' hints.
-func BindHint(originStmt, hintedStmt ast.StmtNode) ast.StmtNode {
-	switch x := originStmt.(type) {
-	case *ast.SelectStmt:
-		return selectBind(x, hintedStmt.(*ast.SelectStmt))
-	default:
-		return originStmt
-	}
-}
-
-func selectBind(originalNode, hintedNode *ast.SelectStmt) *ast.SelectStmt {
-	if hintedNode.TableHints != nil {
-		originalNode.TableHints = hintedNode.TableHints
-	}
-	if originalNode.From != nil {
-		originalNode.From.TableRefs = resultSetNodeBind(originalNode.From.TableRefs, hintedNode.From.TableRefs).(*ast.Join)
-	}
-	if originalNode.Where != nil {
-		originalNode.Where = exprBind(originalNode.Where, hintedNode.Where).(ast.ExprNode)
-	}
-
-	if originalNode.Having != nil {
-		originalNode.Having.Expr = exprBind(originalNode.Having.Expr, hintedNode.Having.Expr)
-	}
-
-	if originalNode.OrderBy != nil {
-		originalNode.OrderBy = orderByBind(originalNode.OrderBy, hintedNode.OrderBy)
-	}
-
-	if originalNode.Fields != nil {
-		origFields := originalNode.Fields.Fields
-		hintFields := hintedNode.Fields.Fields
-		for idx := range origFields {
-			origFields[idx].Expr = exprBind(origFields[idx].Expr, hintFields[idx].Expr)
-		}
-	}
-	return originalNode
+// HintsSet contains all hints of a query.
+type HintsSet struct {
+	tableHints [][]*ast.TableOptimizerHint // Slice offset is the traversal order of `SelectStmt` in the ast.
+	indexHints [][]*ast.IndexHint          // Slice offset is the traversal order of `TableName` in the ast.
 }
 
-func orderByBind(originalNode, hintedNode *ast.OrderByClause) *ast.OrderByClause {
-	for idx := 0; idx < len(originalNode.Items); idx++ {
-		originalNode.Items[idx].Expr = exprBind(originalNode.Items[idx].Expr, hintedNode.Items[idx].Expr)
-	}
-	return originalNode
+type hintProcessor struct {
+	*HintsSet
+	// bindHint2Ast indicates the behavior of the processor, `true` for bind hint to ast, `false` for extract hint from ast.
+	bindHint2Ast bool
+	tableCounter int
+	indexCounter int
 }
 
-func exprBind(originalNode, hintedNode ast.ExprNode) ast.ExprNode {
-	switch v := originalNode.(type) {
-	case *ast.SubqueryExpr:
-		if v.Query != nil {
-			v.Query = resultSetNodeBind(v.Query, hintedNode.(*ast.SubqueryExpr).Query)
-		}
-	case *ast.ExistsSubqueryExpr:
-		if v.Sel != nil {
-			v.Sel.(*ast.SubqueryExpr).Query = resultSetNodeBind(v.Sel.(*ast.SubqueryExpr).Query, hintedNode.(*ast.ExistsSubqueryExpr).Sel.(*ast.SubqueryExpr).Query)
-		}
-	case *ast.PatternInExpr:
-		if v.Sel != nil {
-			v.Sel.(*ast.SubqueryExpr).Query = resultSetNodeBind(v.Sel.(*ast.SubqueryExpr).Query, hintedNode.(*ast.PatternInExpr).Sel.(*ast.SubqueryExpr).Query)
-		}
-	case *ast.BinaryOperationExpr:
-		if v.L != nil {
-			v.L = exprBind(v.L, hintedNode.(*ast.BinaryOperationExpr).L)
-		}
-		if v.R != nil {
-			v.R = exprBind(v.R, hintedNode.(*ast.BinaryOperationExpr).R)
-		}
-	case *ast.IsNullExpr:
-		if v.Expr != nil {
-			v.Expr = exprBind(v.Expr, hintedNode.(*ast.IsNullExpr).Expr)
-		}
-	case *ast.IsTruthExpr:
-		if v.Expr != nil {
-			v.Expr = exprBind(v.Expr, hintedNode.(*ast.IsTruthExpr).Expr)
-		}
-	case *ast.PatternLikeExpr:
-		if v.Pattern != nil {
-			v.Pattern = exprBind(v.Pattern, hintedNode.(*ast.PatternLikeExpr).Pattern)
-		}
-	case *ast.CompareSubqueryExpr:
-		if v.L != nil {
-			v.L = exprBind(v.L, hintedNode.(*ast.CompareSubqueryExpr).L)
-		}
-		if v.R != nil {
-			v.R = exprBind(v.R, hintedNode.(*ast.CompareSubqueryExpr).R)
-		}
-	case *ast.BetweenExpr:
-		if v.Left != nil {
-			v.Left = exprBind(v.Left, hintedNode.(*ast.BetweenExpr).Left)
-		}
-		if v.Right != nil {
-			v.Right = exprBind(v.Right, hintedNode.(*ast.BetweenExpr).Right)
-		}
-	case *ast.UnaryOperationExpr:
-		if v.V != nil {
-			v.V = exprBind(v.V, hintedNode.(*ast.UnaryOperationExpr).V)
-		}
-	case *ast.CaseExpr:
-		if v.Value != nil {
-			v.Value = exprBind(v.Value, hintedNode.(*ast.CaseExpr).Value)
-		}
-		if v.ElseClause != nil {
-			v.ElseClause = exprBind(v.ElseClause, hintedNode.(*ast.CaseExpr).ElseClause)
+func (hp *hintProcessor) Enter(in ast.Node) (ast.Node, bool) {
+	switch v := in.(type) {
+	case *ast.SelectStmt:
+		if hp.bindHint2Ast {
+			if hp.tableCounter < len(hp.tableHints) {
+				v.TableHints = hp.tableHints[hp.tableCounter]
+			} else {
+				v.TableHints = nil
+			}
+			hp.tableCounter++
+		} else {
+			hp.tableHints = append(hp.tableHints, v.TableHints)
+		}
+	case *ast.TableName:
+		if hp.bindHint2Ast {
+			if hp.indexCounter < len(hp.indexHints) {
+				v.IndexHints = hp.indexHints[hp.indexCounter]
+			} else {
+				v.IndexHints = nil
+			}
+			hp.indexCounter++
+		} else {
+			hp.indexHints = append(hp.indexHints, v.IndexHints)
 		}
 	}
-	return originalNode
+	return in, false
 }
 
-func resultSetNodeBind(originalNode, hintedNode ast.ResultSetNode) ast.ResultSetNode {
-	switch x := originalNode.(type) {
-	case *ast.Join:
-		return joinBind(x, hintedNode.(*ast.Join))
-	case *ast.TableSource:
-		ts, _ := hintedNode.(*ast.TableSource)
-		switch v := x.Source.(type) {
-		case *ast.SelectStmt:
-			x.Source = selectBind(v, ts.Source.(*ast.SelectStmt))
-		case *ast.UnionStmt:
-			x.Source = unionSelectBind(v, hintedNode.(*ast.TableSource).Source.(*ast.UnionStmt))
-		case *ast.TableName:
-			x.Source.(*ast.TableName).IndexHints = ts.Source.(*ast.TableName).IndexHints
-		}
-		return x
-	case *ast.SelectStmt:
-		return selectBind(x, hintedNode.(*ast.SelectStmt))
-	case *ast.UnionStmt:
-		return unionSelectBind(x, hintedNode.(*ast.UnionStmt))
-	default:
-		return x
-	}
+func (hp *hintProcessor) Leave(in ast.Node) (ast.Node, bool) {
+	return in, true
 }
 
-func joinBind(originalNode, hintedNode *ast.Join) *ast.Join {
-	if originalNode.Left != nil {
-		originalNode.Left = resultSetNodeBind(originalNode.Left, hintedNode.Left)
-	}
-
-	if hintedNode.Right != nil {
-		originalNode.Right = resultSetNodeBind(originalNode.Right, hintedNode.Right)
-	}
-
-	return originalNode
+// CollectHint collects hints for a statement.
+func CollectHint(in ast.StmtNode) *HintsSet {
+	hp := hintProcessor{HintsSet: &HintsSet{tableHints: make([][]*ast.TableOptimizerHint, 0, 4), indexHints: make([][]*ast.IndexHint, 0, 4)}}
+	in.Accept(&hp)
+	return hp.HintsSet
 }
 
-func unionSelectBind(originalNode, hintedNode *ast.UnionStmt) ast.ResultSetNode {
-	selects := originalNode.SelectList.Selects
-	for i := len(selects) - 1; i >= 0; i-- {
-		originalNode.SelectList.Selects[i] = selectBind(selects[i], hintedNode.SelectList.Selects[i])
-	}
-
-	return originalNode
+// BindHint will add hints for stmt according to the hints in `hintsSet`.
+func BindHint(stmt ast.StmtNode, hintsSet *HintsSet) ast.StmtNode {
+	hp := hintProcessor{HintsSet: hintsSet, bindHint2Ast: true}
+	stmt.Accept(&hp)
+	return stmt
 }

bindinfo/bind_test.go

@@ -22,6 +22,7 @@ import (
 
 	. "github.com/pingcap/check"
 	"github.com/pingcap/parser"
+	"github.com/pingcap/parser/auth"
 	"github.com/pingcap/tidb/bindinfo"
 	"github.com/pingcap/tidb/domain"
 	"github.com/pingcap/tidb/kv"
@@ -137,9 +138,9 @@ func (s *testSuite) TestBindParse(c *C) {
 	c.Check(bindData.UpdateTime, NotNil)
 
 	// Test fields with quotes or slashes.
-	sql = `CREATE GLOBAL BINDING FOR  select * from t where a BETWEEN "a" and "b" USING select * from t use index(idx) where a BETWEEN "a\nb\rc\td\0e" and 'x'`
+	sql = `CREATE GLOBAL BINDING FOR  select * from t where i BETWEEN "a" and "b" USING select * from t use index(index_t) where i BETWEEN "a\nb\rc\td\0e" and 'x'`
 	tk.MustExec(sql)
-	tk.MustExec(`DROP global binding for select * from t use index(idx) where a BETWEEN "a\nb\rc\td\0e" and "x"`)
+	tk.MustExec(`DROP global binding for select * from t use index(index_t) where i BETWEEN "a\nb\rc\td\0e" and "x"`)
 }
 
 func (s *testSuite) TestGlobalBinding(c *C) {
@@ -378,6 +379,19 @@ func (s *testSuite) TestGlobalAndSessionBindingBothExist(c *C) {
 		"  └─Selection_14 9990.00 cop[tikv] not(isnull(test.t2.id))",
 		"    └─TableScan_13 10000.00 cop[tikv] table:t2, range:[-inf,+inf], keep order:false, stats:pseudo",
 	))
+
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a int, b int, index idx(a))")
+	tk.MustQuery("explain select * from t where a = -1").Check(testkit.Rows(
+		"IndexLookUp_10 10.00 root ",
+		"├─IndexScan_8 10.00 cop[tikv] table:t, index:a, range:[-1,-1], keep order:false, stats:pseudo",
+		"└─TableScan_9 10.00 cop[tikv] table:t, keep order:false, stats:pseudo"))
+	tk.MustExec("create global binding for select * from t where a = 10 using select * from t ignore index(idx) where a = 10")
+	// Should not panic for `-1`.
+	tk.MustContains("select * from t where a = -1", "Selection")
+	// Session bindings should be able to cover the global bindings.
+	tk.MustExec("drop session binding for select * from t where a = 10")
+	tk.MustContains("select * from t where a = -1", "IndexLookUp")
 }
 
 func (s *testSuite) TestExplain(c *C) {
@@ -520,3 +534,55 @@ func (s *testSuite) TestBindingCache(c *C) {
 	res := tk.MustQuery("show global bindings")
 	c.Assert(len(res.Rows()), Equals, 2)
 }
+
+func (s *testSuite) TestDefaultDB(c *C) {
+	tk := testkit.NewTestKit(c, s.store)
+	s.cleanBindingEnv(tk)
+	tk.MustExec("use test")
+	tk.MustExec("create table t(a int, b int, index idx(a))")
+	tk.MustExec("create global binding for select * from test.t using select * from test.t use index(idx)")
+	tk.MustExec("use mysql")
+	tk.MustQuery("select * from test.t")
+	// Even in another database, we could still use the bindings.
+	c.Assert(tk.Se.GetSessionVars().StmtCtx.IndexNames[0], Equals, "t:idx")
+	tk.MustExec("drop global binding for select * from test.t")
+	tk.MustQuery("show global bindings").Check(testkit.Rows())
+
+	tk.MustExec("use test")
+	tk.MustExec("create session binding for select * from test.t using select * from test.t use index(idx)")
+	tk.MustExec("use mysql")
+	tk.MustQuery("select * from test.t")
+	// Even in another database, we could still use the bindings.
+	c.Assert(tk.Se.GetSessionVars().StmtCtx.IndexNames[0], Equals, "t:idx")
+}
+
+func (s *testSuite) TestPrivileges(c *C) {
+	tk := testkit.NewTestKit(c, s.store)
+	s.cleanBindingEnv(tk)
+	tk.MustExec("use test")
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a int, b int, index idx(a))")
+	tk.MustExec("create global binding for select * from t using select * from t use index(idx)")
+	c.Assert(tk.Se.Auth(&auth.UserIdentity{Username: "root", Hostname: "%"}, nil, nil), IsTrue)
+	rows := tk.MustQuery("show global bindings").Rows()
+	c.Assert(len(rows), Equals, 1)
+	tk.MustExec("create user test@'%'")
+	c.Assert(tk.Se.Auth(&auth.UserIdentity{Username: "test", Hostname: "%"}, nil, nil), IsTrue)
+	rows = tk.MustQuery("show global bindings").Rows()
+	c.Assert(len(rows), Equals, 0)
+}
+
+func (s *testSuite) TestErrorParse(c *C) {
+	tk := testkit.NewTestKit(c, s.store)
+	s.cleanBindingEnv(tk)
+	tk.MustExec("use test")
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a int, b int, index idx(a))")
+	_, err := tk.Exec("create global binding for select * from t where a = '1' using select * from t where a = '")
+	c.Assert(err, NotNil)
+	tk.MustExec("create global binding for select * from t where a = '1' using select * from t where a = '1'")
+	tk.MustExec("update mysql.bind_info set bind_sql = 'select'")
+	h := s.domain.BindHandle()
+	// Do not panic.
+	h.Update(true)
+}

bindinfo/cache.go

@@ -16,7 +16,6 @@ package bindinfo
 import (
 	"unsafe"
 
-	"github.com/pingcap/parser/ast"
 	"github.com/pingcap/tidb/metrics"
 	"github.com/pingcap/tidb/types"
 	"github.com/pingcap/tidb/util/chunk"
@@ -34,7 +33,8 @@ const (
 // BindMeta stores the basic bind info and bindSql astNode.
 type BindMeta struct {
 	*BindRecord
-	Ast ast.StmtNode //ast will be used to do query sql bind check
+	// Hint is the parsed hints, it is used to bind hints to stmt node.
+	Hint *HintsSet
 }
 
 // cache is a k-v map, key is original sql, value is a slice of BindMeta.

bindinfo/handle.go

@@ -305,11 +305,12 @@ func (h *BindHandle) GetAllBindRecord() (bindRecords []*BindMeta) {
 
 func (h *BindHandle) newBindMeta(record *BindRecord) (hash string, meta *BindMeta, err error) {
 	hash = parser.DigestNormalized(record.OriginalSQL)
+	meta = &BindMeta{BindRecord: record}
 	stmtNodes, _, err := h.bindInfo.parser.Parse(record.BindSQL, record.Charset, record.Collation)
 	if err != nil {
-		return "", nil, err
+		return hash, meta, err
 	}
-	meta = &BindMeta{BindRecord: record, Ast: stmtNodes[0]}
+	meta.Hint = CollectHint(stmtNodes[0])
 	return hash, meta, nil
 }
 

bindinfo/session_handle.go

@@ -50,7 +50,7 @@ func (h *SessionHandle) newBindMeta(record *BindRecord) (hash string, meta *Bind
 	if err != nil {
 		return "", nil, err
 	}
-	meta = &BindMeta{BindRecord: record, Ast: stmtNodes[0]}
+	meta = &BindMeta{BindRecord: record, Hint: CollectHint(stmtNodes[0])}
 	return hash, meta, nil
 }
 

cmd/explaintest/r/explain_easy.result

@@ -466,11 +466,9 @@ begin;
 insert tb values ('1');
 explain select * from ta where a = 1;
 id	count	task	operator info
-Projection_5	8000.00	root	test.ta.a
-└─Selection_6	8000.00	root	eq(cast(test.ta.a), 1)
-  └─UnionScan_7	10000.00	root	eq(cast(test.ta.a), 1)
-    └─TableReader_9	10000.00	root	data:TableScan_8
-      └─TableScan_8	10000.00	cop[tikv]	table:ta, range:[-inf,+inf], keep order:false, stats:pseudo
+Selection_5	8000.00	root	eq(cast(test.ta.a), 1)
+└─TableReader_7	10000.00	root	data:TableScan_6
+  └─TableScan_6	10000.00	cop[tikv]	table:ta, range:[-inf,+inf], keep order:false, stats:pseudo
 rollback;
 drop table if exists t1, t2;
 create table t1(a int, b int, c int, primary key(a, b));