Dev/rubencerna/vector support graphql

.pipelines/mssql-pipelines.yml

@@ -177,7 +177,7 @@ jobs:
       # for the linux job above.
       data-source.connection-string: Server=(localdb)\MSSQLLocalDB;Persist Security Info=False;Integrated Security=True;MultipleActiveResultSets=False;Connection Timeout=30;TrustServerCertificate=True;
       InstallerUrl: https://download.microsoft.com/download/7/c/1/7c14e92e-bdcb-4f89-b7cf-93543e7112d1/SqlLocalDB.msi
-      SqlVersionCode: '15.0'
+      SqlVersionCode: '17.0'
 
   steps:
   - template: templates/mssql-test-steps.yml
@@ -200,7 +200,7 @@ jobs:
       # for the linux job above.
       data-source.connection-string: Server=(localdb)\MSSQLLocalDB;Persist Security Info=False;Integrated Security=True;MultipleActiveResultSets=False;Connection Timeout=30;TrustServerCertificate=True;
       InstallerUrl: https://download.microsoft.com/download/7/c/1/7c14e92e-bdcb-4f89-b7cf-93543e7112d1/SqlLocalDB.msi
-      SqlVersionCode: '15.0'
+      SqlVersionCode: '17.0'
 
   steps:
   - template: templates/mssql-test-steps.yml

config-generators/mssql-commands.txt

@@ -16,6 +16,8 @@ add Broker --config "dab-config.MsSql.json" --source brokers --permissions "anon
 add WebsiteUser --config "dab-config.MsSql.json" --source website_users --permissions "anonymous:create,read,delete,update"
 add WebsiteUser_MM --config "dab-config.MsSql.json" --source website_users_mm --graphql "websiteuser_mm:websiteusers_mm" --permissions "anonymous:*"
 add SupportedType --config "dab-config.MsSql.json" --source type_table --permissions "anonymous:create,read,delete,update"
+add VectorType --config "dab-config.MsSql.json" --source vector_type_table --rest true --graphql false --permissions "anonymous:create,read,delete,update"
+update VectorType --config "dab-config.MsSql.json" --permissions "authenticated:create,read,delete,update"
 add stocks_price --config "dab-config.MsSql.json" --source stocks_price --permissions "authenticated:create,read,update,delete"
 update stocks_price --config "dab-config.MsSql.json" --permissions "anonymous:read"
 update stocks_price --config "dab-config.MsSql.json" --permissions "TestNestedFilterFieldIsNull_ColumnForbidden:read" --fields.exclude "price"

scripts/start-mssql-server.bash

@@ -27,7 +27,7 @@ echo "forceencryption = 1" >> $CERT_DIR/mssql.conf
 cat $CERT_DIR/mssql.conf
 
 # Start mssql-server by volume mounting the cert, key and conf files.
-docker run -e "ACCEPT_EULA=Y" -e "MSSQL_SA_PASSWORD=$DOCKER_SQL_PASS" -p 1433:1433 --name customerdb -h customerdb -v $CERT_DIR/mssql.conf:/var/opt/mssql/mssql.conf -v $CERT_DIR/mssql.pem:/var/opt/mssql/mssql.pem -v $CERT_DIR/mssql.key:/var/opt/mssql/mssql.key -d mcr.microsoft.com/mssql/server:2019-latest
+docker run -e "ACCEPT_EULA=Y" -e "MSSQL_SA_PASSWORD=$DOCKER_SQL_PASS" -p 1433:1433 --name customerdb -h customerdb -v $CERT_DIR/mssql.conf:/var/opt/mssql/mssql.conf -v $CERT_DIR/mssql.pem:/var/opt/mssql/mssql.pem -v $CERT_DIR/mssql.key:/var/opt/mssql/mssql.key -d mcr.microsoft.com/mssql/server:2025-latest
 sleep 30
 docker logs customerdb
 

src/Core/Models/SqlTypeConstants.cs

@@ -48,6 +48,7 @@ public static class SqlTypeConstants
         { "datetime2", true },            // SqlDbType.DateTime2
         { "datetimeoffset", true },       // SqlDbType.DateTimeOffset
         { "", false },                    // SqlDbType.Udt and SqlDbType.Structured provided by SQL as empty strings (unsupported)
-        { "numeric", true}                // Not present in SqlDbType, however can be returned by sql functions like LAG and should map to decimal.
+        { "numeric", true},                // Not present in SqlDbType, however can be returned by sql functions like LAG and should map to decimal.
+        { "vector", true }                // SqlDbType.Vector
     };
 }

src/Core/Resolvers/MsSqlQueryBuilder.cs

@@ -666,8 +666,7 @@ AND ty.name IN
                                     N'hierarchyid',
                                     N'sql_variant',
                                     N'xml',
-                                    N'rowversion',
-                                    N'vector'
+                                    N'rowversion'
                                 )
                         ) THEN 1
                         ELSE 0
@@ -712,8 +711,7 @@ AND ty.name IN
                                     N'hierarchyid',
                                     N'sql_variant',
                                     N'xml',
-                                    N'rowversion',
-                                    N'vector'
+                                    N'rowversion'
                                 )
                         )
                     )

src/Core/Resolvers/MsSqlQueryExecutor.cs

@@ -18,6 +18,7 @@
 using Azure.Identity;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Data.SqlClient;
+using Microsoft.Data.SqlTypes;
 using Microsoft.Extensions.Logging;
 
 namespace Azure.DataApiBuilder.Core.Resolvers
@@ -695,6 +696,19 @@ public override SqlCommand PrepareDbCommand(
                         parameter.Size = parameterEntry.Value.Length.Value;
                     }
 
+                    // if sqldbtype is vector then set the value as an SqlVector object
+                    if (parameter.SqlDbType is SqlDbType.Vector)
+                    {
+                        List<float> values = new();
+                        foreach (float val in (Array)parameter.Value)
+                        {
+                            values.Add(val);
+                        }
+
+                        SqlVector<float> value = new(values.ToArray());
+                        parameter.Value = value;
+                    }
+
                     cmd.Parameters.Add(parameter);
                 }
             }

src/Core/Resolvers/MultipleCreateOrderHelper.cs

@@ -385,7 +385,7 @@ private static RelationshipFields GetRelationshipFieldsInSourceAndTarget(
             foreach (ObjectFieldNode field in fieldNodes)
             {
                 Tuple<IValueNode?, SyntaxKind> fieldDetails = GraphQLUtils.GetFieldDetails(field.Value, context.Variables);
-                SyntaxKind fieldKind = fieldDetails.Item2;
+                SyntaxKind fieldKind = metadataProvider.TryGetUnderlyingFieldKind(entityName, field.Name.Value, out SyntaxKind arrayFieldKind) ? arrayFieldKind : fieldDetails.Item2;
                 if (GraphQLUtils.IsScalarField(fieldKind) && metadataProvider.TryGetBackingColumn(entityName, field.Name.Value, out string? backingColumnName))
                 {
                     backingColumnData.Add(backingColumnName, fieldDetails.Item1);

src/Core/Resolvers/QueryExecutor.cs

@@ -13,6 +13,7 @@
 using Azure.DataApiBuilder.Core.Models;
 using Azure.DataApiBuilder.Service.Exceptions;
 using Microsoft.AspNetCore.Http;
+using Microsoft.Data.SqlTypes;
 using Microsoft.Extensions.Logging;
 using Polly;
 using Polly.Retry;
@@ -502,7 +503,7 @@ public async Task<DbResultSet>
                             {
                                 if (!ConfigProvider.GetConfig().MaxResponseSizeLogicEnabled())
                                 {
-                                    dbResultSetRow.Columns.Add(columnName, dbDataReader[columnName]);
+                                    dbResultSetRow.Columns.Add(columnName, GetColumnInformation(dbDataReader, columnName));
                                 }
                                 else
                                 {
@@ -554,7 +555,7 @@ public DbResultSet
                             {
                                 if (!ConfigProvider.GetConfig().MaxResponseSizeLogicEnabled())
                                 {
-                                    dbResultSetRow.Columns.Add(columnName, dbDataReader[columnName]);
+                                    dbResultSetRow.Columns.Add(columnName, GetColumnInformation(dbDataReader, columnName));
                                 }
                                 else
                                 {
@@ -822,7 +823,7 @@ internal int StreamDataIntoDbResultSetRow(DbDataReader dbDataReader, DbResultSet
             {
                 dataRead = columnSize;
                 ValidateSize(availableBytes, dataRead);
-                dbResultSetRow.Columns.Add(columnName, dbDataReader[columnName]);
+                dbResultSetRow.Columns.Add(columnName, GetColumnInformation(dbDataReader, columnName));
             }
 
             return dataRead;
@@ -885,6 +886,22 @@ private void ValidateSize(long availableSizeBytes, long sizeToBeReadBytes)
             }
         }
 
+        /// <summary>
+        /// Helper function to get column information from the DbDataReader and handle special cases like SqlVector<float>.
+        /// </summary>
+        /// <param name="dbDataReader"></param>
+        /// <param name="columnName"></param>
+        /// <returns></returns>
+        private static object GetColumnInformation(DbDataReader dbDataReader, string columnName)
+        {
+            if (dbDataReader[columnName] is SqlVector<float> columnValue)
+            {
+                return columnValue.Memory;
+            }
+
+            return dbDataReader[columnName];
+        }
+
         internal virtual void AddDbExecutionTimeToMiddlewareContext(long time)
         {
             HttpContext? httpContext = HttpContextAccessor?.HttpContext;

src/Core/Resolvers/Sql Query Structures/BaseSqlQueryStructure.cs

@@ -4,6 +4,7 @@
 using System.Data;
 using System.Globalization;
 using System.Net;
+using System.Text.Json;
 using Azure.DataApiBuilder.Auth;
 using Azure.DataApiBuilder.Config.DatabasePrimitives;
 using Azure.DataApiBuilder.Config.ObjectModel;
@@ -452,10 +453,50 @@ protected static object ParseParamAsSystemType(string param, Type systemType)
                 "Guid" => Guid.Parse(param),
                 "TimeOnly" => TimeOnly.Parse(param),
                 "TimeSpan" => TimeOnly.Parse(param),
+                "Single[]" => ParseArrayIntoSystemType(param, systemType),
                 _ => throw new NotSupportedException($"{systemType.Name} is not supported")
             };
         }
 
+        /// <summary>
+        /// Takes the array of the parameter we are going to parse and converts each element to the specified system type.
+        /// </summary>
+        /// <param name="param"></param>
+        /// <param name="systemType"></param>
+        /// <returns></returns>
+        /// <exception cref="NotSupportedException"></exception>
+        /// <exception cref="FormatException"></exception>
+        private static object ParseArrayIntoSystemType(string param, Type systemType)
+        {
+            Type typeOfArray;
+            switch (systemType.Name)
+            {
+                case "Single[]":
+                    typeOfArray = typeof(Single);
+                    break;
+
+                default:
+                    throw new NotSupportedException($"{systemType.Name} is not supported");
+            }
+
+            try
+            {
+                List<object> list = new();
+                object[] values = JsonSerializer.Deserialize<object[]>(param) ?? Array.Empty<object>();
+                for (int i = 0; i < values.Length; i++)
+                {
+                    string stringValue = values[i]?.ToString() ?? string.Empty;
+                    values[i] = ParseParamAsSystemType(stringValue, typeOfArray);
+                }
+
+                return values;
+            }
+            catch
+            {
+                throw new FormatException($"Expected an array for {systemType.Name} but got an unexpected value");
+            }
+        }
+
         /// <summary>
         /// Very similar to GQLArgumentToDictParams but only extracts the argument names from
         /// the specified field which means that the method does not need a middleware context

src/Core/Resolvers/Sql Query Structures/SqlInsertQueryStructure.cs

@@ -2,13 +2,15 @@
 // Licensed under the MIT License.
 
 using System.Net;
+using System.Text.Json;
 using Azure.DataApiBuilder.Auth;
 using Azure.DataApiBuilder.Config.DatabasePrimitives;
 using Azure.DataApiBuilder.Config.ObjectModel;
 using Azure.DataApiBuilder.Core.Models;
 using Azure.DataApiBuilder.Core.Services;
 using Azure.DataApiBuilder.Service.Exceptions;
 using Azure.DataApiBuilder.Service.GraphQLBuilder.Mutations;
+using HotChocolate.Language;
 using HotChocolate.Resolvers;
 using Microsoft.AspNetCore.Http;
 
@@ -111,8 +113,17 @@ private void PopulateColumnsAndParams(string columnName, object? value)
 
             if (value is not null)
             {
+                // Array/vector columns (e.g. SQL Server 'vector') arrive as a List<IValueNode>.
+                // Calling ToString() on a list/array only yields the CLR type name, so instead extract
+                // the underlying element values and serialize them into a JSON array string (e.g. "[1.5,2.5,3.5]").
+                string stringifiedValue = value switch
+                {
+                    IEnumerable<IValueNode> valueNodes => JsonSerializer.Serialize(valueNodes.Select(TypeHelper.GetValue)),
+                    _ => value.ToString()!
+                };
+
                 paramName = MakeDbConnectionParam(
-                    GetParamAsSystemType(value.ToString()!, columnName, GetColumnSystemType(columnName)), columnName);
+                    GetParamAsSystemType(stringifiedValue, columnName, GetColumnSystemType(columnName)), columnName);
             }
             else
             {

src/Core/Resolvers/SqlMutationEngine.cs

@@ -1088,7 +1088,7 @@ await queryExecutor.ExecuteQueryAsync(
             string rootFieldName = isMultipleInputType ? MULTIPLE_INPUT_ARGUEMENT_NAME : SINGLE_INPUT_ARGUEMENT_NAME;
 
             // Parse the hotchocolate input parameters into .net object types
-            object? parsedInputParams = GQLMultipleCreateArgumentToDictParams(context, rootFieldName, mutationInputParamsFromGQLContext);
+            object? parsedInputParams = GQLMultipleCreateArgumentToDictParams(context, rootFieldName, mutationInputParamsFromGQLContext, sqlMetadataProvider, entityName);
 
             if (parsedInputParams is null)
             {
@@ -1758,14 +1758,16 @@ private static void PopulateCurrentAndLinkingEntityParams(
         internal static object? GQLMultipleCreateArgumentToDictParams(
                 IMiddlewareContext context,
                 string rootFieldName,
-                IDictionary<string, object?> mutationParameters)
+                IDictionary<string, object?> mutationParameters,
+                ISqlMetadataProvider metadataProvider,
+                string entityName)
         {
             if (mutationParameters.TryGetValue(rootFieldName, out object? inputParameters))
             {
                 ObjectField fieldSchema = context.Selection.Field;
                 IInputValueDefinition itemsArgumentSchema = fieldSchema.Arguments[rootFieldName];
                 InputObjectType inputObjectType = ExecutionHelper.InputObjectTypeFromIInputField(itemsArgumentSchema);
-                return GQLMultipleCreateArgumentToDictParamsHelper(context, inputObjectType, inputParameters);
+                return GQLMultipleCreateArgumentToDictParamsHelper(context, inputObjectType, inputParameters, metadataProvider, entityName);
             }
             else
             {
@@ -1813,7 +1815,9 @@ private static void PopulateCurrentAndLinkingEntityParams(
         internal static object? GQLMultipleCreateArgumentToDictParamsHelper(
             IMiddlewareContext context,
             InputObjectType inputObjectType,
-            object? inputParameters)
+            object? inputParameters,
+            ISqlMetadataProvider metadataProvider,
+            string entityName)
         {
             // This condition is met for input types that accept an array of values
             // where the mutation input field is 'items' such as
@@ -1835,7 +1839,9 @@ private static void PopulateCurrentAndLinkingEntityParams(
                     object? parsedInputFieldItem = GQLMultipleCreateArgumentToDictParamsHelper(
                                             context: context,
                                             inputObjectType: inputObjectType,
-                                            inputParameters: inputField.Value);
+                                            inputParameters: inputField.Value,
+                                            metadataProvider: metadataProvider,
+                                            entityName: entityName);
                     if (parsedInputFieldItem is not null)
                     {
                         parsedInputFieldItems.Add((IDictionary<string, object?>)parsedInputFieldItem);
@@ -1862,33 +1868,40 @@ private static void PopulateCurrentAndLinkingEntityParams(
                 foreach (ObjectFieldNode inputFieldNode in inputFieldNodes)
                 {
                     string fieldName = inputFieldNode.Name.Value;
+                    SyntaxKind fieldKind = metadataProvider.TryGetUnderlyingFieldKind(entityName, fieldName, out SyntaxKind arrayFieldKind)
+                        ? arrayFieldKind : inputFieldNode.Value.Kind;
+
                     // For the mutation pointMultipleCreateExample (outlined in the method summary),
                     // the following condition will evaluate to true for fields 'authors' and 'reviews'.
                     // Fields 'authors'/'reviews' can again consist of combination of scalar and relationship fields.
                     // So, the input object type for 'authors'/'reviews' is fetched and the same function is
                     // invoked with the fetched input object type again to parse the input fields of 'authors'/'reviews'.
-                    if (inputFieldNode.Value.Kind == SyntaxKind.ListValue)
+                    if (fieldKind == SyntaxKind.ListValue)
                     {
                         parsedInputFields.Add(
                             fieldName,
                             GQLMultipleCreateArgumentToDictParamsHelper(
                                 context,
                                 GetInputObjectTypeForAField(fieldName, inputObjectType.Fields),
-                                inputFieldNode.Value.Value));
+                                inputFieldNode.Value.Value,
+                                metadataProvider,
+                                entityName));
                     }
                     // For the mutation pointMultipleCreateExample (outlined in the method summary),
                     // the following condition will evaluate to true for fields 'publishers'.
                     // Field 'publishers' can again consist of combination of scalar and relationship fields.
                     // So, the input object type for 'publishers' is fetched and the same function is
                     // invoked with the fetched input object type again to parse the input fields of 'publishers'.
-                    else if (inputFieldNode.Value.Kind == SyntaxKind.ObjectValue)
+                    else if (fieldKind == SyntaxKind.ObjectValue)
                     {
                         parsedInputFields.Add(
                             fieldName,
                             GQLMultipleCreateArgumentToDictParamsHelper(
                                 context,
                                 GetInputObjectTypeForAField(fieldName, inputObjectType.Fields),
-                                inputFieldNode.Value.Value));
+                                inputFieldNode.Value.Value,
+                                metadataProvider,
+                                entityName));
                     }
                     // The flow enters this block for all scalar input fields.
                     else
@@ -2366,7 +2379,7 @@ private void ProcessObjectFieldNodesForAuthZ(
             foreach (ObjectFieldNode field in fieldNodes)
             {
                 Tuple<IValueNode?, SyntaxKind> fieldDetails = GraphQLUtils.GetFieldDetails(field.Value, context.Variables);
-                SyntaxKind underlyingFieldKind = fieldDetails.Item2;
+                SyntaxKind underlyingFieldKind = metadataProvider.TryGetUnderlyingFieldKind(entityName, field.Name.Value, out SyntaxKind arrayFieldKind) ? arrayFieldKind : fieldDetails.Item2;
 
                 // For a column field, we do not have to recurse to process fields in the value - which is required for relationship fields.
                 if (GraphQLUtils.IsScalarField(underlyingFieldKind) || underlyingFieldKind is SyntaxKind.NullValue)