NH-3488 - Remove code duplication in DML queries

Author: hazzik

doc/reference/modules/query_linq.xml

@@ -544,9 +544,9 @@ IList<Cat> oldCats =
         In both cases, unspecified properties are not included in the resulting SQL update. This could
         be changed for <link linkend="mapping-declaration-version"><literal>version</literal></link> and
         <link linkend="mapping-declaration-timestamp"><literal>timestamp</literal></link> properties:
-        <literal>As</literal> and <literal>Assign</literal> methods take an optional boolean parameter,
-        <literal>versioned</literal>, which allows incrementing the version. Custom version types
-        (<literal>NHibernate.Usertype.IUserVersionType</literal>) are not supported.
+        using <literal>UpdateVersioned</literal> instead of <literal>Update</literal> allows incrementing
+        the version. Custom version types (<literal>NHibernate.Usertype.IUserVersionType</literal>) are
+        not supported.
       </para>
     </sect2>
 

src/NHibernate.Test/LinqBulkManipulation/Fixture.cs

@@ -542,7 +542,7 @@ public void IncrementCounterVersion()
 					// Note: Update more than one column to showcase NH-3624, which involved losing some columns. /2014-07-26
 					var count =
 						s.Query<IntegerVersioned>()
-						 .Update().Assign(x => x.Set(y => y.Name, y => y.Name + "upd").Set(y => y.Data, y => y.Data + "upd"), true);
+						 .UpdateVersioned().Assign(x => x.Set(y => y.Name, y => y.Name + "upd").Set(y => y.Data, y => y.Data + "upd"));
 					Assert.That(count, Is.EqualTo(1), "incorrect exec count");
 					t.Commit();
 				}
@@ -571,7 +571,7 @@ public void IncrementTimestampVersion()
 				{
 					// Note: Update more than one column to showcase NH-3624, which involved losing some columns. /2014-07-26
 					var count = s.Query<TimestampVersioned>()
-						.Update().Assign(x => x.Set(y => y.Name, y => y.Name + "upd").Set(y => y.Data, y => y.Data + "upd"), true);
+						.UpdateVersioned().Assign(x => x.Set(y => y.Name, y => y.Name + "upd").Set(y => y.Data, y => y.Data + "upd"));
 					Assert.That(count, Is.EqualTo(1), "incorrect exec count");
 					t.Commit();
 				}

src/NHibernate/Linq/Assignment.cs

@@ -1,28 +1,21 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
 using System.Linq.Expressions;
-using System.Reflection;
 using NHibernate.Linq.Visitors;
-using NHibernate.Util;
 
 namespace NHibernate.Linq
 {
-	public abstract class Assignments
-	{
-		protected static readonly ConstructorInfo DictionaryConstructorInfo = typeof(Dictionary<string, object>).GetConstructor(new[] { typeof(int) });
-		protected static readonly MethodInfo DictionaryAddMethodInfo = ReflectHelper.GetMethod<Dictionary<string, object>>(d => d.Add(null, null));
-	}
-
 	/// <summary>
 	/// Class to hold assignments used in updates and inserts.
 	/// </summary>
 	/// <typeparam name="TSource">The type of the entity source of the insert or to update.</typeparam>
 	/// <typeparam name="TTarget">The type of the entity to insert or to update.</typeparam>
-	public class Assignments<TSource, TTarget> : Assignments
+	public class Assignments<TSource, TTarget>
 	{
-		private readonly List<Assignment> _sets = new List<Assignment>();
+		private readonly Dictionary<string, Expression> _assignments = new Dictionary<string, Expression>();
+
+		internal IReadOnlyDictionary<string, Expression> List => _assignments;
 
 		/// <summary>
 		/// Sets the specified property.
@@ -36,7 +29,7 @@ public Assignments<TSource, TTarget> Set<TProp>(Expression<Func<TTarget, TProp>>
 			if (expression == null)
 				throw new ArgumentNullException(nameof(expression));
 			var member = GetMemberExpression(property);
-			_sets.Add(new Assignment(member.GetMemberPath(), expression));
+			_assignments.Add(member.GetMemberPath(), expression);
 			return this;
 		}
 
@@ -50,7 +43,7 @@ public Assignments<TSource, TTarget> Set<TProp>(Expression<Func<TTarget, TProp>>
 		public Assignments<TSource, TTarget> Set<TProp>(Expression<Func<TTarget, TProp>> property, TProp value)
 		{
 			var member = GetMemberExpression(property);
-			_sets.Add(new Assignment(member.GetMemberPath(), Expression.Constant(value, typeof(TProp))));
+			_assignments.Add(member.GetMemberPath(), Expression.Constant(value, typeof(TProp)));
 			return this;
 		}
 
@@ -63,85 +56,5 @@ private static MemberExpression GetMemberExpression<TProp>(Expression<Func<TTarg
 				throw new ArgumentException($"The property expression must refer to a property of {param.Name}({param.Type.Name})", nameof(property));
 			return member;
 		}
-
-		/// <summary>
-		/// Converts the assignments into a lambda expression, which creates a Dictionary&lt;string,object%gt;.
-		/// </summary>
-		/// <returns>A lambda expression representing the assignments.</returns>
-		public LambdaExpression ConvertToDictionaryExpression()
-		{
-			var param = Expression.Parameter(typeof(TSource));
-			var inits = new List<ElementInit>();
-			foreach (var set in _sets)
-			{
-				var setter = set.Expression;
-				if (setter is LambdaExpression setterLambda)
-				{
-					setter = setterLambda.Body.Replace(setterLambda.Parameters.First(), param);
-				}
-				inits.Add(Expression.ElementInit(DictionaryAddMethodInfo, Expression.Constant(set.PropertyPath),
-					Expression.Convert(setter, typeof(object))));
-			}
-
-			//The ListInit is intentionally "infected" with the lambda parameter (param), in the form of an IIF. 
-			//The only relevance is to make sure that the ListInit is not evaluated by the PartialEvaluatingExpressionTreeVisitor,
-			//which could turn it into a Constant
-			var listInit = Expression.ListInit(
-				Expression.New(
-					DictionaryConstructorInfo,
-					Expression.Condition(
-						Expression.Equal(param, Expression.Constant(null, typeof(TSource))),
-						Expression.Constant(_sets.Count),
-						Expression.Constant(_sets.Count))),
-				inits);
-
-			return Expression.Lambda(listInit, param);
-		}
-
-		/// <summary>
-		/// Converts a members initialization expression to assignments. Unset members are ignored and left untouched.
-		/// </summary>
-		/// <param name="expression">The expression to convert.</param>
-		/// <returns>The corresponding assignments.</returns>
-		public static Assignments<TSource, TTarget> FromExpression(Expression<Func<TSource, TTarget>> expression)
-		{
-			if (expression == null)
-				throw new ArgumentNullException(nameof(expression));
-			var instance = new Assignments<TSource, TTarget>();
-			var memberInitExpression = expression.Body as MemberInitExpression ??
-				throw new ArgumentException("The expression must be member initialization, e.g. x => new Dog { Name = x.Name, Age = x.Age + 5 }");
-
-			AddSetsFromBindings(memberInitExpression.Bindings, instance, "", expression.Parameters);
-
-			return instance;
-		}
-
-		private static void AddSetsFromBindings(IEnumerable<MemberBinding> bindings, Assignments<TSource, TTarget> instance, string path, ReadOnlyCollection<ParameterExpression> parameters)
-		{
-			foreach (var binding in bindings)
-			{
-				if (binding.BindingType == MemberBindingType.Assignment) // {Property="Value"}
-				{
-					AddSetsFromAssignment((MemberAssignment)binding, instance, path + "." + binding.Member.Name, parameters);
-				}
-				else if (binding.BindingType == MemberBindingType.MemberBinding) // {Property={SubProperty="Value}}
-				{
-					AddSetsFromBindings(((MemberMemberBinding)binding).Bindings, instance, path + "." + binding.Member.Name, parameters);
-				}
-			}
-		}
-
-		private static void AddSetsFromAssignment(MemberAssignment assignment, Assignments<TSource, TTarget> instance, string path, ReadOnlyCollection<ParameterExpression> parameters)
-		{
-			// {Property=new Instance{SubProperty="Value"}}
-			if (assignment.Expression is MemberInitExpression memberInit)
-			{
-				AddSetsFromBindings(memberInit.Bindings, instance, path, parameters);
-			}
-			else
-			{
-				instance._sets.Add(new Assignment(path.Substring(1), Expression.Lambda(assignment.Expression, parameters)));
-			}
-		}
 	}
 }

src/NHibernate/Linq/Assignments.cs

@@ -16,9 +16,7 @@ public interface INhQueryProvider : IQueryProvider
 		IEnumerable<TResult> ExecuteFuture<TResult>(Expression expression);
 		IFutureValue<TResult> ExecuteFutureValue<TResult>(Expression expression);
 		void SetResultTransformerAndAdditionalCriteria(IQuery query, NhLinqExpression nhExpression, IDictionary<string, Tuple<object, IType>> parameters);
-		int ExecuteDelete(Expression predicate);
-		int ExecuteUpdate<T>(Expression expression, Assignments<T, T> assignments, bool versioned);
-		int ExecuteInsert<TInput, TOutput>(Expression expression, Assignments<TInput, TOutput> assignments);
+		int ExecuteDml<T>(QueryMode queryMode, Expression expression);
 	}
 
 	public class DefaultQueryProvider : INhQueryProvider
@@ -174,31 +172,9 @@ public virtual void SetResultTransformerAndAdditionalCriteria(IQuery query, NhLi
 			}
 		}
 
-		public int ExecuteDelete(Expression predicate)
+		public int ExecuteDml<T>(QueryMode queryMode, Expression expression)
 		{
-			var nhLinqExpression = new NhLinqDeleteExpression(predicate, Session.Factory);
-
-			var query = Session.CreateQuery(nhLinqExpression);
-
-			SetParameters(query, nhLinqExpression.ParameterValuesByName);
-
-			return query.ExecuteUpdate();
-		}
-
-		public int ExecuteUpdate<T>(Expression expression, Assignments<T, T> assignments, bool versioned)
-		{
-			var nhLinqExpression = new NhLinqUpdateExpression<T>(expression, assignments, Session.Factory, versioned);
-
-			var query = Session.CreateQuery(nhLinqExpression);
-
-			SetParameters(query, nhLinqExpression.ParameterValuesByName);
-
-			return query.ExecuteUpdate();
-		}
-
-		public int ExecuteInsert<TSource, TTarget>(Expression expression, Assignments<TSource, TTarget> assignments)
-		{
-			var nhLinqExpression = new NhLinqInsertExpression<TSource, TTarget>(expression, assignments, Session.Factory);
+			var nhLinqExpression = new NhLinqDmlExpression<T>(queryMode, expression, Session.Factory);
 
 			var query = Session.CreateQuery(nhLinqExpression);
 
@@ -207,4 +183,4 @@ public int ExecuteInsert<TSource, TTarget>(Expression expression, Assignments<TS
 			return query.ExecuteUpdate();
 		}
 	}
-}
+}

src/NHibernate/Linq/DefaultQueryProvider.cs

@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using NHibernate.Linq.Visitors;
+using NHibernate.Util;
+
+namespace NHibernate.Linq
+{
+	public class DmlExpressionRewriter
+	{
+		static readonly ConstructorInfo DictionaryConstructorInfo = typeof(Dictionary<string, object>).GetConstructor(new[] {typeof(int)});
+
+		static readonly MethodInfo DictionaryAddMethodInfo = ReflectHelper.GetMethod<Dictionary<string, object>>(d => d.Add(null, null));
+
+		readonly IReadOnlyCollection<ParameterExpression> _parameters;
+		readonly Dictionary<string, Expression> _assignments = new Dictionary<string, Expression>();
+
+		DmlExpressionRewriter(IReadOnlyCollection<ParameterExpression> parameters)
+		{
+			_parameters = parameters;
+		}
+
+		void AddSettersFromBindings(IEnumerable<MemberBinding> bindings, string path)
+		{
+			foreach (var node in bindings)
+				switch (node.BindingType)
+				{
+					case MemberBindingType.Assignment:
+						AddSettersFromAssignment((MemberAssignment) node, path + "." + node.Member.Name);
+						break;
+					case MemberBindingType.MemberBinding:
+						AddSettersFromBindings(((MemberMemberBinding) node).Bindings, path + "." + node.Member.Name);
+						break;
+					default:
+						throw new InvalidOperationException($"{node.BindingType} is not supported");
+				}
+		}
+
+		void AddSettersFromAssignment(MemberAssignment assignment, string path)
+		{
+			// {Property=new Instance{SubProperty="Value"}}
+			if (assignment.Expression is MemberInitExpression memberInit)
+				AddSettersFromBindings(memberInit.Bindings, path);
+			else
+				_assignments.Add(path.Substring(1), Expression.Lambda(assignment.Expression, _parameters));
+		}
+
+		/// <summary>
+		///     Converts the assignments into a lambda expression, which creates a Dictionary&lt;string,object%gt;.
+		/// </summary>
+		/// <param name="assignments"></param>
+		/// <returns>A lambda expression representing the assignments.</returns>
+		static LambdaExpression ConvertAssignmentsToDictionaryExpression<TSource>(IReadOnlyDictionary<string, Expression> assignments)
+		{
+			var param = Expression.Parameter(typeof(TSource));
+			var inits = new List<ElementInit>();
+			foreach (var set in assignments)
+			{
+				var setter = set.Value;
+				if (setter is LambdaExpression setterLambda)
+					setter = setterLambda.Body.Replace(setterLambda.Parameters.First(), param);
+				inits.Add(
+					Expression.ElementInit(
+						DictionaryAddMethodInfo,
+						Expression.Constant(set.Key),
+						Expression.Convert(setter, typeof(object))));
+			}
+
+			//The ListInit is intentionally "infected" with the lambda parameter (param), in the form of an IIF. 
+			//The only relevance is to make sure that the ListInit is not evaluated by the PartialEvaluatingExpressionTreeVisitor,
+			//which could turn it into a Constant
+			var listInit = Expression.ListInit(
+				Expression.New(
+					DictionaryConstructorInfo,
+					Expression.Condition(
+						Expression.Equal(param, Expression.Constant(null, typeof(TSource))),
+						Expression.Constant(assignments.Count),
+						Expression.Constant(assignments.Count))),
+				inits);
+
+			return Expression.Lambda(listInit, param);
+		}
+
+		public static Expression PrepareExpression<TSource, TTarget>(Expression sourceExpression, Expression<Func<TSource, TTarget>> expression)
+		{
+			if (expression == null)
+				throw new ArgumentNullException(nameof(expression));
+
+			var memberInitExpression = expression.Body as MemberInitExpression ??
+			                           throw new ArgumentException("The expression must be member initialization, e.g. x => new Dog { Name = x.Name, Age = x.Age + 5 }");
+
+			var assignments = ExtractAssignments(expression, memberInitExpression);
+			return PrepareExpression<TSource>(sourceExpression, assignments);
+		}
+
+		public static Expression PrepareExpression<TSource>(Expression sourceExpression, IReadOnlyDictionary<string, Expression> assignments)
+		{
+			var lambda = ConvertAssignmentsToDictionaryExpression<TSource>(assignments);
+
+			return Expression.Call(
+				ReflectionCache.QueryableMethods.SelectDefinition.MakeGenericMethod(typeof(TSource), lambda.Body.Type),
+				sourceExpression,
+				Expression.Quote(lambda));
+		}
+
+		static Dictionary<string, Expression> ExtractAssignments<TSource, TTarget>(Expression<Func<TSource, TTarget>> expression, MemberInitExpression memberInitExpression)
+		{
+			var instance = new DmlExpressionRewriter(expression.Parameters);
+			instance.AddSettersFromBindings(memberInitExpression.Bindings, "");
+			return instance._assignments;
+		}
+	}
+}

src/NHibernate/Linq/DmlExpressionRewriter.cs

@@ -30,7 +30,8 @@ public int Into<TTarget>(Action<Assignments<TSource, TTarget>> assignmentActions
 				throw new ArgumentNullException(nameof(assignmentActions));
 			var assignments = new Assignments<TSource, TTarget>();
 			assignmentActions.Invoke(assignments);
-			return InsertInto(assignments);
+
+			return ExecuteInsert<TTarget>(DmlExpressionRewriter.PrepareExpression<TSource>(_sourceExpression, assignments.List));
 		}
 
 		/// <summary>
@@ -41,13 +42,12 @@ public int Into<TTarget>(Action<Assignments<TSource, TTarget>> assignmentActions
 		/// <returns>The number of inserted entities.</returns>
 		public int As<TTarget>(Expression<Func<TSource, TTarget>> expression)
 		{
-			var assignments = Assignments<TSource, TTarget>.FromExpression(expression);
-			return InsertInto(assignments);
+			return ExecuteInsert<TTarget>(DmlExpressionRewriter.PrepareExpression(_sourceExpression, expression));
 		}
 
-		internal int InsertInto<TTarget>(Assignments<TSource, TTarget> assignments)
+		private int ExecuteInsert<TTarget>(Expression insertExpression)
 		{
-			return _provider.ExecuteInsert(_sourceExpression, assignments);
+			return _provider.ExecuteDml<TTarget>(QueryMode.Insert, insertExpression);
 		}
 	}
 }