split FTS annotations into two: isEnabled and language

Author: maumar

src/EFCore.Cosmos/Extensions/CosmosPropertyBuilderExtensions.cs

@@ -245,26 +245,28 @@ private static CosmosVectorType CreateVectorType(DistanceFunction distanceFuncti
                 CoreStrings.InvalidEnumValue(distanceFunction, nameof(distanceFunction), typeof(DistanceFunction)));
 
     /// <summary>
-    ///     Configures the property to be used with a full-text search.
+    ///     Enables full-text search for this property using a specified language.
     /// </summary>
     /// <remarks>
     ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see>, and
     ///     <see href="https://aka.ms/efcore-docs-cosmos">Accessing Azure Cosmos DB with EF Core</see> for more information and examples.
     /// </remarks>
     /// <param name="propertyBuilder">The builder for the property being configured.</param>
-    /// <param name="language">The language for the full-text search.</param>
+    /// <param name="language">The language used for full-text search. Setting this to (<see langword="null" /> will use the default language for the container, or "en-US" if default language was not specified.</param>
     /// <returns>The same builder instance so that multiple calls can be chained.</returns>
     [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
-    public static PropertyBuilder IsFullTextProperty(
+    public static PropertyBuilder EnableFullTextSearch(
         this PropertyBuilder propertyBuilder,
         string? language = null)
     {
+        propertyBuilder.Metadata.SetIsFullTextSearchEnabled(true);
         propertyBuilder.Metadata.SetFullTextSearchLanguage(language);
+
         return propertyBuilder;
     }
 
     /// <summary>
-    ///     Configures the property to enable full-text search for Azure Cosmos DB using a specified language.
+    ///     Enables full-text search for this property using a specified language.
     /// </summary>
     /// <remarks>
     ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see>, and
@@ -276,62 +278,142 @@ public static PropertyBuilder IsFullTextProperty(
     /// </remarks>
     /// <typeparam name="TProperty">The type of the property being configured.</typeparam>
     /// <param name="propertyBuilder">The builder for the property being configured.</param>
-    /// <param name="language">The language for the full-text search.</param>
+    /// <param name="language">The language used for full-text search. Setting this to (<see langword="null" /> will use the default language for the container, or "en-US" if default language was not specified.</param>
     /// <returns>The same builder instance so that multiple calls can be chained.</returns>
     [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
-    public static PropertyBuilder<TProperty> IsFullTextProperty<TProperty>(
+    public static PropertyBuilder<TProperty> EnableFullTextSearch<TProperty>(
         this PropertyBuilder<TProperty> propertyBuilder,
         string? language = null)
-        => (PropertyBuilder<TProperty>)IsFullTextProperty((PropertyBuilder)propertyBuilder, language);
+        => (PropertyBuilder<TProperty>)EnableFullTextSearch((PropertyBuilder)propertyBuilder, language);
 
     /// <summary>
-    ///     Configures the property to enable full-text search for Azure Cosmos DB using a specified language.
+    ///     Enables full-text search for this property using a specified language.
     /// </summary>
     /// <remarks>
     ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see>, and
     ///     <see href="https://aka.ms/efcore-docs-cosmos">Accessing Azure Cosmos DB with EF Core</see> for more information and examples.
     /// </remarks>
     /// <param name="propertyBuilder">The builder for the property being configured.</param>
-    /// <param name="language">The language for the full-text search.</param>
+    /// <param name="language">The language used for full-text search. Setting this to (<see langword="null" /> will use the default language for the container, or "en-US" if default language was not specified.</param>
     /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
     /// <returns>
     ///     The same builder instance if the configuration was applied,
     ///     <see langword="null" /> otherwise.
     /// </returns>
     [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
-    public static IConventionPropertyBuilder? IsFullTextProperty(
+    public static IConventionPropertyBuilder? EnableFullTextSearch(
         this IConventionPropertyBuilder propertyBuilder,
         string? language,
         bool fromDataAnnotation = false)
     {
-        if (!propertyBuilder.CanSetIsFullTextProperty(language, fromDataAnnotation))
+        if (!propertyBuilder.CanSetEnableFullTextSearch(language, fromDataAnnotation))
         {
             return null;
         }
 
+        propertyBuilder.Metadata.SetIsFullTextSearchEnabled(true, fromDataAnnotation);
         propertyBuilder.Metadata.SetFullTextSearchLanguage(language, fromDataAnnotation);
 
         return propertyBuilder;
     }
 
     /// <summary>
-    ///     Returns a value indicating whether the property can be used with full-text search using a specified language.
+    ///     Returns a value indicating whether full-text search can be enabled for this property using a specified language.
     /// </summary>
     /// <remarks>
     ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see>, and
     ///     <see href="https://aka.ms/efcore-docs-cosmos">Accessing Azure Cosmos DB with EF Core</see> for more information and examples.
     /// </remarks>
     /// <param name="propertyBuilder">The builder for the property being configured.</param>
-    /// <param name="language">The language for the full-text search.</param>
+    /// <param name="language">The language for full-text search.</param>
     /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
     /// <returns><see langword="true" /> if the vector type can be set.</returns>
     [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
-    public static bool CanSetIsFullTextProperty(
+    public static bool CanSetEnableFullTextSearch(
         this IConventionPropertyBuilder propertyBuilder,
         string? language,
         bool fromDataAnnotation = false)
-        => propertyBuilder.CanSetAnnotation(
-            CosmosAnnotationNames.FullTextSearchLanguage,
-            language,
-            fromDataAnnotation);
+        => propertyBuilder.CanSetAnnotation(CosmosAnnotationNames.IsFullTextSearchEnabled, true, fromDataAnnotation)
+            && propertyBuilder.CanSetAnnotation(CosmosAnnotationNames.FullTextSearchLanguage, language, fromDataAnnotation);
+
+    /// <summary>
+    ///     Disables full-text search, if it was prevously enabled for this property.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see>, and
+    ///     <see href="https://aka.ms/efcore-docs-cosmos">Accessing Azure Cosmos DB with EF Core</see> for more information and examples.
+    /// </remarks>
+    /// <param name="propertyBuilder">The builder for the property being configured.</param>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+    [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
+    public static PropertyBuilder DisableFullTextSearch(
+        this PropertyBuilder propertyBuilder)
+    {
+        propertyBuilder.Metadata.SetIsFullTextSearchEnabled(false);
+
+        return propertyBuilder;
+    }
+
+    /// <summary>
+    ///     Disables full-text search, if it was prevously enabled for this property.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see>, and
+    ///     <see href="https://aka.ms/efcore-docs-cosmos">Accessing Azure Cosmos DB with EF Core</see> for more information and examples.
+    /// </remarks>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see>, and
+    ///     <see href="https://aka.ms/efcore-docs-cosmos">Accessing Azure Cosmos DB with EF Core</see> for more information and examples.
+    /// </remarks>
+    /// <typeparam name="TProperty">The type of the property being configured.</typeparam>
+    /// <param name="propertyBuilder">The builder for the property being configured.</param>
+    /// <returns>The same builder instance so that multiple calls can be chained.</returns>
+    [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
+    public static PropertyBuilder<TProperty> DisableFullTextSearch<TProperty>(
+        this PropertyBuilder<TProperty> propertyBuilder)
+        => (PropertyBuilder<TProperty>)DisableFullTextSearch((PropertyBuilder)propertyBuilder);
+
+    /// <summary>
+    ///     Disables full-text search, if it was prevously enabled for this property.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see>, and
+    ///     <see href="https://aka.ms/efcore-docs-cosmos">Accessing Azure Cosmos DB with EF Core</see> for more information and examples.
+    /// </remarks>
+    /// <param name="propertyBuilder">The builder for the property being configured.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    /// <returns>
+    ///     The same builder instance if the configuration was applied,
+    ///     <see langword="null" /> otherwise.
+    /// </returns>
+    [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
+    public static IConventionPropertyBuilder? DisableFullTextSearch(
+        this IConventionPropertyBuilder propertyBuilder,
+        bool fromDataAnnotation = false)
+    {
+        if (!propertyBuilder.CanSetDisableFullTextSearch(fromDataAnnotation))
+        {
+            return null;
+        }
+
+        propertyBuilder.Metadata.SetIsFullTextSearchEnabled(false, fromDataAnnotation);
+
+        return propertyBuilder;
+    }
+
+    /// <summary>
+    ///     Returns a value indicating whether full-text search can be disabled for this property.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-modeling">Modeling entity types and relationships</see>, and
+    ///     <see href="https://aka.ms/efcore-docs-cosmos">Accessing Azure Cosmos DB with EF Core</see> for more information and examples.
+    /// </remarks>
+    /// <param name="propertyBuilder">The builder for the property being configured.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    /// <returns><see langword="true" /> if the vector type can be set.</returns>
+    [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
+    public static bool CanSetDisableFullTextSearch(
+        this IConventionPropertyBuilder propertyBuilder,
+        bool fromDataAnnotation = false)
+        => propertyBuilder.CanSetAnnotation(CosmosAnnotationNames.IsFullTextSearchEnabled, false, fromDataAnnotation);
 }

src/EFCore.Cosmos/Extensions/CosmosPropertyExtensions.cs

@@ -129,32 +129,72 @@ public static void SetVectorType(this IMutableProperty property, CosmosVectorTyp
     public static ConfigurationSource? GetVectorTypeConfigurationSource(this IConventionProperty property)
         => property.FindAnnotation(CosmosAnnotationNames.VectorType)?.GetConfigurationSource();
 
+    /// <summary>
+    ///     Returns the value indicating whether full-text search is enabled for this property.
+    /// </summary>
+    /// <param name="property">The property.</param>
+    /// <returns><see langword="true" /> if full-text search is enabled for this property, <see langword="false" /> otherwise.</returns>
+    [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
+    public static bool? GetIsFullTextSearchEnabled(this IReadOnlyProperty property)
+        => (bool?)property[CosmosAnnotationNames.IsFullTextSearchEnabled];
+
+    /// <summary>
+    ///     Enables full-text search for this property.
+    /// </summary>
+    /// <param name="property">The property.</param>
+    /// <param name="enabled">Indicates whether full-text search is enabled for the property.</param>
+    [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
+    public static void SetIsFullTextSearchEnabled(this IMutableProperty property, bool enabled)
+        => property.SetAnnotation(CosmosAnnotationNames.IsFullTextSearchEnabled, enabled);
+
+    /// <summary>
+    ///     Enables full-text search for this property.
+    /// </summary>
+    /// <param name="property">The property.</param>
+    /// <param name="enabled">Indicates whether full-text search is enabled for the property.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    /// <returns>The configured value.</returns>
+    [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
+    public static string? SetIsFullTextSearchEnabled(
+        this IConventionProperty property,
+        bool enabled,
+        bool fromDataAnnotation = false)
+        => (string?)property.SetAnnotation(
+            CosmosAnnotationNames.IsFullTextSearchEnabled,
+            enabled,
+            fromDataAnnotation)?.Value;
+
+    /// <summary>
+    ///     Gets the <see cref="ConfigurationSource" /> for enabling full-text search for this property.
+    /// </summary>
+    /// <param name="property">The property.</param>
+    /// <returns>
+    ///     The <see cref="ConfigurationSource" /> for enabling full-text search for this property.
+    /// </returns>
+    [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
+    public static ConfigurationSource? GetIsFullTextSearchEnabledConfigurationSource(this IConventionProperty property)
+        => property.FindAnnotation(CosmosAnnotationNames.IsFullTextSearchEnabled)?.GetConfigurationSource();
+
     /// <summary>
     ///     Returns the full-text search language defined for this property.
     /// </summary>
     /// <param name="property">The property.</param>
-    /// <returns>Returns the definition of the vector stored in this property.</returns>
+    /// <returns>The full-text search language for this property.</returns>
     [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
     public static string? GetFullTextSearchLanguage(this IReadOnlyProperty property)
-    {
-        var annotation = property.FindAnnotation(CosmosAnnotationNames.FullTextSearchLanguage);
-
-        return annotation != null
-            ? (string?)annotation.Value ?? (property.DeclaringType as IReadOnlyEntityType)?.GetDefaultFullTextSearchLanguage() ?? "en-US"
-            : null;
-    }
+        => (string?)property[CosmosAnnotationNames.FullTextSearchLanguage];
 
     /// <summary>
     ///     Sets the full-text search language defined for this property.
     /// </summary>
     /// <param name="property">The property.</param>
-    /// <param name="language">The full-text search language for the property.</param>
+    /// <param name="language">The full-text search language for this property.</param>
     [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
     public static void SetFullTextSearchLanguage(this IMutableProperty property, string? language)
         => property.SetAnnotation(CosmosAnnotationNames.FullTextSearchLanguage, language);
 
     /// <summary>
-    ///     Sets the definition of the vector stored in this property.
+    ///     Sets the full-text search language defined for this property.
     /// </summary>
     /// <param name="property">The property.</param>
     /// <param name="language">The full-text search language for the property.</param>

src/EFCore.Cosmos/Infrastructure/Internal/CosmosModelValidator.cs

@@ -594,7 +594,15 @@ protected virtual void ValidateIndexes(
                 }
                 else if (index.IsFullTextIndex() == true)
                 {
-                    // allow these, validation happens during container creation
+                    // composite vector validation is done during container creation
+                    if (index.Properties[0].GetIsFullTextSearchEnabled() != true)
+                    {
+                        throw new InvalidOperationException(
+                            CosmosStrings.FullTextIndexOnNonFullTextProperty(
+                                index.DeclaringEntityType.DisplayName(),
+                                index.Properties[0].Name,
+                                nameof(CosmosPropertyBuilderExtensions.EnableFullTextSearch)));
+                    }
                 }
                 else
                 {

src/EFCore.Cosmos/Metadata/Internal/CosmosAnnotationNames.cs

@@ -63,6 +63,15 @@ public static class CosmosAnnotationNames
     [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
     public const string DefaultFullTextSearchLanguage = Prefix + "DefaultFullTextSearchLanguage";
 
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    [Experimental(EFDiagnostics.CosmosFullTextSearchExperimental)]
+    public const string IsFullTextSearchEnabled = Prefix + "IsFullTextSearchEnabled";
+
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in