split CosmosVectorType into two annotations (distance function and dimensions) so that we can keep CVT pubternal

Author: maumar

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

@@ -121,7 +121,9 @@ public static PropertyBuilder IsVectorProperty(
         DistanceFunction distanceFunction,
         int dimensions)
     {
-        propertyBuilder.Metadata.SetVectorType(CreateVectorType(distanceFunction, dimensions));
+        propertyBuilder.Metadata.SetVectorDistanceFunction(ValidateVectorDistanceFunction(distanceFunction));
+        propertyBuilder.Metadata.SetVectorDimensions(dimensions);
+
         return propertyBuilder;
     }
 
@@ -168,36 +170,66 @@ public static PropertyBuilder<TProperty> IsVectorProperty<TProperty>(
         int dimensions,
         bool fromDataAnnotation = false)
     {
-        if (!propertyBuilder.CanSetIsVectorProperty(distanceFunction, dimensions, fromDataAnnotation))
+        if (!propertyBuilder.CanSetVectorPropertyDistanceFunction(distanceFunction, fromDataAnnotation)
+            || !propertyBuilder.CanSetVectorPropertyDimensions(dimensions, fromDataAnnotation))
         {
             return null;
         }
 
-        propertyBuilder.Metadata.SetVectorType(CreateVectorType(distanceFunction, dimensions), fromDataAnnotation);
+
+        propertyBuilder.Metadata.SetVectorDistanceFunction(ValidateVectorDistanceFunction(distanceFunction), fromDataAnnotation);
+        propertyBuilder.Metadata.SetVectorDimensions(dimensions, fromDataAnnotation);
 
         return propertyBuilder;
     }
 
     /// <summary>
-    ///     Returns a value indicating whether the vector type can be set.
+    ///     Returns a value indicating whether the vector distance function can be set.
     /// </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="distanceFunction">The distance function for a vector comparisons.</param>
-    /// <param name="dimensions">The number of dimensions in the vector.</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>
-    public static bool CanSetIsVectorProperty(
+    /// <returns><see langword="true" /> if the vector distance function can be set.</returns>
+    public static bool CanSetVectorPropertyDistanceFunction(
         this IConventionPropertyBuilder propertyBuilder,
         DistanceFunction distanceFunction,
+        bool fromDataAnnotation = false)
+        => propertyBuilder.CanSetAnnotation(
+            CosmosAnnotationNames.VectorDistanceFunction,
+            ValidateVectorDistanceFunction(distanceFunction),
+            fromDataAnnotation);
+
+    private static DistanceFunction ValidateVectorDistanceFunction(DistanceFunction distanceFunction)
+        => Enum.IsDefined(distanceFunction)
+            ? distanceFunction
+            : throw new ArgumentException(
+                CoreStrings.InvalidEnumValue(
+                    distanceFunction,
+                    nameof(distanceFunction),
+                    typeof(DistanceFunction)));
+
+    /// <summary>
+    ///     Returns a value indicating whether the vector dimensions can be set.
+    /// </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="dimensions">The number of dimensions in the vector.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    /// <returns><see langword="true" /> if the vector dimensions can be set.</returns>
+    public static bool CanSetVectorPropertyDimensions(
+        this IConventionPropertyBuilder propertyBuilder,
         int dimensions,
         bool fromDataAnnotation = false)
         => propertyBuilder.CanSetAnnotation(
-            CosmosAnnotationNames.VectorType,
-            CreateVectorType(distanceFunction, dimensions),
+            CosmosAnnotationNames.VectorDimensions,
+            dimensions,
             fromDataAnnotation);
 
     /// <summary>
@@ -233,12 +265,6 @@ public static PropertyBuilder<TProperty> IsETagConcurrency<TProperty>(
         this PropertyBuilder<TProperty> propertyBuilder)
         => (PropertyBuilder<TProperty>)IsETagConcurrency((PropertyBuilder)propertyBuilder);
 
-    private static CosmosVectorType CreateVectorType(DistanceFunction distanceFunction, int dimensions)
-        => Enum.IsDefined(distanceFunction)
-            ? new CosmosVectorType(distanceFunction, dimensions)
-            : throw new ArgumentException(
-                CoreStrings.InvalidEnumValue(distanceFunction, nameof(distanceFunction), typeof(DistanceFunction)));
-
     /// <summary>
     ///     Enables full-text search for this property using a specified language.
     /// </summary>

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

@@ -84,46 +84,88 @@ public static void SetJsonPropertyName(this IMutableProperty property, string? n
         => property.FindAnnotation(CosmosAnnotationNames.PropertyName)?.GetConfigurationSource();
 
     /// <summary>
-    ///     Returns the definition of the vector stored in this property.
+    ///     Returns the distance function of the vector stored in this property.
     /// </summary>
     /// <param name="property">The property.</param>
-    /// <returns>Returns the definition of the vector stored in this property.</returns>
-    public static CosmosVectorType? GetVectorType(this IReadOnlyProperty property)
-        => (CosmosVectorType?)property[CosmosAnnotationNames.VectorType];
+    /// <returns>Returns the distance function of the vector stored in this property.</returns>
+    public static DistanceFunction? GetVectorDistanceFunction(this IReadOnlyProperty property)
+        => (DistanceFunction?)property[CosmosAnnotationNames.VectorDistanceFunction];
 
     /// <summary>
-    ///     Sets the definition of the vector stored in this property.
+    ///     Returns the dimensions of the vector stored in this property.
     /// </summary>
     /// <param name="property">The property.</param>
-    /// <param name="vectorType">The type of vector stored in the property.</param>
-    public static void SetVectorType(this IMutableProperty property, CosmosVectorType? vectorType)
-        => property.SetOrRemoveAnnotation(CosmosAnnotationNames.VectorType, vectorType);
+    /// <returns>Returns the dimensions of the vector stored in this property.</returns>
+    public static int? GetVectorDimensions(this IReadOnlyProperty property)
+        => (int?)property[CosmosAnnotationNames.VectorDimensions];
 
     /// <summary>
-    ///     Sets the definition of the vector stored in this property.
+    ///     Sets the distance function of the vector stored in this property.
     /// </summary>
     /// <param name="property">The property.</param>
-    /// <param name="vectorType">The type of vector stored in the property.</param>
+    /// <param name="distanceFunction">The distance function of the vector stored in the property.</param>
+    public static void SetVectorDistanceFunction(this IMutableProperty property, DistanceFunction? distanceFunction)
+        => property.SetOrRemoveAnnotation(CosmosAnnotationNames.VectorDistanceFunction, distanceFunction);
+
+    /// <summary>
+    ///     Sets the dimensions of the vector stored in this property.
+    /// </summary>
+    /// <param name="property">The property.</param>
+    /// <param name="dimensions">The dimensions of the vector stored in the property.</param>
+    public static void SetVectorDimensions(this IMutableProperty property, int? dimensions)
+        => property.SetOrRemoveAnnotation(CosmosAnnotationNames.VectorDimensions, dimensions);
+
+    /// <summary>
+    ///     Sets the distance function of the vector stored in this property.
+    /// </summary>
+    /// <param name="property">The property.</param>
+    /// <param name="distanceFunction">The distance function of the vector stored in the property.</param>
     /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
     /// <returns>The configured value.</returns>
-    public static CosmosVectorType? SetVectorType(
+    public static DistanceFunction? SetVectorDistanceFunction(
         this IConventionProperty property,
-        CosmosVectorType? vectorType,
+        DistanceFunction? distanceFunction,
         bool fromDataAnnotation = false)
-        => (CosmosVectorType?)property.SetOrRemoveAnnotation(
-            CosmosAnnotationNames.VectorType,
-            vectorType,
+        => (DistanceFunction?)property.SetOrRemoveAnnotation(
+            CosmosAnnotationNames.VectorDistanceFunction,
+            distanceFunction,
             fromDataAnnotation)?.Value;
 
     /// <summary>
-    ///     Gets the <see cref="ConfigurationSource" /> for the definition of the vector stored in this property.
+    ///     Sets the dimensions of the vector stored in this property.
+    /// </summary>
+    /// <param name="property">The property.</param>
+    /// <param name="dimensions">The dimensions of the vector stored in the property.</param>
+    /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+    /// <returns>The configured value.</returns>
+    public static int? SetVectorDimensions(
+        this IConventionProperty property,
+        int? dimensions,
+        bool fromDataAnnotation = false)
+        => (int?)property.SetOrRemoveAnnotation(
+            CosmosAnnotationNames.VectorDimensions,
+            dimensions,
+            fromDataAnnotation)?.Value;
+
+    /// <summary>
+    ///     Gets the <see cref="ConfigurationSource" /> for the distance function of the vector stored in this property.
+    /// </summary>
+    /// <param name="property">The property.</param>
+    /// <returns>
+    ///     The <see cref="ConfigurationSource" /> for the distance function of the vector stored in this property.
+    /// </returns>
+    public static ConfigurationSource? GetVectorDistanceFunctionConfigurationSource(this IConventionProperty property)
+        => property.FindAnnotation(CosmosAnnotationNames.VectorDistanceFunction)?.GetConfigurationSource();
+
+    /// <summary>
+    ///     Gets the <see cref="ConfigurationSource" /> for the dimensions of the vector stored in this property.
     /// </summary>
     /// <param name="property">The property.</param>
     /// <returns>
-    ///     The <see cref="ConfigurationSource" /> for the definition of the vector stored in this property.
+    ///     The <see cref="ConfigurationSource" /> for the dimensions of the vector stored in this property.
     /// </returns>
-    public static ConfigurationSource? GetVectorTypeConfigurationSource(this IConventionProperty property)
-        => property.FindAnnotation(CosmosAnnotationNames.VectorType)?.GetConfigurationSource();
+    public static ConfigurationSource? GetVectorDimensionsConfigurationSource(this IConventionProperty property)
+        => property.FindAnnotation(CosmosAnnotationNames.VectorDimensions)?.GetConfigurationSource();
 
     /// <summary>
     ///     Returns the value indicating whether full-text search is enabled for this property.

Diff for: src/EFCore.Cosmos/Infrastructure/Internal/CosmosModelValidator.cs

@@ -584,7 +584,8 @@ protected virtual void ValidateIndexes(
                                 string.Join(",", index.Properties.Select(e => e.Name))));
                     }
 
-                    if (index.Properties[0].GetVectorType() == null)
+                    if (index.Properties[0].GetVectorDistanceFunction() == null
+                        || index.Properties[0].GetVectorDimensions() == null)
                     {
                         throw new InvalidOperationException(
                             CosmosStrings.VectorIndexOnNonVector(
@@ -638,8 +639,8 @@ protected override void ValidatePropertyMapping(
         {
             foreach (var property in entityType.GetDeclaredProperties())
             {
-                var cosmosVectorType = property.GetVectorType();
-                if (cosmosVectorType is not null)
+                if (property.GetVectorDistanceFunction() is not null
+                    && property.GetVectorDimensions() is not null)
                 {
                     // Will throw if the data type is not set and cannot be inferred.
                     CosmosVectorType.CreateDefaultVectorDataType(property.ClrType);

Diff for: src/EFCore.Cosmos/Metadata/Internal/CosmosAnnotationNames.cs

@@ -91,7 +91,15 @@ public static class CosmosAnnotationNames
     ///     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>
-    public const string VectorType = Prefix + "VectorType";
+    public const string VectorDistanceFunction = Prefix + "VectorDistanceFunction";
+
+    /// <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>
+    public const string VectorDimensions = Prefix + "VectorDimensions";
 
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

Diff for: src/EFCore.Cosmos/Storage/Internal/CosmosTypeMappingSource.cs

@@ -50,8 +50,9 @@ public CosmosTypeMappingSource(TypeMappingSourceDependencies dependencies)
         // directly.
         => base.FindMapping(property) switch
         {
-            CosmosTypeMapping mapping when property.FindAnnotation(CosmosAnnotationNames.VectorType)?.Value is CosmosVectorType vectorType
-                => new CosmosVectorTypeMapping(mapping, vectorType),
+            CosmosTypeMapping mapping
+                when property.GetVectorDistanceFunction() is DistanceFunction distanceFunction && property.GetVectorDimensions() is int dimensions
+                => new CosmosVectorTypeMapping(mapping, new CosmosVectorType(distanceFunction, dimensions)),
             var other => other
         };