bindinfo: explore per-table index hints during plan generation (#66000)

close #65999

Author: AilinKid

pkg/bindinfo/binding_plan_generation.go

@@ -134,12 +134,12 @@ func (gp *genedPlan) PlanText() string {
 
 // state represents a state of the optimizer variables and fixes.
 type state struct {
-	leading2  [2]*tableName // leading-2 table names
-	indexHint *indexHint    // optional index hint for a table (one at a time to limit search space)
-	varNames  []string      // relevant variables and their values to generate a certain plan
-	varValues []any
-	fixIDs    []uint64 // relevant fixes and their values to generate a certain plan
-	fixValues []string
+	leading2   [2]*tableName // leading-2 table names
+	indexHints []*indexHint  // optional index hints per table
+	varNames   []string      // relevant variables and their values to generate a certain plan
+	varValues  []any
+	fixIDs     []uint64 // relevant fixes and their values to generate a certain plan
+	fixValues  []string
 }
 
 // Encode encodes the state into a string.
@@ -154,11 +154,14 @@ func (s *state) Encode() string {
 		}
 		sb.WriteString(t.String())
 	}
-	if s.indexHint != nil {
+	for _, indexHint := range s.indexHints {
+		if indexHint == nil {
+			continue
+		}
 		if sb.Len() > 0 {
 			sb.WriteString(",")
 		}
-		sb.WriteString(s.indexHint.String())
+		sb.WriteString(indexHint.String())
 	}
 	for _, v := range s.varValues {
 		if sb.Len() > 0 {
@@ -182,35 +185,39 @@ func (s *state) Encode() string {
 
 func newStateWithLeading2(old *state, leading2 [2]*tableName) *state {
 	newState := &state{
-		leading2:  leading2,
-		indexHint: old.indexHint,
-		varNames:  old.varNames,
-		varValues: old.varValues,
-		fixIDs:    old.fixIDs,
-		fixValues: old.fixValues,
+		leading2:   leading2,
+		indexHints: append([]*indexHint(nil), old.indexHints...),
+		varNames:   old.varNames,
+		varValues:  old.varValues,
+		fixIDs:     old.fixIDs,
+		fixValues:  old.fixValues,
 	}
 	return newState
 }
 
-func newStateWithIndexHint(old *state, indexHint *indexHint) *state {
+func newStateWithIndexHint(old *state, tableIdx int, hint *indexHint) *state {
+	newHints := append([]*indexHint(nil), old.indexHints...)
+	if tableIdx >= 0 && tableIdx < len(newHints) {
+		newHints[tableIdx] = hint
+	}
 	return &state{
-		leading2:  old.leading2,
-		indexHint: indexHint,
-		varNames:  old.varNames,
-		varValues: old.varValues,
-		fixIDs:    old.fixIDs,
-		fixValues: old.fixValues,
+		leading2:   old.leading2,
+		indexHints: newHints,
+		varNames:   old.varNames,
+		varValues:  old.varValues,
+		fixIDs:     old.fixIDs,
+		fixValues:  old.fixValues,
 	}
 }
 
 func newStateWithNewVar(old *state, varName string, varVal any) *state {
 	newState := &state{
-		leading2:  old.leading2,
-		indexHint: old.indexHint,
-		varNames:  old.varNames,
-		varValues: make([]any, len(old.varValues)),
-		fixIDs:    old.fixIDs,
-		fixValues: old.fixValues,
+		leading2:   old.leading2,
+		indexHints: append([]*indexHint(nil), old.indexHints...),
+		varNames:   old.varNames,
+		varValues:  make([]any, len(old.varValues)),
+		fixIDs:     old.fixIDs,
+		fixValues:  old.fixValues,
 	}
 	copy(newState.varValues, old.varValues)
 	for i := range newState.varNames {
@@ -224,12 +231,12 @@ func newStateWithNewVar(old *state, varName string, varVal any) *state {
 
 func newStateWithNewFix(old *state, fixID uint64, fixVal string) *state {
 	newState := &state{
-		leading2:  old.leading2,
-		indexHint: old.indexHint,
-		varNames:  old.varNames,
-		varValues: old.varValues,
-		fixIDs:    old.fixIDs,
-		fixValues: make([]string, len(old.fixValues)),
+		leading2:   old.leading2,
+		indexHints: append([]*indexHint(nil), old.indexHints...),
+		varNames:   old.varNames,
+		varValues:  old.varValues,
+		fixIDs:     old.fixIDs,
+		fixValues:  make([]string, len(old.fixValues)),
 	}
 	copy(newState.fixValues, old.fixValues)
 	for i := range newState.fixIDs {
@@ -263,20 +270,20 @@ func generatePlanWithSCtx(sctx sessionctx.Context, defaultSchema, sql, charset,
 			possibleLeading2 = append(possibleLeading2, [2]*tableName{tableNames[i], tableNames[j]})
 		}
 	}
-	possibleIndexHints := extractSelectIndexHints(sctx, defaultSchema, stmt)
-	return breadthFirstPlanSearch(sctx, stmt, vars, fixes, possibleLeading2, possibleIndexHints)
+	indexHintOptions := extractSelectIndexHints(sctx, defaultSchema, stmt)
+	return breadthFirstPlanSearch(sctx, stmt, vars, fixes, possibleLeading2, indexHintOptions)
 }
 
 func breadthFirstPlanSearch(sctx sessionctx.Context, stmt ast.StmtNode,
-	vars []string, fixes []uint64, possibleLeading2 [][2]*tableName, possibleIndexHints []*indexHint) (plans []*genedPlan, err error) {
+	vars []string, fixes []uint64, possibleLeading2 [][2]*tableName, indexHintOptions [][]*indexHint) (plans []*genedPlan, err error) {
 	// init BFS structures
 	visitedStates := make(map[string]struct{})  // map[encodedState]struct{}, all visited states
 	visitedPlans := make(map[string]*genedPlan) // map[planDigest]plan, all visited plans
 	stateList := list.New()                     // states in queue to explore
 
 	// init the start state and push it into the BFS list
 	// start state: no specified leading hint + default values of all variables and fix-controls
-	startState, err := getStartState(vars, fixes)
+	startState, err := getStartState(vars, fixes, len(indexHintOptions))
 	if err != nil {
 		return nil, err
 	}
@@ -300,11 +307,13 @@ func breadthFirstPlanSearch(sctx sessionctx.Context, stmt ast.StmtNode,
 				stateList.PushBack(newState)
 			}
 		}
-		for _, indexHint := range possibleIndexHints {
-			newState := newStateWithIndexHint(currState, indexHint)
-			if _, ok := visitedStates[newState.Encode()]; !ok {
-				visitedStates[newState.Encode()] = struct{}{}
-				stateList.PushBack(newState)
+		for tableIdx := range indexHintOptions {
+			for _, indexHint := range indexHintOptions[tableIdx] {
+				newState := newStateWithIndexHint(currState, tableIdx, indexHint)
+				if _, ok := visitedStates[newState.Encode()]; !ok {
+					visitedStates[newState.Encode()] = struct{}{}
+					stateList.PushBack(newState)
+				}
 			}
 		}
 		for i := range vars {
@@ -416,7 +425,14 @@ func genPlanUnderState(sctx sessionctx.Context, stmt ast.StmtNode, state *state)
 	sctx.GetSessionVars().OptimizerFixControl = fixControlMap
 
 	if sel, isSel := stmt.(*ast.SelectStmt); isSel {
-		if (state.leading2[0] != nil && state.leading2[1] != nil) || state.indexHint != nil {
+		hasIndexHint := false
+		for _, indexHint := range state.indexHints {
+			if indexHint != nil {
+				hasIndexHint = true
+				break
+			}
+		}
+		if (state.leading2[0] != nil && state.leading2[1] != nil) || hasIndexHint {
 			originalHintsLen := len(sel.TableHints)
 			defer func() {
 				sel.TableHints = sel.TableHints[:originalHintsLen]
@@ -437,18 +453,21 @@ func genPlanUnderState(sctx sessionctx.Context, stmt ast.StmtNode, state *state)
 				}
 				sel.TableHints = append(sel.TableHints, leadingHint)
 			}
-			if state.indexHint != nil {
-				indexHint := &ast.TableOptimizerHint{
+			for _, indexHint := range state.indexHints {
+				if indexHint == nil {
+					continue
+				}
+				hintNode := &ast.TableOptimizerHint{
 					HintName: ast.NewCIStr(hint.HintUseIndex),
 					Tables: []ast.HintTable{
 						{
-							DBName:    ast.NewCIStr(state.indexHint.table.schema),
-							TableName: ast.NewCIStr(state.indexHint.table.HintName()),
+							DBName:    ast.NewCIStr(indexHint.table.schema),
+							TableName: ast.NewCIStr(indexHint.table.HintName()),
 						},
 					},
-					Indexes: []ast.CIStr{ast.NewCIStr(state.indexHint.index)},
+					Indexes: []ast.CIStr{ast.NewCIStr(indexHint.index)},
 				}
-				sel.TableHints = append(sel.TableHints, indexHint)
+				sel.TableHints = append(sel.TableHints, hintNode)
 			}
 		}
 	}
@@ -518,9 +537,13 @@ func adjustFix(fixID uint64, fixVal string) (newFixVal string, err error) {
 	}
 }
 
-func getStartState(vars []string, fixes []uint64) (*state, error) {
+func getStartState(vars []string, fixes []uint64, indexHintCount int) (*state, error) {
 	// use the default values of these vars and fix-controls as the initial state.
-	s := &state{varNames: vars, fixIDs: fixes}
+	s := &state{
+		varNames:   vars,
+		fixIDs:     fixes,
+		indexHints: make([]*indexHint, indexHintCount),
+	}
 	for _, varName := range vars {
 		switch varName {
 		case vardef.TiDBOptIndexScanCostFactor:
@@ -755,7 +778,7 @@ func collectJoinPredicates(node ast.ResultSetNode, extractor *predicateColumnExt
 	}
 }
 
-func extractSelectIndexHints(sctx sessionctx.Context, defaultSchema string, node ast.StmtNode) []*indexHint {
+func extractSelectIndexHints(sctx sessionctx.Context, defaultSchema string, node ast.StmtNode) [][]*indexHint {
 	selStmt, isSel := node.(*ast.SelectStmt)
 	if !isSel {
 		return nil
@@ -765,9 +788,10 @@ func extractSelectIndexHints(sctx sessionctx.Context, defaultSchema string, node
 		return nil
 	}
 	allowAnyTable := len(tableNames) == 1
-	hints := make([]*indexHint, 0)
-	seen := make(map[string]struct{})
+	hintOptions := make([][]*indexHint, 0, len(tableNames))
 	for _, target := range tableNames {
+		options := make([]*indexHint, 0, 4)
+		options = append(options, nil) // empty option to avoid forcing index paths
 		extractor := &predicateColumnExtractor{
 			table:         target,
 			columns:       make(map[string]struct{}),
@@ -780,13 +804,16 @@ func extractSelectIndexHints(sctx sessionctx.Context, defaultSchema string, node
 			collectJoinPredicates(selStmt.From.TableRefs, extractor)
 		}
 		if len(extractor.columns) == 0 {
+			hintOptions = append(hintOptions, options)
 			continue
 		}
 		tblInfo, err := sctx.GetLatestInfoSchema().TableInfoByName(ast.NewCIStr(target.schema), ast.NewCIStr(target.name))
 		if err != nil {
+			hintOptions = append(hintOptions, options)
 			continue
 		}
 		useInvisible := sctx.GetSessionVars().OptimizerUseInvisibleIndexes
+		seen := make(map[string]struct{})
 		for _, index := range tblInfo.Indices {
 			if index.State != model.StatePublic {
 				continue
@@ -810,12 +837,13 @@ func extractSelectIndexHints(sctx sessionctx.Context, defaultSchema string, node
 				table: target,
 				index: index.Name.O,
 			}
-			if _, ok := seen[hint.String()]; ok {
+			if _, ok := seen[hint.index]; ok {
 				continue
 			}
-			seen[hint.String()] = struct{}{}
-			hints = append(hints, hint)
+			seen[hint.index] = struct{}{}
+			options = append(options, hint)
 		}
+		hintOptions = append(hintOptions, options)
 	}
-	return hints
+	return hintOptions
 }

pkg/bindinfo/binding_plan_generation_test.go

@@ -109,7 +109,7 @@ func TestStartState(t *testing.T) {
 	}
 	fixes := []uint64{fixcontrol.Fix44855, fixcontrol.Fix45132, fixcontrol.Fix52869}
 
-	state, err := getStartState(vars, fixes)
+	state, err := getStartState(vars, fixes, 0)
 	require.NoError(t, err)
 	require.Equal(t, state.Encode(), "1.0000,1.0000,1.0000,1.0000,1.0000,1.0000,1.0000,1.0000,1.0000,1.0000,1.0000,1.0000,1.0000,1.0000,1.0000,1.0000,1.0000,0.0100,0.0000,0.0000,0.0000,0.8000,true,false,false,0.0000,OFF,1000,OFF")
 }

pkg/bindinfo/testdata/binding_auto_suite_out.json

@@ -94,6 +94,15 @@
             "  └─Selection  9990.00  cop[tikv]    not(isnull(test.t2.a))",
             "    └─TableFullScan  10000.00  cop[tikv]  table:t2  keep order:false, stats:pseudo"
           ],
+          [
+            "HashJoin  12487.50  root    inner join, equal:[eq(test.t1.a, test.t2.a)]",
+            "├─IndexLookUp(Probe)  9990.00  root    ",
+            "│ ├─IndexFullScan(Build)  9990.00  cop[tikv]  table:t1, index:a(a)  keep order:false, stats:pseudo",
+            "│ └─TableRowIDScan(Probe)  9990.00  cop[tikv]  table:t1  keep order:false, stats:pseudo",
+            "└─IndexLookUp(Build)  9990.00  root    ",
+            "  ├─IndexFullScan(Build)  9990.00  cop[tikv]  table:t2, index:a(a)  keep order:false, stats:pseudo",
+            "  └─TableRowIDScan(Probe)  9990.00  cop[tikv]  table:t2  keep order:false, stats:pseudo"
+          ],
           [
             "HashJoin  12487.50  root    inner join, equal:[eq(test.t1.a, test.t2.a)]",
             "├─TableReader(Probe)  9990.00  root    data:Selection",