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

.gitignore

@@ -80,3 +80,7 @@ var
 # Personal config files
 /*config.toml
 .cache
+
+# Claude Code runtime state (per-user, not part of repo)
+.claude/scheduled_tasks.lock
+.claude/settings.local.json

cmd/tidb-server/BUILD.bazel

@@ -107,7 +107,7 @@ go_test(
     srcs = ["main_test.go"],
     embed = [":tidb-server_lib"],
     flaky = True,
-    shard_count = 6,
+    shard_count = 7,
     deps = [
         "//pkg/config",
         "//pkg/config/deploymode",

pkg/expression/BUILD.bazel

@@ -65,6 +65,7 @@ go_library(
         "expression.go",
         "extension.go",
         "fts_helper.go",
+        "fts_to_like.go",
         "function_traits.go",
         "grouping_sets.go",
         "helper.go",
@@ -199,6 +200,7 @@ go_test(
         "evaluator_test.go",
         "expr_to_pb_test.go",
         "expression_test.go",
+        "fts_to_like_test.go",
         "function_traits_test.go",
         "grouping_sets_test.go",
         "helper_test.go",

pkg/expression/builtin.go

@@ -980,7 +980,8 @@ var funcs = map[string]functionClass{
 	ast.VecAsText:               &vecAsTextFunctionClass{baseFunctionClass{ast.VecAsText, 1, 1}},
 
 	// fts functions
-	ast.FTSMatchWord: &ftsMatchWordFunctionClass{baseFunctionClass{ast.FTSMatchWord, 2, 2}},
+	ast.FTSMatchWord:         &ftsMatchWordFunctionClass{baseFunctionClass{ast.FTSMatchWord, 2, 2}},
+	ast.FTSMysqlMatchAgainst: &ftsMysqlMatchAgainstFunctionClass{baseFunctionClass{ast.FTSMysqlMatchAgainst, 2, -1}},
 
 	// TiDB internal function.
 	ast.TiDBDecodeKey:       &tidbDecodeKeyFunctionClass{baseFunctionClass{ast.TiDBDecodeKey, 1, 1}},

pkg/expression/builtin_fts.go

@@ -16,17 +16,20 @@ package expression
 
 import (
 	"github.com/pingcap/errors"
+	"github.com/pingcap/tidb/pkg/parser/ast"
 	"github.com/pingcap/tidb/pkg/types"
 	"github.com/pingcap/tidb/pkg/util/chunk"
 	"github.com/pingcap/tipb/go-tipb"
 )
 
 var (
 	_ functionClass = &ftsMatchWordFunctionClass{}
+	_ functionClass = &ftsMysqlMatchAgainstFunctionClass{}
 )
 
 var (
 	_ builtinFunc = &builtinFtsMatchWordSig{}
+	_ builtinFunc = &builtinFtsMysqlMatchAgainstSig{}
 )
 
 type ftsMatchWordFunctionClass struct {
@@ -37,12 +40,43 @@ type builtinFtsMatchWordSig struct {
 	baseBuiltinFunc
 }
 
+type ftsMysqlMatchAgainstFunctionClass struct {
+	baseFunctionClass
+}
+
+type builtinFtsMysqlMatchAgainstSig struct {
+	baseBuiltinFunc
+	modifier ast.FulltextSearchModifier
+}
+
 func (b *builtinFtsMatchWordSig) Clone() builtinFunc {
 	newSig := &builtinFtsMatchWordSig{}
 	newSig.cloneFrom(&b.baseBuiltinFunc)
 	return newSig
 }
 
+func (b *builtinFtsMysqlMatchAgainstSig) Clone() builtinFunc {
+	newSig := &builtinFtsMysqlMatchAgainstSig{}
+	newSig.cloneFrom(&b.baseBuiltinFunc)
+	newSig.modifier = b.modifier
+	return newSig
+}
+
+func (b *builtinFtsMysqlMatchAgainstSig) SetModifier(modifier ast.FulltextSearchModifier) {
+	b.modifier = modifier
+}
+
+// SetFTSMysqlMatchAgainstModifier sets the modifier for the internal `MATCH ... AGAINST` builtin signature.
+// It is expected to be called by planner right after building the scalar function.
+func SetFTSMysqlMatchAgainstModifier(sf *ScalarFunction, modifier ast.FulltextSearchModifier) error {
+	sig, ok := sf.Function.(*builtinFtsMysqlMatchAgainstSig)
+	if !ok {
+		return errors.Errorf("unexpected builtin signature for %s: %T", ast.FTSMysqlMatchAgainst, sf.Function)
+	}
+	sig.SetModifier(modifier)
+	return nil
+}
+
 func (c *ftsMatchWordFunctionClass) getFunction(ctx BuildContext, args []Expression) (builtinFunc, error) {
 	if err := c.verifyArgs(args); err != nil {
 		return nil, err
@@ -81,3 +115,53 @@ func (b *builtinFtsMatchWordSig) evalReal(ctx EvalContext, row chunk.Row) (float
 	// Reject executing match against in TiDB side.
 	return 0, false, errors.Errorf("cannot use 'FTS_MATCH_WORD()' outside of fulltext index")
 }
+
+func (c *ftsMysqlMatchAgainstFunctionClass) getFunction(ctx BuildContext, args []Expression) (builtinFunc, error) {
+	if err := c.verifyArgs(args); err != nil {
+		return nil, err
+	}
+
+	argAgainst := args[0]
+	argAgainstConstant, ok := argAgainst.(*Constant)
+	if !ok {
+		return nil, ErrNotSupportedYet.GenWithStackByArgs("match against a non-constant string")
+	}
+	if argAgainstConstant.Value.Kind() != types.KindString && !argAgainstConstant.Value.IsNull() {
+		return nil, ErrNotSupportedYet.GenWithStackByArgs("match against a non-string constant")
+	}
+
+	argsMatch := args[1:]
+	for _, arg := range argsMatch {
+		_, ok := arg.(*Column)
+		if !ok {
+			return nil, ErrNotSupportedYet.GenWithStackByArgs("not matching a column")
+		}
+	}
+
+	argTps := make([]types.EvalType, 0, len(args))
+	argTps = append(argTps, types.ETString)
+	for _, arg := range argsMatch {
+		if arg.GetType(ctx.GetEvalCtx()).EvalType() != types.ETString {
+			return nil, ErrNotSupportedYet.GenWithStackByArgs("Doesn't support match search on a non-string column without fulltext index")
+		}
+		argTps = append(argTps, types.ETString)
+	}
+
+	bf, err := newBaseBuiltinFuncWithTp(ctx, c.funcName, args, types.ETReal, argTps...)
+	if err != nil {
+		return nil, err
+	}
+
+	sig := &builtinFtsMysqlMatchAgainstSig{baseBuiltinFunc: bf}
+	sig.setPbCode(tipb.ScalarFuncSig_FTSMatchExpression)
+	return sig, nil
+}
+
+func (b *builtinFtsMysqlMatchAgainstSig) evalReal(ctx EvalContext, row chunk.Row) (float64, bool, error) {
+	// args[0] is validated to be a *Constant by getFunction; guard defensively
+	// since the sig may be reconstructed via the distsql path without that check.
+	if constArg, ok := b.args[0].(*Constant); ok && constArg.Value.IsNull() {
+		return 0, true, nil
+	}
+	return 0, false, errors.Errorf("cannot use 'MATCH ... AGAINST' outside of fulltext index")
+}

pkg/expression/distsql_builtin.go

@@ -1158,6 +1158,13 @@ func getSignatureByPB(ctx BuildContext, sigCode tipb.ScalarFuncSig, tp *tipb.Fie
 		f = &builtinVecL2NormSig{base}
 	case tipb.ScalarFuncSig_FTSMatchWord:
 		f = &builtinFtsMatchWordSig{base}
+	case tipb.ScalarFuncSig_FTSMatchExpression:
+		// NOTE: builtinFtsMysqlMatchAgainstSig.modifier is not serialized in the
+		// protobuf encoding because the tipb schema has no FTS metadata message.
+		// The reconstructed sig therefore uses the zero modifier value
+		// (FulltextSearchModifierNaturalLanguageMode). TiFlash must derive the
+		// search mode from other context when executing this expression.
+		f = &builtinFtsMysqlMatchAgainstSig{baseBuiltinFunc: base}
 	default:
 		e = ErrFunctionNotExists.GenWithStackByArgs("FUNCTION", sigCode)
 		return nil, e