fix FTContainsAll/Any for constants, change TFScore signature to accept params

Author: maumar

Diff for: src/EFCore.Cosmos/Extensions/CosmosDbFunctionsExtensions.cs

@@ -89,11 +89,11 @@ public static bool FullTextContainsAny(this DbFunctions _, string property, para
     ///     Returns the full-text search score for the specified property and keywords.
     /// </summary>
     /// <param name="_">The <see cref="DbFunctions" /> instance.</param>
-    /// <param name="property">The property to search.</param>
-    /// <param name="keywords">The keywords to search for.</param>
+    /// <param name="property">The property to score.</param>
+    /// <param name="keywords">The keywords to score by.</param>
     /// <returns>The full-text search score.</returns>
     [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
-    public static double FullTextScore(this DbFunctions _, string property, string[] keywords)
+    public static double FullTextScore(this DbFunctions _, string property, params string[] keywords)
         => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(FullTextScore)));
 
     /// <summary>

Diff for: src/EFCore.Cosmos/Query/Internal/CosmosShapedQueryCompilingExpressionVisitor.InExpressionValuesExpandingExpressionVisitor.cs

@@ -85,7 +85,7 @@ protected override Expression VisitExtension(Expression expression)
                     return base.VisitExtension(expression);
                 }
 
-                // Inlines array parameter of full-text functions, transforming FullTextContains(x, @keywordsArray) to FullTextContains(x, keyword1, keyword2)) 
+                // Inlines array parameter of full-text functions, transforming FullTextContainsAll(x, @keywordsArray) to FullTextContainsAll(x, keyword1, keyword2)) 
                 case SqlFunctionExpression
                 {
                     Name: "FullTextContainsAny" or "FullTextContainsAll",
@@ -106,6 +106,29 @@ protected override Expression VisitExtension(Expression expression)
                         fullTextContainsAllAnyFunction.TypeMapping);
                 }
 
+                // Inlines array parameter of full-text score, transforming FullTextScore(x, @keywordsArray) to FullTextScore(x, [keyword1, keyword2])) 
+                case SqlFunctionExpression
+                {
+                    Name: "FullTextScore",
+                    IsScoringFunction: true,
+                    Arguments: [var property, SqlParameterExpression { TypeMapping: { ElementTypeMapping: not null } typeMapping } keywords]
+                } fullTextScoreFunction
+                when !UseOldBehavior35476:
+                {
+                    var keywordValues = new List<string>();
+                    foreach (var value in (IEnumerable)parametersValues[keywords.Name])
+                    {
+                        keywordValues.Add((string)value);
+                    }
+
+                    return new SqlFunctionExpression(
+                        fullTextScoreFunction.Name,
+                        isScoringFunction: true,
+                        [property, sqlExpressionFactory.Constant(keywordValues, typeMapping)],
+                        fullTextScoreFunction.Type,
+                        fullTextScoreFunction.TypeMapping);
+                }
+
                 default:
                     return expression;
             }

Diff for: src/EFCore.Cosmos/Query/Internal/Translators/CosmosFullTextSearchTranslator.cs

@@ -65,6 +65,14 @@ public class CosmosFullTextSearchTranslator(ISqlExpressionFactory sqlExpressionF
                     typeof(double),
                     typeMappingSource.FindMapping(typeof(double))),
 
+            nameof(CosmosDbFunctionsExtensions.FullTextContainsAny) or nameof(CosmosDbFunctionsExtensions.FullTextContainsAll)
+                when arguments is [_, SqlExpression property, SqlConstantExpression { Type: var keywordClrType, Value: string[] values } keywords]
+                    && keywordClrType == typeof(string[]) => sqlExpressionFactory.Function(
+                        method.Name == nameof(CosmosDbFunctionsExtensions.FullTextContainsAny) ? "FullTextContainsAny" : "FullTextContainsAll",
+                        [property, .. values.Select(x => sqlExpressionFactory.Constant(x))],
+                        typeof(bool),
+                        typeMappingSource.FindMapping(typeof(bool))),
+
             nameof(CosmosDbFunctionsExtensions.FullTextContainsAny) or nameof(CosmosDbFunctionsExtensions.FullTextContainsAll)
                 when arguments is [_, SqlExpression property, SqlParameterExpression { Type: var keywordClrType } keywords]
                     && keywordClrType == typeof(string[]) => sqlExpressionFactory.Function(