AbstractSessionImpl.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by AsyncGenerator.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------


using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Linq;
using NHibernate.AdoNet;
using NHibernate.Cache;
using NHibernate.Collection;
using NHibernate.Connection;
using NHibernate.Engine;
using NHibernate.Engine.Query;
using NHibernate.Engine.Query.Sql;
using NHibernate.Event;
using NHibernate.Exceptions;
using NHibernate.Hql;
using NHibernate.Linq;
using NHibernate.Loader.Custom;
using NHibernate.Loader.Custom.Sql;
using NHibernate.Multi;
using NHibernate.MultiTenancy;
using NHibernate.Persister.Entity;
using NHibernate.Transaction;
using NHibernate.Type;
using NHibernate.Util;

namespace NHibernate.Impl
{
	using System.Threading.Tasks;
	using System.Threading;
	public abstract partial class AbstractSessionImpl : ISessionImplementor
	{

		#region ISessionImplementor Members

		public abstract Task InitializeCollectionAsync(IPersistentCollection collection, bool writing, CancellationToken cancellationToken);
		public abstract Task<object> InternalLoadAsync(string entityName, object id, bool eager, bool isNullable, CancellationToken cancellationToken);
		public abstract Task<object> ImmediateLoadAsync(string entityName, object id, CancellationToken cancellationToken);

		public virtual async Task<IList> ListAsync(IQueryExpression queryExpression, QueryParameters parameters, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			var results = (IList)typeof(List<>)
				.MakeGenericType(queryExpression.Type)
				.GetConstructor(System.Type.EmptyTypes)
				.Invoke(null);
			await (ListAsync(queryExpression, parameters, results, cancellationToken)).ConfigureAwait(false);
			return results;
		}

		public abstract Task ListAsync(IQueryExpression queryExpression, QueryParameters queryParameters, IList results, CancellationToken cancellationToken);

		public virtual async Task<IList<T>> ListAsync<T>(IQueryExpression query, QueryParameters parameters, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			using (BeginProcess())
			{
				var results = new List<T>();
				await (ListAsync(query, parameters, results, cancellationToken)).ConfigureAwait(false);
				return results;
			}
		}

		//TODO 6.0: Make abstract
		public virtual async Task<IList<T>> ListAsync<T>(CriteriaImpl criteria, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			using (BeginProcess())
			{
				var results = new List<T>();
				await (ListAsync(criteria, results, cancellationToken)).ConfigureAwait(false);
				return results;
			}
		}

		//TODO 6.0: Make virtual
		public abstract Task ListAsync(CriteriaImpl criteria, IList results, CancellationToken cancellationToken);
		//{
		//	ArrayHelper.AddAll(results, List(criteria));
		//}

		public virtual async Task<IList> ListAsync(CriteriaImpl criteria, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			return (await (ListAsync<object>(criteria, cancellationToken)).ConfigureAwait(false)).ToIList();
		}

		public abstract Task<IList> ListFilterAsync(object collection, string filter, QueryParameters parameters, CancellationToken cancellationToken);
		public async Task<IList> ListFilterAsync(object collection, IQueryExpression queryExpression, QueryParameters parameters, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			var results = (IList)typeof(List<>).MakeGenericType(queryExpression.Type)
									.GetConstructor(System.Type.EmptyTypes)
									.Invoke(null);

			await (ListFilterAsync(collection, queryExpression, parameters, results, cancellationToken)).ConfigureAwait(false);
			return results;
		}
		protected abstract Task ListFilterAsync(object collection, IQueryExpression queryExpression, QueryParameters parameters, IList results, CancellationToken cancellationToken);

		public abstract Task<IList<T>> ListFilterAsync<T>(object collection, string filter, QueryParameters parameters, CancellationToken cancellationToken);
		public abstract Task<IEnumerable> EnumerableFilterAsync(object collection, string filter, QueryParameters parameters, CancellationToken cancellationToken);
		public abstract Task<IEnumerable<T>> EnumerableFilterAsync<T>(object collection, string filter, QueryParameters parameters, CancellationToken cancellationToken);
		public abstract Task BeforeTransactionCompletionAsync(ITransaction tx, CancellationToken cancellationToken);
		public abstract Task FlushBeforeTransactionCompletionAsync(CancellationToken cancellationToken);
		public abstract Task AfterTransactionCompletionAsync(bool successful, ITransaction tx, CancellationToken cancellationToken);

		public virtual async Task<IList> ListAsync(NativeSQLQuerySpecification spec, QueryParameters queryParameters, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			using (BeginProcess())
			{
				var results = new List<object>();
				await (ListAsync(spec, queryParameters, results, cancellationToken)).ConfigureAwait(false);
				return results;
			}
		}

		public virtual async Task ListAsync(NativeSQLQuerySpecification spec, QueryParameters queryParameters, IList results, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			using (BeginProcess())
			{
				var query = new SQLCustomQuery(
					spec.SqlQueryReturns,
					spec.QueryString,
					spec.QuerySpaces,
					Factory);
				await (ListCustomQueryAsync(query, queryParameters, results, cancellationToken)).ConfigureAwait(false);
			}
		}

		public virtual async Task<IList<T>> ListAsync<T>(NativeSQLQuerySpecification spec, QueryParameters queryParameters, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			using (BeginProcess())
			{
				var results = new List<T>();
				await (ListAsync(spec, queryParameters, results, cancellationToken)).ConfigureAwait(false);
				return results;
			}
		}

		public abstract Task ListCustomQueryAsync(ICustomQuery customQuery, QueryParameters queryParameters, IList results, CancellationToken cancellationToken);

		public virtual async Task<IList<T>> ListCustomQueryAsync<T>(ICustomQuery customQuery, QueryParameters queryParameters, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			using (BeginProcess())
			{
				var results = new List<T>();
				await (ListCustomQueryAsync(customQuery, queryParameters, results, cancellationToken)).ConfigureAwait(false);
				return results;
			}
		}

		// Since v5.2
		[Obsolete("This method has no usages and will be removed in a future version")]
		public abstract Task<IQueryTranslator[]> GetQueriesAsync(IQueryExpression query, bool scalar, CancellationToken cancellationToken);
		public abstract Task<object> GetEntityUsingInterceptorAsync(EntityKey key, CancellationToken cancellationToken);
		public abstract Task<int> ExecuteNativeUpdateAsync(NativeSQLQuerySpecification specification, QueryParameters queryParameters, CancellationToken cancellationToken);

		//6.0 TODO: Make abstract
		/// <summary>
		/// detect in-memory changes, determine if the changes are to tables
		/// named in the query and, if so, complete execution the flush
		/// </summary>
		/// <param name="querySpaces"></param>
		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
		/// <returns>Returns true if flush was executed</returns>
		public virtual Task<bool> AutoFlushIfRequiredAsync(ISet<string> querySpaces, CancellationToken cancellationToken)
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled<bool>(cancellationToken);
			}
			try
			{
				return Task.FromResult<bool>(AutoFlushIfRequired(querySpaces));
			}
			catch (Exception ex)
			{
				return Task.FromException<bool>(ex);
			}
		}

		public abstract Task FlushAsync(CancellationToken cancellationToken);

		#endregion

		protected async Task AfterOperationAsync(bool success, CancellationToken cancellationToken)
		{
			cancellationToken.ThrowIfCancellationRequested();
			using (BeginContext())
			{
				if (!ConnectionManager.IsInActiveTransaction)
				{
					ConnectionManager.AfterNonTransactionalQuery(success);
					ConnectionManager.AfterTransaction();
					await (AfterTransactionCompletionAsync(success, null, cancellationToken)).ConfigureAwait(false);
				}
			}
		}

		public abstract Task<IQuery> CreateFilterAsync(object collection, IQueryExpression queryExpression, CancellationToken cancellationToken);

		public abstract Task<IEnumerable> EnumerableAsync(IQueryExpression queryExpression, QueryParameters queryParameters, CancellationToken cancellationToken);

		public abstract Task<IEnumerable<T>> EnumerableAsync<T>(IQueryExpression queryExpression, QueryParameters queryParameters, CancellationToken cancellationToken);

		public abstract Task<int> ExecuteUpdateAsync(IQueryExpression queryExpression, QueryParameters queryParameters, CancellationToken cancellationToken);
	}
}