NH-2285: Support for LockMode in linq provider

Author: OnurGumus

src/NHibernate.Test/Linq/QueryLock.cs

@@ -0,0 +1,47 @@
+using System.Linq;
+using NHibernate.AdoNet;
+using NHibernate.Cfg;
+using NHibernate.Engine;
+using NHibernate.Linq;
+using NUnit.Framework;
+
+namespace NHibernate.Test.Linq
+{
+	public class QueryLock : LinqTestCase
+	{
+
+		[Test]
+		public void CanSetLockLinqQueries()
+		{
+			var result = (from e in db.Customers
+						  where e.CompanyName == "Corp"
+						  select e).SetLockMode(LockMode.Upgrade).ToList();
+
+		}
+
+
+		[Test]
+		public void CanSetLockOnLinqPagingQuery()
+		{
+			var result = (from e in db.Customers
+						  where e.CompanyName == "Corp"
+						  select e).Skip(5).Take(5).SetLockMode(LockMode.Upgrade).ToList();
+		}
+
+
+		[Test]
+		public void CanLockBeforeSkipOnLinqOrderedPageQuery()
+		{
+			var result = (from e in db.Customers
+						  orderby e.CompanyName
+						  select e)
+				.SetLockMode(LockMode.Upgrade).Skip(5).Take(5).ToList();
+
+
+		}
+
+
+	}
+
+}
+

src/NHibernate/Linq/LinqExtensionMethods.cs

@@ -2514,6 +2514,15 @@ public static IQueryable<T> CacheRegion<T>(this IQueryable<T> query, string regi
 		public static IQueryable<T> Timeout<T>(this IQueryable<T> query, int timeout)
 			=> query.WithOptions(o => o.SetTimeout(timeout));
 
+		public static IQueryable<T> SetLockMode<T>(this IQueryable<T> query, LockMode lockMode)
+		{
+			var method = ReflectHelper.GetMethod(() => SetLockMode(query, lockMode));
+
+			var callExpression = Expression.Call(method, query.Expression, Expression.Constant(lockMode));
+
+			return new NhQueryable<T>(query.Provider, callExpression);
+		}
+
 		/// <summary>
 		/// Allows to specify the parameter NHibernate type to use for a literal in a queryable expression.
 		/// </summary>

src/NHibernate/Linq/LockExpressionNode.cs

@@ -0,0 +1,29 @@
+using System.Linq.Expressions;
+using Remotion.Linq.Clauses;
+using Remotion.Linq.Parsing.Structure.IntermediateModel;
+
+namespace NHibernate.Linq
+{
+	internal class LockExpressionNode : ResultOperatorExpressionNodeBase
+	{
+		private readonly MethodCallExpressionParseInfo _parseInfo;
+		private readonly ConstantExpression _lockMode;
+
+		public LockExpressionNode(MethodCallExpressionParseInfo parseInfo, ConstantExpression lockMode)
+			: base(parseInfo, null, null)
+		{
+			_parseInfo = parseInfo;
+			_lockMode = lockMode;
+		}
+
+		public override Expression Resolve(ParameterExpression inputParameter, Expression expressionToBeResolved, ClauseGenerationContext clauseGenerationContext)
+		{
+			return Source.Resolve(inputParameter, expressionToBeResolved, clauseGenerationContext);
+		}
+
+		protected override ResultOperatorBase CreateResultOperator(ClauseGenerationContext clauseGenerationContext)
+		{
+			return new LockResultOperator(_parseInfo, _lockMode);
+		}
+	}
+}

src/NHibernate/Linq/LockResultOperator.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Linq.Expressions;
+using Remotion.Linq.Clauses;
+using Remotion.Linq.Clauses.StreamedData;
+using Remotion.Linq.Parsing.Structure.IntermediateModel;
+
+namespace NHibernate.Linq
+{
+	internal class LockResultOperator : ResultOperatorBase
+	{
+		public MethodCallExpressionParseInfo ParseInfo { get; }
+		public ConstantExpression LockMode { get; }
+
+		public LockResultOperator(MethodCallExpressionParseInfo parseInfo, ConstantExpression lockMode)
+		{
+			ParseInfo = parseInfo;
+			LockMode = lockMode;
+		}
+
+		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)
+		{
+		}
+	}
+}

src/NHibernate/Linq/NhRelinqQueryParser.cs

@@ -1,17 +1,14 @@
 using System.Collections;
-using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 using NHibernate.Linq.ExpressionTransformers;
 using NHibernate.Linq.Visitors;
 using NHibernate.Util;
 using Remotion.Linq;
 using Remotion.Linq.EagerFetching.Parsing;
-using Remotion.Linq.Parsing.ExpressionVisitors;
 using Remotion.Linq.Parsing.ExpressionVisitors.Transformation;
 using Remotion.Linq.Parsing.Structure;
 using Remotion.Linq.Parsing.Structure.ExpressionTreeProcessors;
-using Remotion.Linq.Parsing.Structure.IntermediateModel;
 using Remotion.Linq.Parsing.Structure.NodeTypeProviders;
 
 namespace NHibernate.Linq
@@ -83,6 +80,9 @@ public NHibernateNodeTypeProvider()
 			methodInfoRegistry.Register(
 				new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetchMany<object, object, object>(null, null)) },
 				typeof(ThenFetchManyExpressionNode));
+			methodInfoRegistry.Register(
+				new[] { ReflectHelper.GetMethodDefinition(() => LinqExtensionMethods.SetLockMode<object>(null, LockMode.Read)) }, 
+				typeof(LockExpressionNode));
 
 			var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
 			nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);

src/NHibernate/Linq/ReWriters/ResultOperatorRewriter.cs

@@ -68,6 +68,7 @@ private class ResultOperatorExpressionRewriter : RelinqExpressionVisitor
 					typeof(OfTypeResultOperator),
 					typeof(CastResultOperator),
 					typeof(AsQueryableResultOperator),
+					typeof(LockResultOperator),
 				};
 
 			private readonly List<ResultOperatorBase> resultOperators = new List<ResultOperatorBase>();

src/NHibernate/Linq/Visitors/QueryModelVisitor.cs

@@ -141,6 +141,7 @@ static QueryModelVisitor()
 			ResultOperatorMap.Add<OfTypeResultOperator, ProcessOfType>();
 			ResultOperatorMap.Add<CastResultOperator, ProcessCast>();
 			ResultOperatorMap.Add<AsQueryableResultOperator, ProcessAsQueryable>();
+			ResultOperatorMap.Add<LockResultOperator, ProcessLock>();
 		}
 
 		private QueryModelVisitor(VisitorParameters visitorParameters, bool root, QueryModel queryModel,

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

@@ -0,0 +1,10 @@
+namespace NHibernate.Linq.Visitors.ResultOperatorProcessors
+{
+	internal class ProcessLock : IResultOperatorProcessor<LockResultOperator>
+	{
+		public void Process(LockResultOperator resultOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree)
+		{
+			tree.AddAdditionalCriteria((q, p) => q.SetLockMode(queryModelVisitor.Model.MainFromClause.ItemName, (LockMode)resultOperator.LockMode.Value));
+		}
+	}
+}

src/NHibernate/Linq/Visitors/SubQueryFromClauseFlattener.cs

@@ -12,6 +12,7 @@ public class SubQueryFromClauseFlattener : NhQueryModelVisitorBase
 	{
 		private static readonly System.Type[] FlattenableResultOperators =
 		{
+			typeof (LockResultOperator),
 			typeof (FetchOneRequest),
 			typeof (FetchManyRequest)
 		};