chore: add WriteMutationsAsync to .NET wrapper (#567)

Add an async version of the WriteMutations method to the .NET wrapper.

Author: olavloite

spannerlib/wrappers/spannerlib-dotnet/spannerlib-dotnet-grpc-impl/GrpcLibSpanner.cs

@@ -172,7 +172,25 @@ public async Task CloseConnectionAsync(Connection connection, CancellationToken
         }));
         return response.CommitTimestamp == null ? null : response;
     }
-
+    
+    public async Task<CommitResponse?> WriteMutationsAsync(Connection connection,
+        BatchWriteRequest.Types.MutationGroup mutations, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var response = await _client.WriteMutationsAsync(new WriteMutationsRequest
+            {
+                Connection = ToProto(connection),
+                Mutations = mutations,
+            }, cancellationToken: cancellationToken);
+            return response.CommitTimestamp == null ? null : response;
+        }
+        catch (RpcException exception)
+        {
+            throw SpannerException.ToSpannerException(exception);
+        }
+    }
+    
     public Rows Execute(Connection connection, ExecuteSqlRequest statement)
     {
         if (_useStreamingRows) 

spannerlib/wrappers/spannerlib-dotnet/spannerlib-dotnet-native-impl/SharedLibSpanner.cs

@@ -104,6 +104,12 @@ public void CloseConnection(Connection connection)
         }
         return CommitResponse.Parser.ParseFrom(handler.Value());
     }
+    
+    public Task<CommitResponse?> WriteMutationsAsync(Connection connection,
+        BatchWriteRequest.Types.MutationGroup mutations, CancellationToken cancellationToken = default)
+    {
+        return Task.Run(() => WriteMutations(connection, mutations), cancellationToken);
+    }
 
     public Rows Execute(Connection connection, ExecuteSqlRequest statement)
     {

spannerlib/wrappers/spannerlib-dotnet/spannerlib-dotnet-tests/ConnectionTests.cs

@@ -88,6 +88,50 @@ public void TestWriteMutations([Values] LibType libType)
         Assert.That(commit.Mutations[1].InsertOrUpdate.Values.Count, Is.EqualTo(1));
     }
 
+    [Test]
+    public async Task TestWriteMutationsAsync([Values] LibType libType)
+    {
+        await using var pool = Pool.Create(SpannerLibDictionary[libType], ConnectionString);
+        await using var connection = pool.CreateConnection();
+        var insertMutation = new Mutation
+        {
+            Insert = new Mutation.Types.Write
+            {
+                Table = "my_table",
+                Columns = { new[] { "id", "value" } },
+            }
+        };
+        insertMutation.Insert.Values.AddRange([
+            new ListValue{Values = { Value.ForString("1"), Value.ForString("One") }},
+            new ListValue{Values = { Value.ForString("2"), Value.ForString("Two") }}
+        ]);
+        var insertOrUpdateMutation = new Mutation
+        {
+            InsertOrUpdate = new Mutation.Types.Write
+            {
+                Table = "my_table",
+                Columns = { new[] { "id", "value" } },
+            }
+        };
+        insertOrUpdateMutation.InsertOrUpdate.Values.AddRange([
+            new ListValue{Values = { Value.ForString("0"), Value.ForString("Zero") }}
+        ]);
+        
+        var response = await connection.WriteMutationsAsync(new BatchWriteRequest.Types.MutationGroup
+        {
+            Mutations = { new []{insertMutation, insertOrUpdateMutation}}
+        });
+        Assert.That(response, Is.Not.Null);
+        Assert.That(response.CommitTimestamp, Is.Not.Null);
+        Assert.That(Fixture.SpannerMock.Requests.OfType<BeginTransactionRequest>().Count(), Is.EqualTo(1));
+        Assert.That(Fixture.SpannerMock.Requests.OfType<CommitRequest>().Count(), Is.EqualTo(1));
+        var commit = Fixture.SpannerMock.Requests.OfType<CommitRequest>().Single();
+        Assert.That(commit, Is.Not.Null);
+        Assert.That(commit.Mutations.Count, Is.EqualTo(2));
+        Assert.That(commit.Mutations[0].Insert.Values.Count, Is.EqualTo(2));
+        Assert.That(commit.Mutations[1].InsertOrUpdate.Values.Count, Is.EqualTo(1));
+    }
+
     [Test]
     public void TestWriteMutationsInTransaction([Values] LibType libType)
     {

spannerlib/wrappers/spannerlib-dotnet/spannerlib-dotnet/Connection.cs

@@ -88,7 +88,25 @@ public Task RollbackAsync(CancellationToken cancellationToken = default)
     {
         return Spanner.WriteMutations(this, mutations);
     }
-
+    
+    /// <summary>
+    /// Writes the given list of mutations to Spanner. If the connection has an active read/write transaction, then the
+    /// mutations will be buffered in the current transaction and sent to Spanner when the transaction is committed.
+    /// If the connection does not have a transaction, then the mutations are sent to Spanner directly in a new
+    /// read/write transaction.
+    /// </summary>
+    /// <param name="mutations">The mutations to write to Spanner</param>
+    /// <param name="cancellationToken">The cancellation token</param>
+    /// <returns>
+    /// The CommitResponse that is returned by Spanner, or null if the mutations were only buffered in the current
+    /// transaction.
+    /// </returns>
+    public Task<CommitResponse?> WriteMutationsAsync(BatchWriteRequest.Types.MutationGroup mutations,
+        CancellationToken cancellationToken = default)
+    {
+        return Spanner.WriteMutationsAsync(this, mutations, cancellationToken);
+    }
+    
     /// <summary>
     /// Executes any type of SQL statement on this connection. The SQL statement will use the current transaction of the
     /// connection. The contents of the returned Rows object depends on the type of SQL statement.

spannerlib/wrappers/spannerlib-dotnet/spannerlib-dotnet/ISpannerLib.cs

@@ -91,6 +91,21 @@ public enum RowEncoding
     /// </returns>
     public CommitResponse? WriteMutations(Connection connection, BatchWriteRequest.Types.MutationGroup mutations);
 
+    /// <summary>
+    /// Writes an array of mutations to Spanner. The mutations are buffered in the current transaction of the given
+    /// connection (if any). Otherwise, the mutations are written directly to Spanner using a new read/write
+    /// transaction and the CommitResponse of that transaction is returned. The returned value is null if the mutations
+    /// were only buffered in an active transaction.
+    /// </summary>
+    /// <param name="connection">The connection to use to write the mutations</param>
+    /// <param name="mutations">The mutations to write</param>
+    /// <param name="cancellationToken">The cancellation token</param>
+    /// <returns>
+    /// The CommitResponse of the read/write transaction that was created to write the mutations, or null if the
+    /// mutations were buffered in an active transaction on the connection.
+    /// </returns>
+    public Task<CommitResponse?> WriteMutationsAsync(Connection connection, BatchWriteRequest.Types.MutationGroup mutations, CancellationToken cancellationToken = default);
+    
     /// <summary>
     /// Executes a SQL statement of any type on the given connection.
     /// </summary>