NH-3658

src/NHibernate.Test/Linq/QueryAsReadOnlyTests.cs

@@ -0,0 +1,35 @@
+using System.Linq;
+using NHibernate.AdoNet;
+using NHibernate.Cfg;
+using NHibernate.Engine;
+using NHibernate.Linq;
+using NUnit.Framework;
+
+namespace NHibernate.Test.Linq
+{
+	public class QueryAsReadOnlyTests : LinqTestCase
+	{
+		[Test]
+		public void CanSetReadOnlyOnSimpeLinqQueries()
+		{
+			//NH-3658
+			var result = (from e in db.Customers
+						  where e.CompanyName == "Corp"
+						  select e).AsReadOnly().ToList();
+
+			Assert.IsTrue(result.All(x => session.IsReadOnly(x)));
+		}
+
+		[Test]
+		public void CanSetReadOnlyOnComplexLinqQueries()
+		{
+			//NH-3658
+			var result = (from e in db.Customers
+						  where e.CompanyName == "Corp"
+						  orderby e.ContactName
+						  select e).Skip(1).Take(10).AsReadOnly().ToList();
+
+			Assert.IsTrue(result.All(x => session.IsReadOnly(x)));
+		}
+	}
+}

src/NHibernate.Test/NHibernate.Test.csproj

@@ -519,6 +519,7 @@
     <Compile Include="Linq\DateTimeTests.cs" />
     <Compile Include="Linq\ExpressionSessionLeakTest.cs" />
     <Compile Include="Linq\LoggingTests.cs" />
+    <Compile Include="Linq\QueryAsReadOnlyTests.cs" />
     <Compile Include="Linq\QueryTimeoutTests.cs" />
     <Compile Include="Linq\JoinTests.cs" />
     <Compile Include="Linq\CustomExtensionsExample.cs" />
@@ -529,7 +530,7 @@
     <Compile Include="Linq\ExtensionMethods.cs" />
     <Compile Include="Linq\FunctionTests.cs" />
     <Compile Include="Linq\LinqQuerySamples.cs" />
-    <Compile Include="Linq\LinqReadonlyTestsContext.cs" />
+    <Compile Include="Linq\LinqReadOnlyTestsContext.cs" />
     <Compile Include="Linq\LinqTestCase.cs" />
     <Compile Include="Linq\LinqToHqlGeneratorsRegistryFactoryTest.cs" />
     <Compile Include="Linq\MethodCallTests.cs" />
@@ -3630,4 +3631,4 @@ if exist hibernate.cfg.xml (del hibernate.cfg.xml)
 if exist "$(ProjectDir)hibernate.cfg.xml" (copy "$(ProjectDir)hibernate.cfg.xml" "hibernate.cfg.xml")
 copy /y "..\..\..\NHibernate.DomainModel\ABC.hbm.xml" "ABC.hbm.xml"</PostBuildEvent>
   </PropertyGroup>
-</Project>
+</Project>

src/NHibernate.TestDatabaseSetup/NHibernate.TestDatabaseSetup.csproj

@@ -58,6 +58,9 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Microsoft.Data.Services">
+      <HintPath>..\..\lib\net\Microsoft.Data.Services.dll</HintPath>
+    </Reference>
     <Reference Include="FirebirdSql.Data.FirebirdClient">
       <HintPath>..\..\lib\teamcity\firebird\FirebirdSql.Data.FirebirdClient.dll</HintPath>
     </Reference>

src/NHibernate.TestDatabaseSetup/TestDatabaseSetup.build

@@ -22,6 +22,7 @@
 			<include name="FirebirdSql.Data.FirebirdClient.dll" />
 			<include name="System.Data.SqlServerCe.dll" />
 			<include name="Npgsql.dll" />
+			<include name="Microsoft.Data.Services.dll" />
 		</assemblyfileset>
 	</target>
 	<target name="generate-assemblyinfo" depends="init common.generate-assemblyinfo" />

src/NHibernate/Linq/GroupBy/AggregatingGroupByRewriter.cs

@@ -38,6 +38,7 @@ public static class AggregatingGroupByRewriter
 				typeof (AnyResultOperator),
 				typeof (AllResultOperator),
 				typeof (TimeoutResultOperator),
+				typeof (AsReadOnlyResultOperator),
 			};
 
 		public static void ReWrite(QueryModel queryModel)

src/NHibernate/Linq/LinqExtensionMethods.cs

@@ -20,6 +20,15 @@ public static IQueryable<T> Query<T>(this IStatelessSession session)
 			return new NhQueryable<T>(session.GetSessionImplementation());
 		}
 
+		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> Cacheable<T>(this IQueryable<T> query)
 		{
 			var method = ReflectionHelper.GetMethodDefinition(() => Cacheable<object>(null)).MakeGenericMethod(typeof (T));

src/NHibernate/Linq/NhRelinqQueryParser.cs

@@ -78,6 +78,13 @@ public NHibernateNodeTypeProvider()
 					}, typeof (TimeoutExpressionNode)
 				);
 
+			methodInfoRegistry.Register(
+				new[]
+					{
+						ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.AsReadOnly<object>(null)),
+					}, typeof(AsReadOnlyExpressionNode)
+				);
+
 			var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
 			nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
 			defaultNodeTypeProvider = nodeTypeProvider;
@@ -168,6 +175,26 @@ 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 TimeoutExpressionNode : ResultOperatorExpressionNodeBase
 	{
@@ -192,6 +219,35 @@ protected override ResultOperatorBase CreateResultOperator(ClauseGenerationConte
 		}
 	}
 
+	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 TimeoutResultOperator : ResultOperatorBase
 	{
 		public MethodCallExpressionParseInfo ParseInfo { get; private set; }

src/NHibernate/Linq/ReWriters/QueryReferenceExpressionFlattener.cs

@@ -16,6 +16,7 @@ public class QueryReferenceExpressionFlattener : ExpressionTreeVisitor
 																				{
 																					typeof(CacheableResultOperator),
 																					typeof (TimeoutResultOperator),
+																					typeof (AsReadOnlyResultOperator),
 																				};
 
 		private QueryReferenceExpressionFlattener(QueryModel model)

src/NHibernate/Linq/Visitors/QueryModelVisitor.cs

@@ -105,6 +105,7 @@ static QueryModelVisitor()
 			ResultOperatorMap.Add<FetchOneRequest, ProcessFetchOne>();
 			ResultOperatorMap.Add<FetchManyRequest, ProcessFetchMany>();
 			ResultOperatorMap.Add<CacheableResultOperator, ProcessCacheable>();
+			ResultOperatorMap.Add<AsReadOnlyResultOperator, ProcessAsReadOnly>();
 			ResultOperatorMap.Add<TimeoutResultOperator, ProcessTimeout>();
 			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));
+		}
+	}
+}