Improve Execution Performance

src/Core/Models/GraphQLFilterParsers.cs

@@ -11,6 +11,7 @@
 using Azure.DataApiBuilder.Service.Exceptions;
 using Azure.DataApiBuilder.Service.GraphQLBuilder.Directives;
 using Azure.DataApiBuilder.Service.GraphQLBuilder.Queries;
+using Azure.DataApiBuilder.Service.Services;
 using HotChocolate.Language;
 using HotChocolate.Resolvers;
 using Microsoft.AspNetCore.Http;
@@ -65,12 +66,12 @@ public Predicate Parse(
         string dataSourceName = _configProvider.GetConfig().GetDataSourceNameFromEntityName(entityName);
         ISqlMetadataProvider metadataProvider = _metadataProviderFactory.GetMetadataProvider(dataSourceName);
 
-        InputObjectType filterArgumentObject = ResolverMiddleware.InputObjectTypeFromIInputField(filterArgumentSchema);
+        InputObjectType filterArgumentObject = ExecutionHelper.InputObjectTypeFromIInputField(filterArgumentSchema);
 
         List<PredicateOperand> predicates = new();
         foreach (ObjectFieldNode field in fields)
         {
-            object? fieldValue = ResolverMiddleware.ExtractValueFromIValueNode(
+            object? fieldValue = ExecutionHelper.ExtractValueFromIValueNode(
                 value: field.Value,
                 argumentSchema: filterArgumentObject.Fields[field.Name.Value],
                 variables: ctx.Variables);
@@ -85,7 +86,7 @@ public Predicate Parse(
             bool fieldIsAnd = string.Equals(name, $"{PredicateOperation.AND}", StringComparison.OrdinalIgnoreCase);
             bool fieldIsOr = string.Equals(name, $"{PredicateOperation.OR}", StringComparison.OrdinalIgnoreCase);
 
-            InputObjectType filterInputObjectType = ResolverMiddleware.InputObjectTypeFromIInputField(filterArgumentObject.Fields[name]);
+            InputObjectType filterInputObjectType = ExecutionHelper.InputObjectTypeFromIInputField(filterArgumentObject.Fields[name]);
             if (fieldIsAnd || fieldIsOr)
             {
                 PredicateOperation op = fieldIsAnd ? PredicateOperation.AND : PredicateOperation.OR;
@@ -509,7 +510,7 @@ private Predicate ParseAndOr(
         List<PredicateOperand> operands = new();
         foreach (IValueNode field in fields)
         {
-            object? fieldValue = ResolverMiddleware.ExtractValueFromIValueNode(
+            object? fieldValue = ExecutionHelper.ExtractValueFromIValueNode(
                 value: field,
                 argumentSchema: argumentSchema,
                 ctx.Variables);
@@ -598,11 +599,11 @@ public static Predicate Parse(
     {
         List<PredicateOperand> predicates = new();
 
-        InputObjectType argumentObject = ResolverMiddleware.InputObjectTypeFromIInputField(argumentSchema);
+        InputObjectType argumentObject = ExecutionHelper.InputObjectTypeFromIInputField(argumentSchema);
         foreach (ObjectFieldNode field in fields)
         {
             string name = field.Name.ToString();
-            object? value = ResolverMiddleware.ExtractValueFromIValueNode(
+            object? value = ExecutionHelper.ExtractValueFromIValueNode(
                 value: field.Value,
                 argumentSchema: argumentObject.Fields[field.Name.Value],
                 variables: ctx.Variables);

src/Core/Resolvers/ArrayPoolWriter.cs

@@ -0,0 +1,188 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Buffers;
+
+/// <summary>
+/// A helper to write to pooled arrays.
+/// </summary>
+internal sealed class ArrayPoolWriter : IBufferWriter<byte>, IDisposable
+{
+    private const int INITIAL_BUFFER_SIZE = 512;
+    private byte[] _buffer;
+    private int _capacity;
+    private int _start;
+    private bool _disposed;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ArrayPoolWriter"/> class.
+    /// </summary>
+    public ArrayPoolWriter()
+    {
+        _buffer = ArrayPool<byte>.Shared.Rent(INITIAL_BUFFER_SIZE);
+        _capacity = _buffer.Length;
+        _start = 0;
+    }
+
+    /// <summary>
+    /// Gets the part of the buffer that has been written to.
+    /// </summary>
+    /// <returns>
+    /// A <see cref="ReadOnlyMemory{T}"/> of the written portion of the buffer.
+    /// </returns>
+    public ReadOnlyMemory<byte> GetWrittenMemory()
+        => _buffer.AsMemory()[.._start];
+
+    /// <summary>
+    /// Gets the part of the buffer that has been written to.
+    /// </summary>
+    /// <returns>
+    /// A <see cref="ReadOnlySpan{T}"/> of the written portion of the buffer.
+    /// </returns>
+    public ReadOnlySpan<byte> GetWrittenSpan()
+        => _buffer.AsSpan()[.._start];
+
+    /// <summary>
+    /// Advances the writer by the specified number of bytes.
+    /// </summary>
+    /// <param name="count">
+    /// The number of bytes to advance the writer by.
+    /// </param>
+    /// <exception cref="ArgumentOutOfRangeException">
+    /// Thrown if <paramref name="count"/> is negative or
+    /// if <paramref name="count"/> is greater than the
+    /// available capacity on the internal buffer.
+    /// </exception>
+    public void Advance(int count)
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException(nameof(ArrayPoolWriter));
+        }
+
+        if (count < 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(count));
+        }
+
+        if (count > _capacity)
+        {
+            throw new ArgumentOutOfRangeException(nameof(count), count, "Cannot advance past the end of the buffer.");
+        }
+
+        _start += count;
+        _capacity -= count;
+    }
+
+    /// <summary>
+    /// Gets a <see cref="Memory{T}"/> to write to.
+    /// </summary>
+    /// <param name="sizeHint">
+    /// The minimum size of the returned <see cref="Memory{T}"/>.
+    /// </param>
+    /// <returns>
+    /// A <see cref="Memory{T}"/> to write to.
+    /// </returns>
+    /// <exception cref="ArgumentOutOfRangeException">
+    /// Thrown if <paramref name="sizeHint"/> is negative.
+    /// </exception>
+    public Memory<byte> GetMemory(int sizeHint = 0)
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException(nameof(ArrayPoolWriter));
+        }
+
+        if (sizeHint < 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(sizeHint));
+        }
+
+        int size = sizeHint < 1 ? INITIAL_BUFFER_SIZE : sizeHint;
+        EnsureBufferCapacity(size);
+        return _buffer.AsMemory().Slice(_start, size);
+    }
+
+    /// <summary>
+    /// Gets a <see cref="Span{T}"/> to write to.
+    /// </summary>
+    /// <param name="sizeHint">
+    /// The minimum size of the returned <see cref="Span{T}"/>.
+    /// </param>
+    /// <returns>
+    /// A <see cref="Span{T}"/> to write to.
+    /// </returns>
+    /// <exception cref="ArgumentOutOfRangeException">
+    /// Thrown if <paramref name="sizeHint"/> is negative.
+    /// </exception>
+    public Span<byte> GetSpan(int sizeHint = 0)
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException(nameof(ArrayPoolWriter));
+        }
+
+        if (sizeHint < 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(sizeHint));
+        }
+
+        int size = sizeHint < 1 ? INITIAL_BUFFER_SIZE : sizeHint;
+        EnsureBufferCapacity(size);
+        return _buffer.AsSpan().Slice(_start, size);
+    }
+
+    /// <summary>
+    /// Ensures that the internal buffer has the needed capacity.
+    /// </summary>
+    /// <param name="neededCapacity">
+    /// The needed capacity on the internal buffer.
+    /// </param>
+    private void EnsureBufferCapacity(int neededCapacity)
+    {
+        // check if we have enough capacity available on the buffer.
+        if (_capacity < neededCapacity)
+        {
+            // if we need to expand the buffer we first capture the original buffer.
+            byte[] buffer = _buffer;
+
+            // next we determine the new size of the buffer, we at least double the size to avoid
+            // expanding the buffer too often.
+            int newSize = buffer.Length * 2;
+
+            // if that new buffer size is not enough to satisfy the needed capacity
+            // we add the needed capacity to the doubled buffer capacity.
+            if (neededCapacity > newSize - _start)
+            {
+                newSize += neededCapacity;
+            }
+
+            // next we will rent a new array from the array pool that supports
+            // the new capacity requirements.
+            _buffer = ArrayPool<byte>.Shared.Rent(newSize);
+
+            // the rented array might have a larger size than the needed capacity,
+            // so we will take the buffer length and calculate from that the free capacity.
+            _capacity += _buffer.Length - buffer.Length;
+
+            // finally we copy the data from the original buffer to the new buffer.
+            buffer.AsSpan().CopyTo(_buffer);
+
+            // last but not least we return the original buffer to the array pool.
+            ArrayPool<byte>.Shared.Return(buffer);
+        }
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        if (!_disposed)
+        {
+            ArrayPool<byte>.Shared.Return(_buffer);
+            _buffer = Array.Empty<byte>();
+            _capacity = 0;
+            _start = 0;
+            _disposed = true;
+        }
+    }
+}

src/Core/Resolvers/CosmosQueryEngine.cs

@@ -189,14 +189,14 @@ public Task<IActionResult> ExecuteAsync(StoredProcedureRequestContext context, s
         }
 
         /// <inheritdoc />
-        public JsonDocument ResolveInnerObject(JsonElement element, IObjectField fieldSchema, ref IMetadata metadata)
+        public JsonElement ResolveObject(JsonElement element, IObjectField fieldSchema, ref IMetadata metadata)
         {
-            //TODO: Try to avoid additional deserialization/serialization here.
-            return JsonDocument.Parse(element.ToString());
+            return element;
         }
 
         /// <inheritdoc />
-        public object ResolveListType(JsonElement element, IObjectField fieldSchema, ref IMetadata metadata)
+        /// metadata is not used in this method, but it is required by the interface.
+        public object ResolveList(JsonElement array, IObjectField fieldSchema, ref IMetadata metadata)
         {
             IType listType = fieldSchema.Type;
             // Is the List type nullable? [...]! vs [...]
@@ -217,10 +217,10 @@ public object ResolveListType(JsonElement element, IObjectField fieldSchema, ref
 
             if (listType.IsObjectType())
             {
-                return JsonSerializer.Deserialize<List<JsonElement>>(element);
+                return JsonSerializer.Deserialize<List<JsonElement>>(array);
             }
 
-            return JsonSerializer.Deserialize(element, fieldSchema.RuntimeType);
+            return JsonSerializer.Deserialize(array, fieldSchema.RuntimeType);
         }
 
         /// <summary>

src/Core/Resolvers/IQueryEngine.cs

@@ -44,11 +44,11 @@ public interface IQueryEngine
         /// <summary>
         /// Resolves a jsonElement representing an inner object based on the field's schema and metadata
         /// </summary>
-        public JsonDocument? ResolveInnerObject(JsonElement element, IObjectField fieldSchema, ref IMetadata metadata);
+        public JsonElement ResolveObject(JsonElement element, IObjectField fieldSchema, ref IMetadata metadata);
 
         /// <summary>
         /// Resolves a jsonElement representing a list type based on the field's schema and metadata
         /// </summary>
-        public object? ResolveListType(JsonElement element, IObjectField fieldSchema, ref IMetadata metadata);
+        public object ResolveList(JsonElement array, IObjectField fieldSchema, ref IMetadata? metadata);
     }
 }

src/Core/Resolvers/JsonObjectExtensions.cs

@@ -0,0 +1,91 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Buffers;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+/// <summary>
+/// This extension class provides helpers to convert a mutable JSON object
+/// to a JSON element or JSON document.
+/// </summary>
+internal static class JsonObjectExtensions
+{
+    /// <summary>
+    /// Converts a mutable JSON object to an immutable JSON element.
+    /// </summary>
+    /// <param name="obj">
+    /// The mutable JSON object to convert.
+    /// </param>
+    /// <returns>
+    /// An immutable JSON element.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// Thrown if <paramref name="obj"/> is <see langword="null"/>.
+    /// </exception>
+    public static JsonElement ToJsonElement(this JsonObject obj)
+    {
+        if (obj == null)
+        {
+            throw new ArgumentNullException(nameof(obj));
+        }
+
+        // we first write the mutable JsonObject to the pooled buffer and avoid serializing
+        // to a full JSON string.
+        using ArrayPoolWriter buffer = new();
+        obj.WriteTo(buffer);
+
+        // next we take the reader here and parse the JSON element from the buffer.
+        Utf8JsonReader reader = new(buffer.GetWrittenSpan());
+
+        // the underlying JsonDocument will not use pooled arrays to store metadata on it ...
+        // this JSON element can be safely returned.
+        return JsonElement.ParseValue(ref reader);
+    }
+
+    /// <summary>
+    /// Converts a mutable JSON object to an immutable JSON document.
+    /// </summary>
+    /// <param name="obj">
+    /// The mutable JSON object to convert.
+    /// </param>
+    /// <returns>
+    /// An immutable JSON document.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// Thrown if <paramref name="obj"/> is <see langword="null"/>.
+    /// </exception>
+    public static JsonDocument ToJsonDocument(this JsonObject obj)
+    {
+        if (obj == null)
+        {
+            throw new ArgumentNullException(nameof(obj));
+        }
+
+        // we first write the mutable JsonObject to the pooled buffer and avoid serializing
+        // to a full JSON string.
+        using ArrayPoolWriter buffer = new();
+        obj.WriteTo(buffer);
+
+        // next we parse the JSON document from the buffer.
+        // this JSON document will be disposed by the GraphQL execution engine.
+        return JsonDocument.Parse(buffer.GetWrittenMemory());
+    }
+
+    private static void WriteTo(this JsonObject obj, IBufferWriter<byte> bufferWriter)
+    {
+        if (obj == null)
+        {
+            throw new ArgumentNullException(nameof(obj));
+        }
+
+        if (bufferWriter == null)
+        {
+            throw new ArgumentNullException(nameof(bufferWriter));
+        }
+
+        using Utf8JsonWriter writer = new(bufferWriter);
+        obj.WriteTo(writer);
+        writer.Flush();
+    }
+}