Merge pull request #62 from DataObjects-NET/async-enumerable-1

DataObjects.Net async API

Author: alex-kulakov

Extensions/Xtensive.Orm.BulkOperations.Tests/Other.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2012-2020 Xtensive LLC.
+// Copyright (C) 2012-2020 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Alexander Ovchinnikov
@@ -7,9 +7,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using NUnit.Framework;
 using TestCommon.Model;
-using Xtensive.Orm.Rse;
 
 namespace Xtensive.Orm.BulkOperations.Tests
 {
@@ -37,6 +37,29 @@ public void CompositeKeyUpdate()
       }
     }
 
+    [Test]
+    public async Task CompositeKeyUpdateAsync()
+    {
+      await using (Session session = await Domain.OpenSessionAsync()) {
+        await using (TransactionScope trx = session.OpenTransaction()) {
+          DateTime date1 = DateTime.Now;
+          DateTime date2 = DateTime.Now.AddDays(1);
+          Guid id1 = Guid.NewGuid();
+          Guid id2 = Guid.NewGuid();
+          var foo1 = new Bar2(session, date1, id1) {Name = "test"};
+          var foo2 = new Bar2(session, date2, id1);
+          var foo3 = new Bar2(session, date2, id2) {Name = "test"};
+          int updated =
+            await session.Query.All<Bar2>().Where(a => a.Name=="test").Set(a => a.Name, "abccba").UpdateAsync();
+          Assert.That(updated, Is.EqualTo(2));
+          Assert.That(foo1.Name, Is.EqualTo("abccba"));
+          Assert.That(foo3.Name, Is.EqualTo("abccba"));
+          Assert.That(foo2.Name, Is.Null);
+          trx.Complete();
+        }
+      }
+    }
+
     [Test]
     public void SimpleDelete()
     {
@@ -64,6 +87,36 @@ public void SimpleDelete()
       }
     }
 
+    [Test]
+    public async Task SimpleDeleteAsync()
+    {
+      await using (Session session = await Domain.OpenSessionAsync()) {
+        await using (TransactionScope trx = session.OpenTransaction()) {
+          var bar1 = new Bar(session) {Name = "test", Count = 3};
+          var bar2 = new Bar(session);
+          var bar3 = new Bar(session);
+          bar3.Foo.Add(new Foo(session) {Name = "Foo"});
+          string s = "test";
+
+          int deleted = await session.Query.All<Bar>().Where(a => a.Name==s).DeleteAsync();
+          Assert.That(bar1.IsRemoved, Is.True);
+          Assert.That(bar2.IsRemoved, Is.False);
+          Assert.That(bar3.IsRemoved, Is.False);
+          Assert.That(deleted, Is.EqualTo(1));
+
+          await session.Query.All<Bar>()
+            .Where(a => a.Foo.Any(b => b.Name=="Foo"))
+            .UpdateAsync(a => new Bar(null) {Name = ""});
+
+          deleted = await session.Query.All<Bar>().Where(a => a.Foo.Count(b => b.Name=="Foo")==0).DeleteAsync();
+          Assert.That(bar2.IsRemoved, Is.True);
+          Assert.That(bar3.IsRemoved, Is.False);
+          Assert.That(deleted, Is.EqualTo(1));
+          trx.Complete();
+        }
+      }
+    }
+
     [Test]
     public void SimpleInsert()
     {
@@ -93,6 +146,34 @@ public void SimpleInsert()
       }
     }
 
+    [Test]
+    public async Task SimpleInsertAsync()
+    {
+      await using (Session session = await Domain.OpenSessionAsync()) {
+        await using (TransactionScope trx = session.OpenTransaction()) {
+          string s1 = "abccba";
+          int i = 5;
+          Key key = await session.Query.InsertAsync(
+            () => new Bar(session) {Name = "test1" + s1, Count = i * 2 + 1, Description = null});
+          Assert.That(key, Is.EqualTo(Key.Create<Bar>(session.Domain, 1)));
+          var bar = session.Query.Single<Bar>(key);
+          Assert.That(bar.Name, Is.EqualTo("test1abccba"));
+          Assert.That(bar.Count, Is.EqualTo(11));
+          Assert.That(bar.Description, Is.Null);
+
+          key = await session.Query.InsertAsync(
+            () => new Bar(session) {Id = 100, Name = "test" + s1, Count = i * 2 + 1, Description = null});
+          Assert.That(key, Is.EqualTo(Key.Create<Bar>(session.Domain, 100)));
+          bar = session.Query.Single<Bar>(key);
+          Assert.That(bar.Name, Is.EqualTo("testabccba"));
+          Assert.That(bar.Count, Is.EqualTo(11));
+          Assert.That(bar.Description, Is.Null);
+
+          trx.Complete();
+        }
+      }
+    }
+
     [Test]
     public void SimpleUpdate()
     {
@@ -114,6 +195,27 @@ public void SimpleUpdate()
       }
     }
 
+    [Test]
+    public async Task SimpleUpdateAsync()
+    {
+      await using (Session session = await Domain.OpenSessionAsync()) {
+        await using (TransactionScope trx = session.OpenTransaction()) {
+          var bar1 = new Bar(session) {Name = "test", Count = 3};
+          var bar2 = new Bar(session);
+          string s = "test";
+          string s1 = "abccba";
+          int updated = await session.Query.All<Bar>()
+            .Where(a => a.Name.Contains(s))
+            .UpdateAsync(a => new Bar(session) {Name = a.Name + s1, Count = a.Count * 2, Description = null});
+          Assert.That(bar1.Name, Is.EqualTo("testabccba"));
+          Assert.That(bar1.Description, Is.Null);
+          Assert.That(bar1.Count, Is.EqualTo(6));
+          Assert.That(updated, Is.EqualTo(1));
+          trx.Complete();
+        }
+      }
+    }
+
     [Test]
     public void SubqueryInsert()
     {

Extensions/Xtensive.Orm.BulkOperations/BulkExtensions.cs

@@ -1,10 +1,13 @@
-using System;
-using System.Collections.Generic;
+// Copyright (C) 2019-2020 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
+
+using System;
 using System.Diagnostics.Contracts;
 using System.Linq;
 using System.Linq.Expressions;
-using System.Reflection;
-using Xtensive.Orm;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Xtensive.Orm.BulkOperations
 {
@@ -19,10 +22,22 @@ public static class BulkExtensions
     /// <typeparam name="T">Type of the entity.</typeparam>
     /// <param name="query">The query.</param>
     /// <returns>Number of the deleted entities.</returns>
-    public static int Delete<T>(this IQueryable<T> query) where T : class, IEntity
-    {
-      return new BulkDeleteOperation<T>(query).Execute();
-    }
+    public static int Delete<T>(this IQueryable<T> query) where T : class, IEntity =>
+      new BulkDeleteOperation<T>(query).Execute();
+
+    /// <summary>
+    /// Asynchronously executes bulk delete of entities specified by the query.
+    /// </summary>
+    /// <remarks>Multiple active operations in the same session instance are not supported. Use
+    /// <see langword="await"/> to ensure that all asynchronous operations have completed before calling
+    /// another method in this session.</remarks>
+    /// <typeparam name="T">Type of the entity.</typeparam>
+    /// <param name="query">The query.</param>
+    /// <param name="token">The cancellation token to terminate execution if needed.</param>
+    /// <returns>Number of the deleted entities.</returns>
+    public static Task<int> DeleteAsync<T>(this IQueryable<T> query, CancellationToken token = default)
+      where T : class, IEntity =>
+      new BulkDeleteOperation<T>(query).ExecuteAsync(token);
 
     /// <summary>
     /// Executes bulk update of entities specified by the query.
@@ -35,10 +50,8 @@ public static int Delete<T>(this IQueryable<T> query) where T : class, IEntity
     /// <returns>Instance of <see cref=" IUpdatable&lt;T&gt;"/>.</returns>
     [Pure]
     public static IUpdatable<T> Set<T, TResult>(this IQueryable<T> query, Expression<Func<T, TResult>> field,
-      Expression<Func<T, TResult>> update) where T: IEntity
-    {
-      return new Updatable<T>(query, field, update);
-    }
+      Expression<Func<T, TResult>> update) where T: IEntity =>
+      new Updatable<T>(query, field, update);
 
     /// <summary>
     /// Executes bulk update of entities specified by the query.
@@ -51,10 +64,8 @@ public static IUpdatable<T> Set<T, TResult>(this IQueryable<T> query, Expression
     /// <returns>Instance of <see cref=" IUpdatable&lt;T&gt;"/>.</returns>
     [Pure]
     public static IUpdatable<T> Set<T, TResult>(this IUpdatable<T> query, Expression<Func<T, TResult>> field,
-      Expression<Func<T, TResult>> update) where T: IEntity
-    {
-      return new Updatable<T>((Updatable<T>) query, field, update);
-    }
+      Expression<Func<T, TResult>> update) where T: IEntity =>
+      new Updatable<T>((Updatable<T>) query, field, update);
 
     /// <summary>
     /// Executes bulk update of entities specified by the query.
@@ -67,10 +78,8 @@ public static IUpdatable<T> Set<T, TResult>(this IUpdatable<T> query, Expression
     /// <returns>Instance of <see cref=" IUpdatable&lt;T&gt;"/>.</returns>
     [Pure]
     public static IUpdatable<T> Set<T, TResult>(this IQueryable<T> query, Expression<Func<T, TResult>> field,
-      TResult value) where T: IEntity
-    {
-      return Set(query, field, a => value);
-    }
+      TResult value) where T: IEntity =>
+      Set(query, field, a => value);
 
     /// <summary>
     /// Executes bulk update of entities specified by the query.
@@ -83,10 +92,8 @@ public static IUpdatable<T> Set<T, TResult>(this IQueryable<T> query, Expression
     /// <returns>Instance of <see cref=" IUpdatable&lt;T&gt;"/>.</returns>
     [Pure]
     public static IUpdatable<T> Set<T, TResult>(this IUpdatable<T> query, Expression<Func<T, TResult>> field,
-      TResult value) where T: IEntity
-    {
-      return Set(query, field, a => value);
-    }
+      TResult value) where T: IEntity =>
+      Set(query, field, a => value);
 
     /// <summary>
     /// Executes the UPDATE operation.
@@ -95,21 +102,46 @@ public static IUpdatable<T> Set<T, TResult>(this IUpdatable<T> query, Expression
     /// <param name="query">The query.</param>
     /// <param name="evaluator">The expression, that specify new values. Constructor parameters are ignored.</param>
     /// <returns>Number of updated entities.</returns>
-    public static int Update<T>(this IQueryable<T> query, Expression<Func<T, T>> evaluator) where T : class, IEntity
-    {
-      return new BulkUpdateOperation<T>(query, evaluator).Execute();
-    }
+    public static int Update<T>(this IQueryable<T> query, Expression<Func<T, T>> evaluator) where T : class, IEntity =>
+      new BulkUpdateOperation<T>(query, evaluator).Execute();
+
+    /// <summary>
+    /// Asynchronously executes the UPDATE operation.
+    /// </summary>
+    /// <remarks>Multiple active operations in the same session instance are not supported. Use
+    /// <see langword="await"/> to ensure that all asynchronous operations have completed before calling
+    /// another method in this session.</remarks>
+    /// <typeparam name="T">Type of the entity.</typeparam>
+    /// <param name="query">The query.</param>
+    /// <param name="evaluator">The expression, that specify new values. Constructor parameters are ignored.</param>
+    /// <param name="token">The cancellation token to terminate execution if necessary.</param>
+    /// <returns>Number of updated entities.</returns>
+    public static Task<int> UpdateAsync<T>(this IQueryable<T> query, Expression<Func<T, T>> evaluator,
+      CancellationToken token = default) where T : class, IEntity =>
+      new BulkUpdateOperation<T>(query, evaluator).ExecuteAsync(token);
 
     /// <summary>
     /// Executes the UPDATE operation.
     /// </summary>
     /// <typeparam name="T">Type of the entity.</typeparam>
     /// <param name="query">The query.</param>
     /// <returns>Number of updated entities.</returns>
-    public static int Update<T>(this IUpdatable<T> query) where T : class, IEntity
-    {
-      return new BulkUpdateOperation<T>(query).Execute();
-    }
+    public static int Update<T>(this IUpdatable<T> query) where T : class, IEntity =>
+      new BulkUpdateOperation<T>(query).Execute();
+
+    /// <summary>
+    /// Asynchronously executes the UPDATE operation.
+    /// </summary>
+    /// <remarks>Multiple active operations in the same session instance are not supported. Use
+    /// <see langword="await"/> to ensure that all asynchronous operations have completed before calling
+    /// another method in this session.</remarks>
+    /// <typeparam name="T">Type of the entity.</typeparam>
+    /// <param name="query">The query.</param>
+    /// <param name="token">The cancellation token to terminate execution if necessary.</param>
+    /// <returns>Number of updated entities.</returns>
+    public static Task<int> UpdateAsync<T>(this IUpdatable<T> query, CancellationToken token = default)
+      where T : class, IEntity =>
+      new BulkUpdateOperation<T>(query).ExecuteAsync(token);
 
     /// <summary>
     /// Executes INSERT operation.
@@ -125,9 +157,23 @@ public static Key Insert<T>(this QueryEndpoint queryEndpoint, Expression<Func<T>
       return operation.Key;
     }
 
-    #region Non-public methods
-
-
-    #endregion
+    /// <summary>
+    /// Asynchronously executes INSERT operation.
+    /// </summary>
+    /// <remarks>Multiple active operations in the same session instance are not supported. Use
+    /// <see langword="await"/> to ensure that all asynchronous operations have completed before calling
+    /// another method in this session.</remarks>
+    /// <typeparam name="T">Type of the entity.</typeparam>
+    /// <param name="queryEndpoint">The query endpoint.</param>
+    /// <param name="evaluator">The expression, tha specify new values.</param>
+    /// <param name="token">The cancellation token to terminate execution if necessary.</param>
+    /// <returns>Key of the created entity.</returns>
+    public static async Task<Key> InsertAsync<T>(this QueryEndpoint queryEndpoint, Expression<Func<T>> evaluator,
+      CancellationToken token = default) where T : Entity
+    {
+      var operation = new InsertOperation<T>(queryEndpoint.Provider, evaluator);
+      await operation.ExecuteAsync(token).ConfigureAwait(false);
+      return operation.Key;
+    }
   }
 }