NH-3470 - Allow Session.Query to load entities as read-only

src/NHibernate.Test/Linq/QueryReadOnlyTests.cs

@@ -0,0 +1,59 @@
+using System.Linq;
+using NHibernate.Cfg;
+using NHibernate.Linq;
+using NUnit.Framework;
+
+namespace NHibernate.Test.Linq
+{
+	public class QueryReadOnlyTests : LinqTestCase
+	{
+		[Test]
+		public void CanSetReadOnlyOnLinqQueries()
+		{
+			var result = (from e in db.Customers
+						  where e.CompanyName == "Bon app'"
+						  select e).AsReadOnly().ToList();
+
+			Assert.That(result.All(x => this.session.IsReadOnly(x)), Is.True);
+		}
+
+
+		[Test]
+		public void CanSetReadOnlyOnLinqPagingQuery()
+		{
+			var result = (from e in db.Customers
+						  select e).Skip(1).Take(1).AsReadOnly().ToList();
+
+			Assert.That(result.All(x => this.session.IsReadOnly(x)), Is.True);
+		}
+
+
+		[Test]
+		public void CanSetReadOnlyBeforeSkipOnLinqOrderedPageQuery()
+		{
+			var result = (from e in db.Customers
+						  orderby e.CompanyName
+						  select e)
+				.AsReadOnly().Skip(5).Take(5).ToList();
+
+			Assert.That(result.All(x => this.session.IsReadOnly(x)), Is.True);
+		}
+
+		[Test]
+		public void CanSetReadOnlyOnLinqGroupPageQuery()
+		{
+			var subQuery = db.Customers.Where(e2 => e2.CompanyName.Contains("a")).Select(e2 => e2.CustomerId)
+							 .AsReadOnly(); // This AsReadOnly() should not cause trouble, and be ignored.
+
+			var result = (from e in db.Customers
+						  where subQuery.Contains(e.CustomerId)
+						  group e by e.CompanyName
+							  into g
+							  select new { g.Key, Count = g.Count() })
+				.Skip(5).Take(5)
+				.AsReadOnly().ToList();
+
+			Assert.That(result.All(x => this.session.IsReadOnly(x)), Is.True);
+		}
+	}
+}

src/NHibernate.Test/NHibernate.Test.csproj

@@ -547,6 +547,7 @@
     <Compile Include="Linq\DateTimeTests.cs" />
     <Compile Include="Linq\ExpressionSessionLeakTest.cs" />
     <Compile Include="Linq\LoggingTests.cs" />
+    <Compile Include="Linq\QueryReadOnlyTests.cs" />
     <Compile Include="Linq\QueryTimeoutTests.cs" />
     <Compile Include="Linq\JoinTests.cs" />
     <Compile Include="Linq\CustomExtensionsExample.cs" />

src/NHibernate/Linq/GroupBy/AggregatingGroupByRewriter.cs

@@ -40,6 +40,7 @@ public static class AggregatingGroupByRewriter
 				typeof (AnyResultOperator),
 				typeof (AllResultOperator),
 				typeof (TimeoutResultOperator),
+				typeof (AsReadOnlyResultOperator),
 				typeof (CacheableResultOperator)
 			};
 

src/NHibernate/Linq/LinqExtensionMethods.cs

@@ -58,6 +58,15 @@ public static IQueryable<T> CacheRegion<T>(this IQueryable<T> query, string regi
 			return new NhQueryable<T>(query.Provider, callExpression);
 		}
 
+		public static IQueryable<T> AsReadOnly<T>(this IQueryable<T> query)
+		{
+			var method = ReflectionHelper.GetMethodDefinition(() => AsReadOnly<object>(null)).MakeGenericMethod(typeof(T));
+
+			var callExpression = Expression.Call(method, query.Expression);
+
+			return new NhQueryable<T>(query.Provider, callExpression);
+		}
+
 		public static IQueryable<T> Timeout<T>(this IQueryable<T> query, int timeout)
 		{
 			var method = ReflectionHelper.GetMethodDefinition(() => Timeout<object>(null, 0)).MakeGenericMethod(typeof(T));
@@ -73,9 +82,9 @@ public static IEnumerable<T> ToFuture<T>(this IQueryable<T> query)
 			if (nhQueryable == null)
 				throw new NotSupportedException("Query needs to be of type QueryableBase<T>");
 
-			var provider = (INhQueryProvider) nhQueryable.Provider;
+			var provider = (INhQueryProvider)nhQueryable.Provider;
 			var future = provider.ExecuteFuture(nhQueryable.Expression);
-			return (IEnumerable<T>) future;
+			return (IEnumerable<T>)future;
 		}
 
 		public static IFutureValue<T> ToFutureValue<T>(this IQueryable<T> query)
@@ -84,14 +93,14 @@ public static IFutureValue<T> ToFutureValue<T>(this IQueryable<T> query)
 			if (nhQueryable == null)
 				throw new NotSupportedException("Query needs to be of type QueryableBase<T>");
 
-			var provider = (INhQueryProvider) nhQueryable.Provider;
+			var provider = (INhQueryProvider)nhQueryable.Provider;
 			var future = provider.ExecuteFuture(nhQueryable.Expression);
 			if (future is IEnumerable<T>)
 			{
-				return new FutureValue<T>(() => ((IEnumerable<T>) future));
+				return new FutureValue<T>(() => ((IEnumerable<T>)future));
 			}
 
-			return (IFutureValue<T>) future;
+			return (IFutureValue<T>)future;
 		}
 
 		public static T MappedAs<T>(this T parameter, IType type)
@@ -105,13 +114,13 @@ public static IFutureValue<TResult> ToFutureValue<T, TResult>(this IQueryable<T>
 			if (nhQueryable == null)
 				throw new NotSupportedException("Query needs to be of type QueryableBase<T>");
 
-			var provider = (INhQueryProvider) query.Provider;
+			var provider = (INhQueryProvider)query.Provider;
 
 			var expression = ReplacingExpressionTreeVisitor.Replace(selector.Parameters.Single(),
 																	query.Expression,
 																	selector.Body);
 
-			return (IFutureValue<TResult>) provider.ExecuteFuture(expression);
+			return (IFutureValue<TResult>)provider.ExecuteFuture(expression);
 		}
 	}
 }

src/NHibernate/Linq/NhRelinqQueryParser.cs

@@ -75,7 +75,14 @@ public NHibernateNodeTypeProvider()
 				new[]
 					{
 						ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.Timeout<object>(null, 0)),
-					}, typeof (TimeoutExpressionNode)
+					}, typeof(TimeoutExpressionNode)
+				);
+
+			methodInfoRegistry.Register(
+				new[]
+					{
+						ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.AsReadOnly<object>(null)),
+					}, typeof(AsReadOnlyExpressionNode)
 				);
 
 			var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
@@ -100,7 +107,8 @@ public System.Type GetNodeType(MethodInfo method)
 
 	public class AsQueryableExpressionNode : MethodCallExpressionNodeBase
 	{
-		public AsQueryableExpressionNode(MethodCallExpressionParseInfo parseInfo) : base(parseInfo)
+		public AsQueryableExpressionNode(MethodCallExpressionParseInfo parseInfo)
+			: base(parseInfo)
 		{
 		}
 
@@ -120,7 +128,8 @@ public class CacheableExpressionNode : ResultOperatorExpressionNodeBase
 		private readonly MethodCallExpressionParseInfo _parseInfo;
 		private readonly ConstantExpression _data;
 
-		public CacheableExpressionNode(MethodCallExpressionParseInfo parseInfo, ConstantExpression data) : base(parseInfo, null, null)
+		public CacheableExpressionNode(MethodCallExpressionParseInfo parseInfo, ConstantExpression data)
+			: base(parseInfo, null, null)
 		{
 			_parseInfo = parseInfo;
 			_data = data;
@@ -168,6 +177,55 @@ public override void TransformExpressions(Func<Expression, Expression> transform
 		}
 	}
 
+	internal class AsReadOnlyExpressionNode : ResultOperatorExpressionNodeBase
+	{
+		private readonly MethodCallExpressionParseInfo _parseInfo;
+
+		public AsReadOnlyExpressionNode(MethodCallExpressionParseInfo parseInfo)
+			: base(parseInfo, null, null)
+		{
+			_parseInfo = parseInfo;
+		}
+
+		public override Expression Resolve(ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext)
+		{
+			return Source.Resolve(inputParameter, expressionToBeResolved, clauseGenerationContext);
+		}
+
+		protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext)
+		{
+			return new AsReadOnlyResultOperator(_parseInfo);
+		}
+	}
+
+	internal class AsReadOnlyResultOperator : ResultOperatorBase
+	{
+		public MethodCallExpressionParseInfo ParseInfo { get; private set; }
+
+		public AsReadOnlyResultOperator(MethodCallExpressionParseInfo parseInfo)
+		{
+			ParseInfo = parseInfo;
+		}
+
+		public override IStreamedData ExecuteInMemory(IStreamedData input)
+		{
+			throw new NotImplementedException();
+		}
+
+		public override IStreamedDataInfo GetOutputDataInfo(IStreamedDataInfo inputInfo)
+		{
+			return inputInfo;
+		}
+
+		public override ResultOperatorBase Clone(CloneContext cloneContext)
+		{
+			throw new NotImplementedException();
+		}
+
+		public override void TransformExpressions(Func<Expression, Expression> transformation)
+		{
+		}
+	}
 
 	internal class TimeoutExpressionNode : ResultOperatorExpressionNodeBase
 	{

src/NHibernate/Linq/ReWriters/QueryReferenceExpressionFlattener.cs

@@ -17,6 +17,7 @@ public class QueryReferenceExpressionFlattener : ExpressionTreeVisitor
 		{
 			typeof (CacheableResultOperator),
 			typeof (TimeoutResultOperator),
+			typeof (AsReadOnlyResultOperator),
 			typeof (FetchOneRequest),
 			typeof (FetchManyRequest)
 		};

src/NHibernate/Linq/ReWriters/ResultOperatorRewriter.cs

@@ -67,6 +67,7 @@ private class ResultOperatorExpressionRewriter : ExpressionTreeVisitor
 					typeof(OfTypeResultOperator),
 					typeof(CacheableResultOperator),
 					typeof(TimeoutResultOperator),
+					typeof(AsReadOnlyResultOperator),
 					typeof(CastResultOperator), // see ProcessCast class
 				};
 

src/NHibernate/Linq/Visitors/QueryModelVisitor.cs

@@ -124,6 +124,7 @@ static QueryModelVisitor()
 			ResultOperatorMap.Add<FetchManyRequest, ProcessFetchMany>();
 			ResultOperatorMap.Add<CacheableResultOperator, ProcessCacheable>();
 			ResultOperatorMap.Add<TimeoutResultOperator, ProcessTimeout>();
+			ResultOperatorMap.Add<AsReadOnlyResultOperator, ProcessAsReadOnly>();
 			ResultOperatorMap.Add<OfTypeResultOperator, ProcessOfType>();
 			ResultOperatorMap.Add<CastResultOperator, ProcessCast>();
 		}

src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessAsReadOnly.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace NHibernate.Linq.Visitors.ResultOperatorProcessors
+{
+	internal class ProcessAsReadOnly : IResultOperatorProcessor<AsReadOnlyResultOperator>
+	{
+		public void Process(AsReadOnlyResultOperator resultOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree)
+		{
+			tree.AddAdditionalCriteria((q, p) => q.SetReadOnly(true));
+		}
+	}
+}

src/NHibernate/NHibernate.csproj

@@ -334,6 +334,7 @@
     <Compile Include="Linq\Visitors\PossibleValueSet.cs" />
     <Compile Include="Linq\Visitors\QueryExpressionSourceIdentifer.cs" />
     <Compile Include="Linq\Visitors\QuerySourceIdentifier.cs" />
+    <Compile Include="Linq\Visitors\ResultOperatorProcessors\ProcessAsReadOnly.cs" />
     <Compile Include="Linq\Visitors\MemberExpressionJoinDetector.cs" />
     <Compile Include="Linq\Visitors\ResultOperatorProcessors\ProcessTimeout.cs" />
     <Compile Include="Linq\Visitors\ResultOperatorProcessors\ProcessAggregateFromSeed.cs" />