Rename SetLockMode to WithLock

Author: hazzik

src/NHibernate.Test/Linq/QueryLock.cs

@@ -17,22 +17,47 @@ public void CanSetLockLinqQueries()
 			using (session.BeginTransaction())
 			{
 				var result = (from e in db.Customers
-				              select e).SetLockMode(LockMode.Upgrade).ToList();
+				              select e).WithLock(LockMode.Upgrade).ToList();
 
 				Assert.That(result, Has.Count.EqualTo(91));
 				Assert.That(session.GetCurrentLockMode(result[0]), Is.EqualTo(LockMode.Upgrade));
 				AssertSeparateTransactionIsLockedOut(result[0].CustomerId);
 			}
 		}
 
+		[Test]
+		public void CanSetLockOnSubquery()
+		{
+			using (session.BeginTransaction())
+			{
+				var result = (from c in db.Customers
+				              from o in c.Orders.DefaultIfEmpty()
+				              select o).ToList();
+
+				Assert.That(result, Has.Count.EqualTo(91));
+				Assert.That(session.GetCurrentLockMode(result[0]), Is.EqualTo(LockMode.Upgrade));
+			}
+		}
+
+		[Test]
+		public void CanSetLockOnSubqueryHql()
+		{
+			using (session.BeginTransaction())
+			{
+				session
+					.CreateQuery("select o from Customer c join c.Orders o")
+					.SetLockMode("o", LockMode.Upgrade)
+					.List();
+			}
+		}
 
 		[Test]
 		public void CanSetLockOnLinqPagingQuery()
 		{
 			using (session.BeginTransaction())
 			{
 				var result = (from e in db.Customers
-				              select e).Skip(5).Take(5).SetLockMode(LockMode.Upgrade).ToList();
+				              select e).Skip(5).Take(5).WithLock(LockMode.Upgrade).ToList();
 
 				Assert.That(result, Has.Count.EqualTo(5));
 				Assert.That(session.GetCurrentLockMode(result[0]), Is.EqualTo(LockMode.Upgrade));
@@ -48,7 +73,7 @@ public void CanLockBeforeSkipOnLinqOrderedPageQuery()
 				var result = (from e in db.Customers
 				              orderby e.CompanyName
 				              select e)
-				             .SetLockMode(LockMode.Upgrade).Skip(5).Take(5).ToList();
+				             .WithLock(LockMode.Upgrade).Skip(5).Take(5).ToList();
 
 				Assert.That(result, Has.Count.EqualTo(5));
 				Assert.That(session.GetCurrentLockMode(result[0]), Is.EqualTo(LockMode.Upgrade));
@@ -70,7 +95,7 @@ private void AssertSeparateTransactionIsLockedOut(string customerId)
 								from e in s2.Query<Customer>()
 								where e.CustomerId == customerId
 								select e
-							).SetLockMode(LockMode.UpgradeNoWait)
+							).WithLock(LockMode.UpgradeNoWait)
 							 .WithOptions(o => o.SetTimeout(5))
 							 .ToList();
 						Assert.That(result2, Is.Not.Null);
@@ -107,7 +132,7 @@ private static IQueryable<Customer> BuildQueryableAllCustomers(
 			IQueryable<Customer> dbCustomers,
 			LockMode lockMode)
 		{
-			return (from e in dbCustomers select e).SetLockMode(lockMode).WithOptions(o => o.SetTimeout(5));
+			return (from e in dbCustomers select e).WithLock(lockMode).WithOptions(o => o.SetTimeout(5));
 		}
 	}
 }

src/NHibernate/Linq/LinqExtensionMethods.cs

@@ -2514,15 +2514,21 @@ 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)
+		public static IQueryable<T> WithLock<T>(this IQueryable<T> query, LockMode lockMode)
 		{
-			var method = ReflectHelper.GetMethod(() => SetLockMode(query, lockMode));
+			var method = ReflectHelper.GetMethod(() => WithLock(query, lockMode));
 
 			var callExpression = Expression.Call(method, query.Expression, Expression.Constant(lockMode));
 
 			return new NhQueryable<T>(query.Provider, callExpression);
 		}
 
+		public static IEnumerable<T> WithLock<T>(this IEnumerable<T> query, LockMode lockMode)
+		{
+			throw new InvalidOperationException(
+				"The NHibernate.Linq.LinqExtensionMethods.WithLock(IEnumerable<T>, LockMode) method can only be used in a Linq expression.");
+		}
+
 		/// <summary>
 		/// Allows to specify the parameter NHibernate type to use for a literal in a queryable expression.
 		/// </summary>

src/NHibernate/Linq/LockExpressionNode.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Linq.Expressions;
 using Remotion.Linq.Clauses;
 using Remotion.Linq.Parsing.Structure.IntermediateModel;

src/NHibernate/Linq/NhRelinqQueryParser.cs

@@ -1,4 +1,6 @@
 using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 using NHibernate.Linq.ExpressionTransformers;
@@ -81,7 +83,11 @@ public NHibernateNodeTypeProvider()
 				new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetchMany<object, object, object>(null, null)) },
 				typeof(ThenFetchManyExpressionNode));
 			methodInfoRegistry.Register(
-				new[] { ReflectHelper.GetMethodDefinition(() => LinqExtensionMethods.SetLockMode<object>(null, LockMode.Read)) }, 
+				new[]
+				{
+					ReflectHelper.GetMethodDefinition(() => default(IQueryable<object>).WithLock(LockMode.Read)),
+					ReflectHelper.GetMethodDefinition(() => default(IEnumerable<object>).WithLock(LockMode.Read))
+				}, 
 				typeof(LockExpressionNode));
 
 			var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();

src/NHibernate/Linq/Visitors/SubQueryFromClauseFlattener.cs

@@ -12,8 +12,9 @@ public class SubQueryFromClauseFlattener : NhQueryModelVisitorBase
 	{
 		private static readonly System.Type[] FlattenableResultOperators =
 		{
-			typeof (FetchOneRequest),
-			typeof (FetchManyRequest)
+			typeof(FetchOneRequest),
+			typeof(FetchManyRequest),
+			typeof(LockResultOperator)
 		};
 
 		public static void ReWrite(QueryModel queryModel)
@@ -23,16 +24,14 @@ public static void ReWrite(QueryModel queryModel)
 
 		public override void VisitAdditionalFromClause(AdditionalFromClause fromClause, QueryModel queryModel, int index)
 		{
-			var subQueryExpression = fromClause.FromExpression as SubQueryExpression;
-			if (subQueryExpression != null)
+			if (fromClause.FromExpression is SubQueryExpression subQueryExpression)
 				FlattenSubQuery(subQueryExpression, fromClause, queryModel, index + 1);
 			base.VisitAdditionalFromClause(fromClause, queryModel, index);
 		}
 
 		public override void VisitMainFromClause(MainFromClause fromClause, QueryModel queryModel)
 		{
-			var subQueryExpression = fromClause.FromExpression as SubQueryExpression;
-			if (subQueryExpression != null)
+			if (fromClause.FromExpression is SubQueryExpression subQueryExpression)
 				FlattenSubQuery(subQueryExpression, fromClause, queryModel, 0);
 			base.VisitMainFromClause(fromClause, queryModel);
 		}