NH-3488 - Refactoring further assignments

Author: hazzik

src/NHibernate/Linq/Assignment.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
 using System.Linq.Expressions;
 using NHibernate.Linq.Visitors;
@@ -14,9 +13,9 @@ namespace NHibernate.Linq
 	/// <typeparam name="TTarget">The type of the entity to insert or to update.</typeparam>
 	public class Assignments<TSource, TTarget>
 	{
-		private readonly List<Assignment> _sets = new List<Assignment>();
+		private readonly Dictionary<string, Expression> _assignments = new Dictionary<string, Expression>();
 
-		internal IReadOnlyCollection<Assignment> List => _sets;
+		internal IReadOnlyDictionary<string, Expression> List => _assignments;
 
 		/// <summary>
 		/// Sets the specified property.
@@ -30,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;
 		}
 
@@ -44,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;
 		}
 
@@ -57,53 +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 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 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 instance = new Assignments<TSource, TTarget>();
-			instance.AddSetsFromBindings(memberInitExpression.Bindings, "", expression.Parameters);
-			return instance;
-		}
-
-		private void AddSetsFromBindings(IEnumerable<MemberBinding> bindings, string path, ReadOnlyCollection<ParameterExpression> parameters)
-		{
-			foreach (var node in bindings)
-			{
-				switch (node.BindingType)
-				{
-					case MemberBindingType.Assignment:
-						AddSetsFromAssignment((MemberAssignment)node, path + "." + node.Member.Name, parameters);
-						break;
-					case MemberBindingType.MemberBinding:
-						AddSetsFromBindings(((MemberMemberBinding)node).Bindings, path + "." + node.Member.Name, parameters);
-						break;
-					default:
-						throw new InvalidOperationException($"{node.BindingType} is not supported");
-				}
-			}
-		}
-
-		private void AddSetsFromAssignment(MemberAssignment assignment, string path, ReadOnlyCollection<ParameterExpression> parameters)
-		{
-			// {Property=new Instance{SubProperty="Value"}}
-			if (assignment.Expression is MemberInitExpression memberInit)
-			{
-				AddSetsFromBindings(memberInit.Bindings, path, parameters);
-			}
-			else
-			{
-				_sets.Add(new Assignment(path.Substring(1), Expression.Lambda(assignment.Expression, parameters)));
-			}
-		}
 	}
 }

src/NHibernate/Linq/Assignments.cs

@@ -17,8 +17,8 @@ public interface INhQueryProvider : IQueryProvider
 		IFutureValue<TResult> ExecuteFutureValue<TResult>(Expression expression);
 		void SetResultTransformerAndAdditionalCriteria(IQuery query, NhLinqExpression nhExpression, IDictionary<string, Tuple<object, IType>> parameters);
 		int ExecuteDelete<T>(Expression predicate);
-		int ExecuteUpdate<TInput>(Expression expression, bool versioned, IReadOnlyCollection<Assignment> assignments);
-		int ExecuteInsert<TInput, TOutput>(Expression expression, IReadOnlyCollection<Assignment> assignments);
+		int ExecuteUpdate<T>(Expression expression, bool versioned);
+		int ExecuteInsert<T>(Expression expression);
 	}
 
 	public class DefaultQueryProvider : INhQueryProvider
@@ -185,9 +185,9 @@ public int ExecuteDelete<T>(Expression predicate)
 			return query.ExecuteUpdate();
 		}
 
-		public int ExecuteUpdate<T>(Expression expression, bool versioned, IReadOnlyCollection<Assignment> assignments)
+		public int ExecuteUpdate<T>(Expression expression, bool versioned)
 		{
-			var nhLinqExpression = new NhLinqUpdateExpression<T>(expression, Session.Factory, versioned, assignments);
+			var nhLinqExpression = new NhLinqUpdateExpression<T>(Session.Factory, expression, versioned);
 
 			var query = Session.CreateQuery(nhLinqExpression);
 
@@ -196,9 +196,9 @@ public int ExecuteUpdate<T>(Expression expression, bool versioned, IReadOnlyColl
 			return query.ExecuteUpdate();
 		}
 
-		public int ExecuteInsert<TSource, TTarget>(Expression expression, IReadOnlyCollection<Assignment> assignments)
+		public int ExecuteInsert<T>(Expression expression)
 		{
-			var nhLinqExpression = new NhLinqInsertExpression<TSource, TTarget>(expression, Session.Factory, assignments);
+			var nhLinqExpression = new NhLinqInsertExpression<T>(Session.Factory, expression);
 
 			var query = Session.CreateQuery(nhLinqExpression);
 

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 _provider.ExecuteInsert<TTarget>(DmlExpressionRewriter.PrepareExpression<TSource>(_sourceExpression, assignments.List));
 		}
 
 		/// <summary>
@@ -41,13 +42,7 @@ 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);
-		}
-
-		internal int InsertInto<TTarget>(Assignments<TSource, TTarget> assignments)
-		{
-			return _provider.ExecuteInsert<TSource, TTarget>(_sourceExpression, assignments.List);
+			return _provider.ExecuteInsert<TTarget>(DmlExpressionRewriter.PrepareExpression(_sourceExpression, expression));
 		}
 	}
 }

src/NHibernate/Linq/InsertSyntax.cs

@@ -32,7 +32,7 @@ public class NhLinqExpression : IQueryExpression
 
 		protected virtual QueryMode QueryMode => QueryMode.Select;
 
-		private Expression _expression;
+		private readonly Expression _expression;
 		private readonly IDictionary<ConstantExpression, NamedParameter> _constantToParameterMap;
 
 		public NhLinqExpression(Expression expression, ISessionFactoryImplementor sessionFactory)

src/NHibernate/Linq/NhLinqExpression.cs

@@ -1,11 +1,9 @@
-using System.Collections.Generic;
 using System.Linq.Expressions;
 using NHibernate.Engine;
-using NHibernate.Util;
 
 namespace NHibernate.Linq
 {
-	public class NhLinqInsertExpression<TSource, TTarget> : NhLinqExpression
+	public class NhLinqInsertExpression<TTarget> : NhLinqExpression
 	{
 		protected override QueryMode QueryMode => QueryMode.Insert;
 
@@ -14,19 +12,10 @@ public class NhLinqInsertExpression<TSource, TTarget> : NhLinqExpression
 		/// </summary>
 		protected override System.Type TargetType => typeof(TTarget);
 
-		public NhLinqInsertExpression(Expression expression, ISessionFactoryImplementor sessionFactory, IReadOnlyCollection<Assignment> assignments)
-			: base(RewriteForInsert(expression, assignments), sessionFactory)
+		public NhLinqInsertExpression(ISessionFactoryImplementor sessionFactory, Expression expression)
+			: base(expression, sessionFactory)
 		{
 			Key = "INSERT " + Key;
 		}
-
-		private static Expression RewriteForInsert(Expression expression, IReadOnlyCollection<Assignment> assignments)
-		{
-			var lambda = Assignment.ConvertAssignmentsToDictionaryExpression<TSource>(assignments);
-
-			return Expression.Call(
-				ReflectionCache.QueryableMethods.SelectDefinition.MakeGenericMethod(typeof(TSource), lambda.Body.Type),
-				expression, Expression.Quote(lambda));
-		}
 	}
 }