planner: rewrite FTS predicates to LIKE for evaluation of non-TiCI query plan

pkg/expression/integration_test/integration_test.go

@@ -207,7 +207,12 @@ func TestFTSSyntax(t *testing.T) {
 	// tk.MustContainErrMsg("select * from t where (fts_match_word('hello', title)) > 0", "Currently 'FTS_MATCH_WORD()' must be used alone")
 	// tk.MustContainErrMsg("select (fts_match_word('hello', title)) AS score from t where fts_match_word('hello', title)", "Currently 'FTS_MATCH_WORD()' cannot be used in SELECT fields")
 	tk.MustContainErrMsg("select * from t where match() against ('hello')", `You have an error in your SQL syntax`)
-	tk.MustContainErrMsg("select * from t where match(title) against ('hello' in boolean mode)", `UnknownType: *ast.MatchAgainst`)
+	// Test MATCH...AGAINST with default 'like' fallback mode - should succeed
+	tk.MustQuery("select * from t where match(title) against ('hello' in boolean mode)")
+	// Test MATCH...AGAINST with 'error' fallback mode - should fail
+	tk.MustExec("set @@tidb_opt_fulltext_search_fallback='error'")
+	tk.MustContainErrMsg("select * from t where match(title) against ('hello' in boolean mode)", `This version of TiDB doesn't yet support 'MATCH...AGAINST without fulltext index'`)
+	tk.MustExec("set @@tidb_opt_fulltext_search_fallback='like'")
 	tk.MustContainErrMsg("select * from t where fts_match_word(title, body)", `match against a non-constant string`)
 	tk.MustContainErrMsg("select * from t where fts_match_word(45.67, body)", `match against a non-constant string`)
 	tk.MustContainErrMsg("select * from t where fts_match_word('hello', title, body)", `Incorrect parameter count in the call to native function`)

pkg/planner/core/BUILD.bazel

@@ -13,6 +13,7 @@ go_library(
         "expression_rewriter.go",
         "find_best_task.go",
         "flat_plan.go",
+        "fulltext_to_like.go",
         "hint_utils.go",
         "index_join_path.go",
         "indexmerge_path.go",
@@ -209,6 +210,7 @@ go_test(
         "exhaust_physical_plans_test.go",
         "expression_test.go",
         "find_best_task_test.go",
+        "fulltext_to_like_test.go",
         "hint_test.go",
         "indexmerge_intersection_test.go",
         "indexmerge_path_test.go",

pkg/planner/core/expression_rewriter.go

@@ -1692,6 +1692,8 @@ func (er *expressionRewriter) Leave(originInNode ast.Node) (retNode ast.Node, ok
 		}
 		er.ctxStack[len(er.ctxStack)-1].SetCoercibility(expression.CoercibilityExplicit)
 		er.ctxStack[len(er.ctxStack)-1].SetCharsetAndCollation(arg.GetType(er.sctx.GetEvalCtx()).GetCharset(), arg.GetType(er.sctx.GetEvalCtx()).GetCollate())
+	case *ast.MatchAgainst:
+		er.matchAgainstToExpression(v)
 	default:
 		er.err = errors.Errorf("UnknownType: %T", v)
 		return retNode, false
@@ -2217,6 +2219,71 @@ func (er *expressionRewriter) patternLikeOrIlikeToExpression(v *ast.PatternLikeO
 	er.ctxStackAppend(function, types.EmptyName)
 }
 
+func (er *expressionRewriter) matchAgainstToExpression(v *ast.MatchAgainst) {
+	// Check the session variable to determine behavior
+	var fallbackMode string
+	if er.planCtx != nil && er.planCtx.builder != nil && er.planCtx.builder.ctx != nil {
+		fallbackMode = er.planCtx.builder.ctx.GetSessionVars().FulltextSearchFallback
+	} else {
+		fallbackMode = "like" // default
+	}
+
+	if fallbackMode == "error" {
+		er.err = expression.ErrNotSupportedYet.GenWithStackByArgs("MATCH...AGAINST without fulltext index")
+		return
+	}
+
+	// Both the column expressions and Against expression have been visited
+	// and pushed onto the ctxStack. The stack layout is:
+	// [..., col1, col2, ..., colN, against]
+	numColumns := len(v.ColumnNames)
+	l := len(er.ctxStack)
+	if l < numColumns+1 {
+		er.err = errors.Errorf("MATCH...AGAINST: expected %d column expressions and Against expression on stack, got %d", numColumns+1, l)
+		return
+	}
+
+	// The Against expression is the last one on the stack
+	againstExpr := er.ctxStack[l-1]
+
+	// Check if it's a constant string
+	constExpr, ok := againstExpr.(*expression.Constant)
+	if !ok {
+		er.err = expression.ErrNotSupportedYet.GenWithStackByArgs("MATCH...AGAINST with non-constant search string")
+		return
+	}
+
+	searchText, err := constExpr.Eval(er.sctx.GetEvalCtx(), chunk.Row{})
+	if err != nil {
+		er.err = err
+		return
+	}
+
+	if searchText.Kind() != types.KindString {
+		er.err = expression.ErrNotSupportedYet.GenWithStackByArgs("MATCH...AGAINST with non-string search expression")
+		return
+	}
+
+	// Get the column expressions from the stack
+	// They're at positions [l-numColumns-1 : l-1]
+	columns := make([]expression.Expression, numColumns)
+	for i := range numColumns {
+		columns[i] = er.ctxStack[l-numColumns-1+i]
+	}
+
+	// Pop all column expressions and the Against expression
+	er.ctxStackPop(numColumns + 1)
+
+	// Convert to LIKE predicates
+	result, err := er.convertMatchAgainstToLike(columns, searchText.GetString(), v.Modifier)
+	if err != nil {
+		er.err = err
+		return
+	}
+
+	er.ctxStackAppend(result, types.EmptyName)
+}
+
 func (er *expressionRewriter) regexpToScalarFunc(v *ast.PatternRegexpExpr) {
 	l := len(er.ctxStack)
 	er.err = expression.CheckArgsNotMultiColumnRow(er.ctxStack[l-2:]...)