planner: support global binding fuzzy matching

pkg/bindinfo/BUILD.bazel

@@ -51,11 +51,11 @@ go_test(
         "bind_cache_test.go",
         "binding_match_test.go",
         "capture_test.go",
+        "fuzzy_binding_test.go",
         "global_handle_test.go",
         "main_test.go",
         "optimize_test.go",
         "session_handle_test.go",
-        "universal_binding_test.go",
     ],
     embed = [":bindinfo"],
     flaky = True,

pkg/bindinfo/bind_record.go

@@ -20,6 +20,7 @@ import (
 
 	"github.com/pingcap/tidb/pkg/metrics"
 	"github.com/pingcap/tidb/pkg/parser"
+	"github.com/pingcap/tidb/pkg/parser/ast"
 	"github.com/pingcap/tidb/pkg/sessionctx"
 	"github.com/pingcap/tidb/pkg/types"
 	"github.com/pingcap/tidb/pkg/util/hack"
@@ -85,6 +86,9 @@ type Binding struct {
 	PlanDigest string
 	// Type indicates the type of this binding, currently only 2 types: "" for normal and "u" for universal bindings.
 	Type string
+
+	// TableNames records all schema and table names in this binding statement, which are used for fuzzy matching.
+	TableNames []*ast.TableName
 }
 
 func (b *Binding) isSame(rb *Binding) bool {
@@ -196,7 +200,7 @@ func (br *BindRecord) prepareHints(sctx sessionctx.Context) error {
 		if err != nil {
 			return err
 		}
-		if sctx != nil && bind.Type == TypeNormal {
+		if sctx != nil && bind.Type == TypeNormal && !isFuzzyBinding(stmt) {
 			paramChecker := &paramMarkerChecker{}
 			stmt.Accept(paramChecker)
 			if !paramChecker.hasParamMarker {

pkg/bindinfo/binding_match.go

@@ -59,7 +59,7 @@ func getBindRecord(ctx sessionctx.Context, stmt ast.StmtNode) (*BindRecord, stri
 	if globalHandle == nil {
 		return nil, "", nil
 	}
-	if bindRecord, err := globalHandle.MatchGlobalBinding(ctx.GetSessionVars().CurrentDB, stmt); err == nil && bindRecord != nil && bindRecord.HasEnabledBinding() {
+	if bindRecord, err := globalHandle.MatchGlobalBinding(ctx, stmt); err == nil && bindRecord != nil && bindRecord.HasEnabledBinding() {
 		return bindRecord, metrics.ScopeGlobal, nil
 	}
 	return nil, "", nil
@@ -77,11 +77,17 @@ func eraseLastSemicolon(stmt ast.StmtNode) {
 // For normal bindings, DB name will be completed automatically:
 //
 //	e.g. `select * from t where a in (1, 2, 3)` --> `select * from test.t where a in (...)`
-func normalizeStmt(stmtNode ast.StmtNode, specifiedDB string) (stmt ast.StmtNode, normalizedStmt, sqlDigest string, err error) {
+func normalizeStmt(stmtNode ast.StmtNode, specifiedDB string, fuzzy bool) (stmt ast.StmtNode, normalizedStmt, sqlDigest string, err error) {
 	normalize := func(n ast.StmtNode) (normalizedStmt, sqlDigest string) {
 		eraseLastSemicolon(n)
 		var digest *parser.Digest
-		normalizedStmt, digest = parser.NormalizeDigestForBinding(utilparser.RestoreWithDefaultDB(n, specifiedDB, n.Text()))
+		var normalizedSQL string
+		if !fuzzy {
+			normalizedSQL = utilparser.RestoreWithDefaultDB(n, specifiedDB, n.Text())
+		} else {
+			normalizedSQL = utilparser.RestoreWithoutDB(n)
+		}
+		normalizedStmt, digest = parser.NormalizeDigestForBinding(normalizedSQL)
 		return normalizedStmt, digest.String()
 	}
 
@@ -131,6 +137,37 @@ func normalizeStmt(stmtNode ast.StmtNode, specifiedDB string) (stmt ast.StmtNode
 	return nil, "", "", nil
 }
 
+func fuzzyMatchBindingTableName(currentDB string, stmtTableNames, bindingTableNames []*ast.TableName) (numWildcards int, matched bool) {
+	if len(stmtTableNames) != len(bindingTableNames) {
+		return 0, false
+	}
+	for i := range stmtTableNames {
+		if stmtTableNames[i].Name.L != bindingTableNames[i].Name.L {
+			return 0, false
+		}
+		if bindingTableNames[i].Schema.L == "*" {
+			numWildcards++
+		}
+		if bindingTableNames[i].Schema.L == stmtTableNames[i].Schema.L || // exactly same, or
+			(stmtTableNames[i].Schema.L == "" && bindingTableNames[i].Schema.L == currentDB) || // equal to the current DB, or
+			bindingTableNames[i].Schema.L == "*" { // fuzzy match successfully
+			continue
+		}
+		return 0, false
+	}
+	return numWildcards, true
+}
+
+// isFuzzyBinding checks whether the stmtNode is a fuzzy binding.
+func isFuzzyBinding(stmt ast.Node) bool {
+	for _, t := range CollectTableNames(stmt) {
+		if t.Schema.L == "*" {
+			return true
+		}
+	}
+	return false
+}
+
 // CollectTableNames gets all table names from ast.Node.
 // This function is mainly for binding fuzzy matching.
 // ** the return is read-only.

pkg/bindinfo/capture_test.go

@@ -329,7 +329,7 @@ func TestBindingSource(t *testing.T) {
 	tk.MustExec("create global binding for select * from t where a > 10 using select * from t ignore index(idx_a) where a > 10")
 	bindHandle := dom.BindHandle()
 	stmt, _, _ := internal.UtilNormalizeWithDefaultDB(t, "select * from t where a > ?")
-	bindData, err := bindHandle.MatchGlobalBinding("test", stmt)
+	bindData, err := bindHandle.MatchGlobalBinding(tk.Session(), stmt)
 	require.NoError(t, err)
 	require.NotNil(t, bindData)
 	require.Equal(t, "select * from `test` . `t` where `a` > ?", bindData.OriginalSQL)
@@ -350,7 +350,7 @@ func TestBindingSource(t *testing.T) {
 	tk.MustExec("admin capture bindings")
 	bindHandle.CaptureBaselines()
 	stmt, _, _ = internal.UtilNormalizeWithDefaultDB(t, "select * from t where a < ?")
-	bindData, err = bindHandle.MatchGlobalBinding("test", stmt)
+	bindData, err = bindHandle.MatchGlobalBinding(tk.Session(), stmt)
 	require.NoError(t, err)
 	require.NotNil(t, bindData)
 	require.Equal(t, "select * from `test` . `t` where `a` < ?", bindData.OriginalSQL)