Obsolete old future related classes

bahusoid · bahusoid · commit 5a7e1317ef6e · 2018-06-06T10:48:46.000+03:00
diff --git a/src/NHibernate/Async/Impl/FutureCriteriaBatch.cs b/src/NHibernate/Async/Impl/FutureCriteriaBatch.cs
@@ -8,6 +8,7 @@
 //------------------------------------------------------------------------------
 
 
+using System;
 using System.Collections;
 
 namespace NHibernate.Impl
diff --git a/src/NHibernate/Async/Impl/FutureQueryBatch.cs b/src/NHibernate/Async/Impl/FutureQueryBatch.cs
@@ -8,6 +8,7 @@
 //------------------------------------------------------------------------------
 
 
+using System;
 using System.Collections;
 using NHibernate.Transform;
 
diff --git a/src/NHibernate/Engine/ISessionImplementor.cs b/src/NHibernate/Engine/ISessionImplementor.cs
@@ -333,8 +333,12 @@ public partial interface ISessionImplementor
 		/// <summary> Execute a HQL update or delete query</summary>
 		int ExecuteUpdate(IQueryExpression query, QueryParameters queryParameters);
 
+		//Since 5.2
+		[Obsolete("Replaced by FutureBatch")]
 		FutureCriteriaBatch FutureCriteriaBatch { get; }
 
+		//Since 5.2
+		[Obsolete("Replaced by FutureBatch")]
 		FutureQueryBatch FutureQueryBatch { get; }
 
 		Guid SessionId { get; }
diff --git a/src/NHibernate/Impl/AbstractQueryImpl.cs b/src/NHibernate/Impl/AbstractQueryImpl.cs
@@ -903,22 +903,12 @@ public IQuery SetResultTransformer(IResultTransformer transformer)
 
 		public IFutureEnumerable<T> Future<T>()
 		{
-			if (FutureSettings.IsUnifiedFuture)
-			{
-				return session.GetFutureMultiBatch().AddAsEnumerable<T>(this);
-			}
-			session.FutureQueryBatch.Add<T>(this);
-			return session.FutureQueryBatch.GetEnumerator<T>();
+			return session.GetFutureMultiBatch().AddAsEnumerable<T>(this);
 		}
 
 		public IFutureValue<T> FutureValue<T>()
 		{
-			if (FutureSettings.IsUnifiedFuture)
-			{
-				return session.GetFutureMultiBatch().AddAsValue<T>(this);
-			}
-			session.FutureQueryBatch.Add<T>(this);
-			return session.FutureQueryBatch.GetFutureValue<T>();
+			return session.GetFutureMultiBatch().AddAsValue<T>(this);
 		}
 
 		/// <summary> Override the current session cache mode, just for this query.
diff --git a/src/NHibernate/Impl/AbstractSessionImpl.cs b/src/NHibernate/Impl/AbstractSessionImpl.cs
@@ -280,7 +280,12 @@ public virtual IQuery GetNamedSQLQuery(string name)
 		public abstract string BestGuessEntityName(object entity);
 		public abstract string GuessEntityName(object entity);
 		public abstract int ExecuteNativeUpdate(NativeSQLQuerySpecification specification, QueryParameters queryParameters);
+
+		//Since 5.2
+		[Obsolete("Replaced by FutureBatch")]
 		public abstract FutureCriteriaBatch FutureCriteriaBatch { get; protected internal set; }
+		//Since 5.2
+		[Obsolete("Replaced by FutureBatch")]
 		public abstract FutureQueryBatch FutureQueryBatch { get; protected internal set; }
 	
 		public virtual IMultiAnyQueryBatch FutureMultiBatch
diff --git a/src/NHibernate/Impl/CriteriaImpl.cs b/src/NHibernate/Impl/CriteriaImpl.cs
@@ -457,22 +457,12 @@ public ICriteria CreateCriteria(string associationPath, string alias, JoinType j
 
 		public IFutureValue<T> FutureValue<T>()
 		{
-			if (FutureSettings.IsUnifiedFuture)
-			{
-				return session.GetFutureMultiBatch().AddAsValue<T>(this);
-			}
-			session.FutureCriteriaBatch.Add<T>(this);
-			return session.FutureCriteriaBatch.GetFutureValue<T>();
+			return session.GetFutureMultiBatch().AddAsValue<T>(this);
 		}
 
 		public IFutureEnumerable<T> Future<T>()
 		{
-			if (FutureSettings.IsUnifiedFuture)
-			{
-				return session.GetFutureMultiBatch().AddAsEnumerable<T>(this);
-			}
-			session.FutureCriteriaBatch.Add<T>(this);
-			return session.FutureCriteriaBatch.GetEnumerator<T>();
+			return session.GetFutureMultiBatch().AddAsEnumerable<T>(this);
 		}
 
 		public object UniqueResult()
diff --git a/src/NHibernate/Impl/DelayedEnumerator.cs b/src/NHibernate/Impl/DelayedEnumerator.cs
@@ -7,6 +7,8 @@
 
 namespace NHibernate.Impl
 {
+	//Since 5.2
+	[Obsolete]
 	internal class DelayedEnumerator<T> : IFutureEnumerable<T>, IDelayedValue
 	{
 		public delegate IEnumerable<T> GetResult();
@@ -73,6 +75,8 @@ public IList TransformList(IList collection)
 		}
 	}
 
+	//Since 5.2
+	[Obsolete]
 	internal interface IDelayedValue
 	{
 		Delegate ExecuteOnEval { get; set; }
diff --git a/src/NHibernate/Impl/FutureBatch.cs b/src/NHibernate/Impl/FutureBatch.cs
@@ -6,6 +6,8 @@
 
 namespace NHibernate.Impl
 {
+	//Since 5.2
+	[Obsolete("Replaced by MultiAnyQueryBatch")]
 	public abstract partial class FutureBatch<TQueryApproach, TMultiApproach>
 	{
 		private class BatchedQuery
diff --git a/src/NHibernate/Impl/FutureCriteriaBatch.cs b/src/NHibernate/Impl/FutureCriteriaBatch.cs
@@ -1,7 +1,10 @@
+using System;
 using System.Collections;
 
 namespace NHibernate.Impl
 {
+	//Since 5.2
+	[Obsolete("Replaced by MultiAnyQueryBatch")]
 	public partial class FutureCriteriaBatch : FutureBatch<ICriteria, IMultiCriteria>
 	{
 		public FutureCriteriaBatch(SessionImpl session) : base(session) {}
diff --git a/src/NHibernate/Impl/FutureQueryBatch.cs b/src/NHibernate/Impl/FutureQueryBatch.cs
@@ -1,8 +1,11 @@
-﻿using System.Collections;
+﻿using System;
+using System.Collections;
 using NHibernate.Transform;
 
 namespace NHibernate.Impl
 {
+	//Since 5.2
+	[Obsolete("Replaced by MultiAnyQueryBatch")]
 	public partial class FutureQueryBatch : FutureBatch<IQuery, IMultiQuery>
 	{
 		public FutureQueryBatch(SessionImpl session) : base(session)
diff --git a/src/NHibernate/Impl/FutureValue.cs b/src/NHibernate/Impl/FutureValue.cs
@@ -7,6 +7,8 @@
 
 namespace NHibernate.Impl
 {
+	//Since 5.2
+	[Obsolete]
 	internal class FutureValue<T> : IFutureValue<T>, IDelayedValue
 	{
 		public delegate IEnumerable<T> GetResult();
diff --git a/src/NHibernate/Impl/SessionImpl.cs b/src/NHibernate/Impl/SessionImpl.cs
@@ -49,8 +49,12 @@ public sealed partial class SessionImpl : AbstractSessionImpl, IEventSource, ISe
 
 		private CacheMode cacheMode = CacheMode.Normal;
 
+		//Since 5.2
+		[Obsolete()]
 		[NonSerialized]
 		private FutureCriteriaBatch futureCriteriaBatch;
+		//Since 5.2
+		[Obsolete()]
 		[NonSerialized]
 		private FutureQueryBatch futureQueryBatch;
 
@@ -209,6 +213,8 @@ internal SessionImpl(SessionFactoryImpl factory, ISessionCreationOptions options
 			}
 		}
 
+		//Since 5.2
+		[Obsolete("Replaced by MultiAnyQueryBatch")]
 		public override FutureCriteriaBatch FutureCriteriaBatch
 		{
 			get
@@ -223,6 +229,8 @@ protected internal set
 			}
 		}
 
+		//Since 5.2
+		[Obsolete("Replaced by MultiAnyQueryBatch")]
 		public override FutureQueryBatch FutureQueryBatch
 		{
 			get
diff --git a/src/NHibernate/Impl/StatelessSessionImpl.cs b/src/NHibernate/Impl/StatelessSessionImpl.cs
@@ -855,12 +855,16 @@ public override int ExecuteUpdate(IQueryExpression queryExpression, QueryParamet
 			}
 		}
 
+		//Since 5.2
+		[Obsolete("Replaced by MultiAnyQueryBatch")]
 		public override FutureCriteriaBatch FutureCriteriaBatch
 		{
 			get { throw new NotSupportedException("future queries are not supported for stateless session"); }
 			protected internal set { throw new NotSupportedException("future queries are not supported for stateless session"); }
 		}
 
+		//Since 5.2
+		[Obsolete("Replaced by MultiAnyQueryBatch")]
 		public override FutureQueryBatch FutureQueryBatch
 		{
 			get { throw new NotSupportedException("future queries are not supported for stateless session"); }
diff --git a/src/NHibernate/Linq/DefaultQueryProvider.cs b/src/NHibernate/Linq/DefaultQueryProvider.cs
@@ -15,8 +15,12 @@ namespace NHibernate.Linq
 {
 	public partial interface INhQueryProvider : IQueryProvider
 	{
-		//TODO: Obsolete? We don't really need ExecuteFuture, ExecuteFutureValue for unified batch
+		//Since 5.2
+		[Obsolete("Replaced by INhQueryProviderSupportMultiBatch interface")]
 		IFutureEnumerable<TResult> ExecuteFuture<TResult>(Expression expression);
+
+		//Since 5.2
+		[Obsolete("Replaced by INhQueryProviderSupportMultiBatch interface")]
 		IFutureValue<TResult> ExecuteFutureValue<TResult>(Expression expression);
 		void SetResultTransformerAndAdditionalCriteria(IQuery query, NhLinqExpression nhExpression, IDictionary<string, Tuple<object, IType>> parameters);
 		int ExecuteDml<T>(QueryMode queryMode, Expression expression);
@@ -118,6 +122,8 @@ public virtual IQueryable<T> CreateQuery<T>(Expression expression)
 			return new NhQueryable<T>(this, expression);
 		}
 
+		//Since 5.2
+		[Obsolete("Replaced by INhQueryProviderSupportMultiBatch interface")]
 		public virtual IFutureEnumerable<TResult> ExecuteFuture<TResult>(Expression expression)
 		{
 			var nhExpression = PrepareQuery(expression, out var query);
@@ -129,22 +135,17 @@ public virtual IFutureEnumerable<TResult> ExecuteFuture<TResult>(Expression expr
 			return result;
 		}
 
+		//Since 5.2
+		[Obsolete("Replaced by INhQueryProviderSupportMultiBatch interface")]
 		public virtual IFutureValue<TResult> ExecuteFutureValue<TResult>(Expression expression)
 		{
 			var nhExpression = PrepareQuery(expression, out var query);
-			if (FutureSettings.IsUnifiedFuture)
-			{
-				var linqBatchItem = new MultiAnyLinqQuery<TResult>(query, nhExpression);
-				return Session.GetFutureMultiBatch().AddAsValue(linqBatchItem);
-			}
-
-			var result = query.FutureValue<TResult>();
-			if (result is IDelayedValue delayedValue)
-				SetupFutureResult(nhExpression, delayedValue);
-
-			return result;
+			var linqBatchItem = new MultiAnyLinqQuery<TResult>(query, nhExpression);
+			return Session.GetFutureMultiBatch().AddAsValue(linqBatchItem);
 		}
 
+		//Since 5.2
+		[Obsolete]
 		private static void SetupFutureResult(NhLinqExpression nhExpression, IDelayedValue result)
 		{
 			if (nhExpression.ExpressionToHqlTranslationResults.PostExecuteTransformer == null)
diff --git a/src/NHibernate/Linq/LinqExtensionMethods.cs b/src/NHibernate/Linq/LinqExtensionMethods.cs
@@ -2404,8 +2404,14 @@ async Task<List<TSource>> InternalToListAsync()
 		/// <exception cref="T:System.NotSupportedException"><paramref name="source" /> <see cref="IQueryable.Provider"/> is not a <see cref="INhQueryProvider"/>.</exception>
 		public static IFutureEnumerable<TSource> ToFuture<TSource>(this IQueryable<TSource> source)
 		{
+			if (source.Provider is INhQueryProviderSupportMultiBatch batchProvider)
+			{
+				return batchProvider.GetFutureMultiBatch().AddAsEnumerable(source);
+			}
+#pragma warning disable CS0618 // Type or member is obsolete
 			var provider = GetNhProvider(source);
 			return provider.ExecuteFuture<TSource>(source.Expression);
+#pragma warning restore CS0618 // Type or member is obsolete
 		}
 
 		/// <summary>
@@ -2419,14 +2425,15 @@ public static IFutureEnumerable<TSource> ToFuture<TSource>(this IQueryable<TSour
 		/// <exception cref="T:System.NotSupportedException"><paramref name="source" /> <see cref="IQueryable.Provider"/> is not a <see cref="INhQueryProvider"/>.</exception>
 		public static IFutureValue<TSource> ToFutureValue<TSource>(this IQueryable<TSource> source)
 		{
-			if (FutureSettings.IsUnifiedFuture)
+			if (source.Provider is INhQueryProviderSupportMultiBatch batchProvider)
 			{
-				var mbProvider = GetMultiBatcNhProvider(source);
-				return mbProvider.GetFutureMultiBatch().AddAsValue(source);
+				return batchProvider.GetFutureMultiBatch().AddAsValue(source);
 			}
+#pragma warning disable CS0618, CS0612// Type or member is obsolete
 			var provider = GetNhProvider(source);
 			var future = provider.ExecuteFuture<TSource>(source.Expression);
 			return new FutureValue<TSource>(future.GetEnumerable, future.GetEnumerableAsync);
+#pragma warning restore CS0618, CS0612// Type or member is obsolete
 		}
 
 		/// <summary>
@@ -2442,16 +2449,16 @@ public static IFutureValue<TSource> ToFutureValue<TSource>(this IQueryable<TSour
 		/// <exception cref="T:System.NotSupportedException"><paramref name="source" /> <see cref="IQueryable.Provider"/> is not a <see cref="INhQueryProvider"/>.</exception>
 		public static IFutureValue<TResult> ToFutureValue<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<IQueryable<TSource>, TResult>> selector)
 		{
-			if (FutureSettings.IsUnifiedFuture)
+			if (source.Provider is INhQueryProviderSupportMultiBatch batchProvider)
 			{
-				var mbProvider = GetMultiBatcNhProvider(source);
-				return mbProvider.GetFutureMultiBatch().AddAsValue(source, selector);
+				return batchProvider.GetFutureMultiBatch().AddAsValue(source, selector);
 			}
+#pragma warning disable CS0618 // Type or member is obsolete
 			var expression = ReplacingExpressionVisitor
 				.Replace(selector.Parameters.Single(), source.Expression, selector.Body);
-
 			var provider = GetNhProvider(source);
 			return provider.ExecuteFutureValue<TResult>(expression);
+#pragma warning restore CS0618 // Type or member is obsolete
 		}
 
 
@@ -2529,19 +2536,6 @@ internal static INhQueryProvider GetNhProvider<TSource>(this IQueryable<TSource>
 				throw new NotSupportedException($"Source {nameof(source.Provider)} must be a {nameof(INhQueryProvider)}");
 			}
 			return provider;
-		}	
-		
-		internal static INhQueryProviderSupportMultiBatch GetMultiBatcNhProvider<TSource>(this IQueryable<TSource> source)
-		{
-			if (source == null)
-			{
-				throw new ArgumentNullException(nameof(source));
-			}
-			if (!(source.Provider is INhQueryProviderSupportMultiBatch provider))
-			{
-				throw new NotSupportedException($"Source {nameof(source.Provider)} must be a {nameof(INhQueryProviderSupportMultiBatch)}");
-			}
-			return provider;
 		}
 	}
 }
diff --git a/src/NHibernate/Multi/FutureExtensions.cs b/src/NHibernate/Multi/FutureExtensions.cs
@@ -25,6 +25,11 @@ public static IFutureEnumerable<TResult> AddAsEnumerable<TResult>(this IMultiAny
 			return new FutureEnumerable<TResult>(AddAsList<TResult>(batch, query));
 		}
 
+		public static IFutureEnumerable<TResult> AddAsEnumerable<TResult>(this IMultiAnyQueryBatch batch, IQueryable<TResult> query)
+		{
+			return new FutureEnumerable<TResult>(AddAsList(batch, query));
+		}
+
 		public static IFutureList<TResult> AddAsList<TResult>(this IMultiAnyQueryBatch batch, IQuery query)
 		{
 			return AddAsList(batch, For<TResult>(query));
diff --git a/src/NHibernate/Multi/FutureSettings.cs b/src/NHibernate/Multi/FutureSettings.cs

Original file line number	Diff line number	Diff line change
`@@ -903,22 +903,12 @@ public IQuery SetResultTransformer(IResultTransformer transformer)`
`903`	`903`
`904`	`904`	`public IFutureEnumerable<T> Future<T>()`
`905`	`905`	`{`
`906`		`- if (FutureSettings.IsUnifiedFuture)`
`907`		`- {`
`908`		`- return session.GetFutureMultiBatch().AddAsEnumerable<T>(this);`
`909`		`- }`
`910`		`- session.FutureQueryBatch.Add<T>(this);`
`911`		`- return session.FutureQueryBatch.GetEnumerator<T>();`
	`906`	`+ return session.GetFutureMultiBatch().AddAsEnumerable<T>(this);`
`912`	`907`	`}`
`913`	`908`
`914`	`909`	`public IFutureValue<T> FutureValue<T>()`
`915`	`910`	`{`
`916`		`- if (FutureSettings.IsUnifiedFuture)`
`917`		`- {`
`918`		`- return session.GetFutureMultiBatch().AddAsValue<T>(this);`
`919`		`- }`
`920`		`- session.FutureQueryBatch.Add<T>(this);`
`921`		`- return session.FutureQueryBatch.GetFutureValue<T>();`
	`911`	`+ return session.GetFutureMultiBatch().AddAsValue<T>(this);`
`922`	`912`	`}`
`923`	`913`
`924`	`914`	`/// <summary> Override the current session cache mode, just for this query.`
Original file line number	Diff line number	Diff line change
`@@ -457,22 +457,12 @@ public ICriteria CreateCriteria(string associationPath, string alias, JoinType j`
`457`	`457`
`458`	`458`	`public IFutureValue<T> FutureValue<T>()`
`459`	`459`	`{`
`460`		`- if (FutureSettings.IsUnifiedFuture)`
`461`		`- {`
`462`		`- return session.GetFutureMultiBatch().AddAsValue<T>(this);`
`463`		`- }`
`464`		`- session.FutureCriteriaBatch.Add<T>(this);`
`465`		`- return session.FutureCriteriaBatch.GetFutureValue<T>();`
	`460`	`+ return session.GetFutureMultiBatch().AddAsValue<T>(this);`
`466`	`461`	`}`
`467`	`462`
`468`	`463`	`public IFutureEnumerable<T> Future<T>()`
`469`	`464`	`{`
`470`		`- if (FutureSettings.IsUnifiedFuture)`
`471`		`- {`
`472`		`- return session.GetFutureMultiBatch().AddAsEnumerable<T>(this);`
`473`		`- }`
`474`		`- session.FutureCriteriaBatch.Add<T>(this);`
`475`		`- return session.FutureCriteriaBatch.GetEnumerator<T>();`
	`465`	`+ return session.GetFutureMultiBatch().AddAsEnumerable<T>(this);`
`476`	`466`	`}`
`477`	`467`
`478`	`468`	`public object UniqueResult()`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,8 @@`
`7`	`7`
`8`	`8`	`namespace NHibernate.Impl`
`9`	`9`	`{`
	`10`	`+ //Since 5.2`
	`11`	`+ [Obsolete]`
`10`	`12`	`internal class DelayedEnumerator<T> : IFutureEnumerable<T>, IDelayedValue`
`11`	`13`	`{`
`12`	`14`	`public delegate IEnumerable<T> GetResult();`
`@@ -73,6 +75,8 @@ public IList TransformList(IList collection)`
`73`	`75`	`}`
`74`	`76`	`}`
`75`	`77`
	`78`	`+ //Since 5.2`
	`79`	`+ [Obsolete]`
`76`	`80`	`internal interface IDelayedValue`
`77`	`81`	`{`
`78`	`82`	`Delegate ExecuteOnEval { get; set; }`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,8 @@`
`6`	`6`
`7`	`7`	`namespace NHibernate.Impl`
`8`	`8`	`{`
	`9`	`+ //Since 5.2`
	`10`	`+ [Obsolete("Replaced by MultiAnyQueryBatch")]`
`9`	`11`	`public abstract partial class FutureBatch<TQueryApproach, TMultiApproach>`
`10`	`12`	`{`
`11`	`13`	`private class BatchedQuery`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,10 @@`
	`1`	`+using System;`
`1`	`2`	`using System.Collections;`
`2`	`3`
`3`	`4`	`namespace NHibernate.Impl`
`4`	`5`	`{`
	`6`	`+ //Since 5.2`
	`7`	`+ [Obsolete("Replaced by MultiAnyQueryBatch")]`
`5`	`8`	`public partial class FutureCriteriaBatch : FutureBatch<ICriteria, IMultiCriteria>`
`6`	`9`	`{`
`7`	`10`	`public FutureCriteriaBatch(SessionImpl session) : base(session) {}`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,11 @@`
`1`		`-using System.Collections;`
	`1`	`+using System;`
	`2`	`+using System.Collections;`
`2`	`3`	`using NHibernate.Transform;`
`3`	`4`
`4`	`5`	`namespace NHibernate.Impl`
`5`	`6`	`{`
	`7`	`+ //Since 5.2`
	`8`	`+ [Obsolete("Replaced by MultiAnyQueryBatch")]`
`6`	`9`	`public partial class FutureQueryBatch : FutureBatch<IQuery, IMultiQuery>`
`7`	`10`	`{`
`8`	`11`	`public FutureQueryBatch(SessionImpl session) : base(session)`