Support batching DML operations

[gokhanabatay]

Hi,
We have a Customer entity which has 100 properties/columns. At some business, some set of columns need to be updated with customer based custom data.
Think about that we have a fund batch and this batch create funds and updates Customer with latest fund amount "LastFundAmount".

Customer No  Last Fund Amount   Last Fund Date
100                   333                         20190916
101                   342                         20190916
102                   404.3                      20190916
103                   500                         20190916

We don't want to update Customer all properties which may create unnecessary index rebuild on db site, we need to update just changed data.

IQuery query = ISession.CreateQuery(Update Customer Set LastFundAmount = :LastFundAmount, LastFundDate = :LastFundDate where CustomerNo = :CustomerNo);

Also Batcher makes some database specific thinks for bulk insert/update/delete so, this hql needs to be send batcher at IStatementExecuter, but BasicExecuter or MultiTableExecuter does not supports batching.

Our application runs with 3 customer with 3 different database:Oracle, SQLServer, PostgresSql

[bahusoid]

I guess it could be possible to support such update queries in QueryBatch.
But most likely you have to implement IQueryBatchItem interface from the scratch (I guess some of the code can be reused from QueryBatchItem<TResult>).
So as a start you can start debugging:

var batch = session.CreateQueryBatch();
batch.Add(new QueryBatchItem<int>(session.CreateQuery("Update Customer Set LastFundAmount = :LastFundAmount, LastFundDate = :LastFundDate where CustomerNo = :CustomerNo)")));
batch.Execute();

It should give you some ideas what should be done inside UpdateQueryBatchItem that needs to be implemented...

[gokhanabatay]

Hi @fredericDelaporte , @bahusoid
Hql, Linq, NativeSql batching supported with below implementation.

There are some issues;

1. Dml Style Queries(Linq) does not cached internal NHibernate Cache NHibernate query plan for Linq Dml is not cached #2222
2. I need to use some private methods and Assingments.cs because they are inaccessible

private static readonly Func<AbstractQueryImpl2, IDictionary<string, TypedValue>, IQueryExpression> ExpandParametersFunc =
            DelegateFactory.InstanceMethod<Func<AbstractQueryImpl2, IDictionary<string, TypedValue>, IQueryExpression>>("ExpandParameters");
private static readonly Func<SqlString, IList<IParameterSpecification>, ISessionImplementor, SqlString> ExpandDynamicFilterParametersFunc =
            DelegateFactory.StaticMethod<FilterHelper, Func<SqlString, IList<IParameterSpecification>, ISessionImplementor, SqlString>>("ExpandDynamicFilterParameters");
private static readonly Func<QueryTranslatorImpl, IStatementExecutor> StatementExecutorFunc =
            DelegateFactory.FieldGet<QueryTranslatorImpl, IStatementExecutor>("_statementExecutor");
private static readonly Action<IQuery, IDictionary<string, Tuple<object, IType>>> SetParametersFunc = 
            DelegateFactory.StaticMethod<DefaultQueryProvider, Action<IQuery, IDictionary<string, Tuple<object, IType>>>>("SetParameters");
private static readonly Action<object, object[]> VerifyParametersFunc =
            DelegateFactory.InstanceMethodVoid(typeof(SqlQueryImpl), "VerifyParameters", typeof(bool));

Sample Useage:

--Hql sample
var batch = ISession.CreateQueryBatchDml();
foreach (var item in new string[] { "1311", "1328" })
{
    var query = ISession.CreateQuery($"update {typeof(StmtAccountStat)} set FirstDelayDate = :FirstDelayDate where AccountNo = :AccountNo");
    var date = item == "1311" ? System.DateTime.Now : System.DateTime.Now.AddDays(1);
    query.SetParameter("FirstDelayDate", date);
    query.SetParameter("AccountNo", item);
    batch.Add(query);
}
batch.Execute();

--Linq sample
foreach (var item in new string[] { "1311", "1328" })
{
    var date = item == "1311" ? System.DateTime.Now : System.DateTime.Now.AddDays(5);

    var query = ISession.Query<StmtAccountStat>().Where(x => x.AccountNo == item)
        .UpdateBuilderBatch()
        .Set(x => x.FirstDelayDate, date)
        .CreateQuery();

    batch.Add(query);
}
batch.Execute();

--Native SQL sample
foreach (var item in new string[] { "1311", "1328" })
{
    var query = ISession.CreateSQLQuery($"UPDATE DBO.STMT_ACCOUNT_STAT set FIRST_DELAY_DATE = :FirstDelayDate where ACCOUNT_NO = :AccountNo");
    var date = item == "1311" ? System.DateTime.Now : System.DateTime.Now.AddDays(1);
    query.SetParameter("FirstDelayDate", date);
    query.SetParameter("AccountNo", item);
    batch.Add(query);
}
batch.Execute();

using NHibernate;

namespace NHibernate.Multi
{
    public static class NHibernateSessionExtension
    {
        public static IQueryBatchDml CreateQueryBatchDml(this ISession session)
        {
            return new QueryBatchDml(session.GetSessionImplementation());
        }
    }
}

using System.Linq;

namespace NHibernate.Multi
{
    public static class DmlMethodExtension
    {
        /// <summary>
        /// Initiate an update for the entities selected by the query. Return
        /// a builder allowing to set properties and allowing to execute the update.
        /// </summary>
        /// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
        /// <param name="source">The query matching the entities to update.</param>
        /// <returns>An update builder.</returns>
        public static UpdateBuilderBatch<TSource> UpdateBuilderBatch<TSource>(this IQueryable<TSource> source)
        {
            return new UpdateBuilderBatch<TSource>(source);
        }
    }
}

using NHibernate;
using NHibernate.Linq;
using System;
using System.Linq;
using System.Linq.Expressions;

namespace NHibernate.Multi
{
    public class UpdateBuilderBatch<TSource>
    {
         internal static class NHibernateQueryProvider
        {
            public static readonly Action<IQuery, IDictionary<string, NamedParameter>> SetParametersFunc =
                DelegateFactory.StaticMethod<DefaultQueryProvider, Action<IQuery, IDictionary<string, NamedParameter>>>("SetParameters");
        
            public static readonly Func<NhLinqExpression, IDictionary<string, NamedParameter>> NamedParametersFunc =
                DelegateFactory.PropertyGet<NhLinqExpression, IDictionary<string, NamedParameter>>("NamedParameters");
        }
        
        private readonly IQueryable<TSource> _source;
        private readonly Assignments<TSource, TSource> _assignments = new Assignments<TSource, TSource>();
        
        internal UpdateBuilderBatch(IQueryable<TSource> source)
        {
            _source = source;
        }
        
        /// <summary>
        /// Set the specified property and return this builder.
        /// </summary>
        /// <typeparam name="TProp">The type of the property.</typeparam>
        /// <param name="property">The property.</param>
        /// <param name="expression">The expression that should be assigned to the property.</param>
        /// <returns>This update builder.</returns>
        public UpdateBuilderBatch<TSource> Set<TProp>(Expression<Func<TSource, TProp>> property, Expression<Func<TSource, TProp>> expression)
        {
            _assignments.Set(property, expression);
            return this;
        }
        
        /// <summary>
        /// Set the specified property and return this builder.
        /// </summary>
        /// <typeparam name="TProp">The type of the property.</typeparam>
        /// <param name="property">The property.</param>
        /// <param name="value">The value.</param>
        /// <returns>This update builder.</returns>
        public UpdateBuilderBatch<TSource> Set<TProp>(Expression<Func<TSource, TProp>> property, TProp value)
        {
            _assignments.Set(property, value);
            return this;
        }
        
        /// <summary>
        /// Returns update query. The update operation is performed batch in the database without reading the entities out of it.
        /// </summary>
        /// <returns>The number of updated entities.</returns>
        public IQuery CreateQuery(bool isVersioned = false)
        {
            var queryProvider = (DefaultQueryProvider)_source.Provider;
            var nhLinqExpression = new NhLinqDmlExpression<TSource>(isVersioned ? QueryMode.UpdateVersioned : QueryMode.Update, DmlExpressionRewriter.PrepareExpression<TSource>(_source.Expression, _assignments.List), queryProvider.Session.Factory);
        
            var query = queryProvider.Session.CreateQuery(nhLinqExpression);
        
            NHibernateQueryProvider.SetParametersFunc(query, NHibernateQueryProvider.NamedParametersFunc(nhLinqExpression));
        
            return query;
        }
    }
}

using NHibernate;
using System.Threading;
using System.Threading.Tasks;

namespace NHibernate.Multi
{
    public interface IQueryBatchDml
    {
        //
        // Summary:
        //     The timeout in seconds for the underlying ADO.NET query.
        int? Timeout { get; set; }

        //
        // Summary:
        //     The session flush mode to use during the batch execution.
        FlushMode? FlushMode { get; set; }

        /// <summary>
        /// Execute 
        /// </summary>
        void Execute();

        /// <summary>
        /// ExecuteAsync
        /// </summary>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        Task ExecuteAsync(CancellationToken cancellationToken);

        void Add(IQuery query);
    }
}

using NHibernate;
using NHibernate.AdoNet;
using NHibernate.Engine;
using NHibernate.Impl;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Threading;
using System.Threading.Tasks;

namespace NHibernate.Multi
{
    public class QueryBatchDml : IQueryBatchDml
    {
        protected readonly Dictionary<string, List<IQueryBatchDmlItem>> Queries = new Dictionary<string, List<IQueryBatchDmlItem>>();
        private static readonly Action<object, object[]> VerifyParametersFunc =
            DelegateFactory.InstanceMethodVoid(typeof(SqlQueryImpl), "VerifyParameters", typeof(bool));

        public QueryBatchDml(ISessionImplementor session)
        {
            Session = session;
        }

        protected ISessionImplementor Session { get; }

        public int? Timeout { get; set; }

        public FlushMode? FlushMode { get; set; }

        public async Task ExecuteAsync(CancellationToken cancellationToken = default(CancellationToken))
        {
            cancellationToken.ThrowIfCancellationRequested();
            if (Queries.Count == 0)
                return;

            var sessionFlushMode = Session.FlushMode;
            if (FlushMode.HasValue)
                Session.FlushMode = FlushMode.Value;
            try
            {
                if (Session.Factory.Settings.AdoBatchSize <= 1)
                {
                    foreach (var key in Queries.Keys)
                    {
                        foreach (var query in Queries[key])
                        {
                            await (query.ExecuteNonBatchedAsync(cancellationToken)).ConfigureAwait(false);
                        }
                    }

                    return;
                }

                await (ExecuteBatchedAsync(cancellationToken)).ConfigureAwait(false);
            }
            finally
            {
                Queries.Clear();

                if (FlushMode.HasValue)
                    Session.FlushMode = sessionFlushMode;
            }
        }

        public void Execute()
        {
            if (Queries.Count == 0)
                return;

            var sessionFlushMode = Session.FlushMode;
            if (FlushMode.HasValue)
                Session.FlushMode = FlushMode.Value;
            try
            {
                if (Session.Factory.Settings.AdoBatchSize <= 1)
                {
                    foreach (var key in Queries.Keys)
                    {
                        foreach (var query in Queries[key])
                        {
                            query.ExecuteNonBatched();
                        }
                    }

                    return;
                }

                ExecuteBatched();
            }
            finally
            {
                Queries.Clear();

                if (FlushMode.HasValue)
                    Session.FlushMode = sessionFlushMode;
            }
        }

        private void ExecuteBatched()
        {
            using ((Session as AbstractSessionImpl).BeginProcess())
            {
                IExpectation expectation = Expectations.AppropriateExpectation(ExecuteUpdateResultCheckStyle.Count);
                DbCommand command = null;
                foreach (var typeOfQueries in Queries.Values)
                {
                    IQueryBatchDmlItem firstQueryBatchDmlItem = null;
                    foreach (var query in typeOfQueries)
                    {
                        if (firstQueryBatchDmlItem == null)
                        {
                            query.Init(Session);
                            firstQueryBatchDmlItem = query;
                        }

                        var queryParameters = query.GetQuery().GetQueryParameters();
                        queryParameters.ValidateParameters();

                        command = Session.Batcher.PrepareBatchCommand(CommandType.Text, firstQueryBatchDmlItem.SqlString, firstQueryBatchDmlItem.QueryParameterTypes);
                        foreach (var parameterSpecification in firstQueryBatchDmlItem.ParameterSpecifications)
                        {
                            parameterSpecification.Bind(command, firstQueryBatchDmlItem.SqlQueryParametersList, queryParameters, Session);
                        }
                        Session.Batcher.AddToBatch(expectation);
                    }
                }

                if (Timeout.HasValue)
                {
                    command.CommandTimeout = Timeout.Value;
                }

                Session.Batcher.ExecuteBatch();
            }
        }

        private async Task ExecuteBatchedAsync(CancellationToken cancellationToken = default(CancellationToken))
        {
            using ((Session as AbstractSessionImpl).BeginProcess())
            {
                IExpectation expectation = Expectations.AppropriateExpectation(ExecuteUpdateResultCheckStyle.Count);
                DbCommand command = null;
                foreach (var typeOfQueries in Queries.Values)
                {
                    IQueryBatchDmlItem firstQueryBatchDmlItem = null;
                    foreach (var query in typeOfQueries)
                    {
                        if (firstQueryBatchDmlItem == null)
                        {
                            query.Init(Session);
                            firstQueryBatchDmlItem = query;
                        }

                        var queryParameters = query.GetQuery().GetQueryParameters();
                        queryParameters.ValidateParameters();

                        command = await (Session.Batcher.PrepareBatchCommandAsync(CommandType.Text, firstQueryBatchDmlItem.SqlString, firstQueryBatchDmlItem.QueryParameterTypes, cancellationToken)).ConfigureAwait(false);
                        foreach (var parameterSpecification in firstQueryBatchDmlItem.ParameterSpecifications)
                        {
                            await (parameterSpecification.BindAsync(command, firstQueryBatchDmlItem.SqlQueryParametersList, queryParameters, Session, cancellationToken)).ConfigureAwait(false);
                        }
                        await (Session.Batcher.AddToBatchAsync(expectation, cancellationToken)).ConfigureAwait(false);
                    }
                }

                if (Timeout.HasValue)
                {
                    command.CommandTimeout = Timeout.Value;
                }

                await (Session.Batcher.ExecuteBatchAsync(cancellationToken)).ConfigureAwait(false);
            }
        }

        public void Add(IQuery query)
        {
            if (!(query is AbstractQueryImpl abstractQueryImpl))
            {
                throw new ArgumentNullException(nameof(query));
            }
            else if (query is SqlQueryImpl nativeQueryImp)
            {
                VerifyParametersFunc(nativeQueryImp, new object[] { false });
            }

            Queries.TryGetValue(abstractQueryImpl.QueryString, out var typeOfQueries);
            if (typeOfQueries == null)
            {
                typeOfQueries = new List<IQueryBatchDmlItem>();
                Queries[abstractQueryImpl.QueryString] = typeOfQueries;
            }

            typeOfQueries.Add(new QueryBatchDmlItem(abstractQueryImpl));
        }
    }
}

using NHibernate.Engine;
using NHibernate.Param;
using NHibernate.SqlCommand;
using NHibernate.SqlTypes;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace NHibernate.Multi
{
    public interface IQueryBatchDmlItem
    {
        /// <summary>
        /// Returns Query
        /// </summary>
        AbstractQueryImpl GetQuery();

        /// <summary>
        /// Returns SqlString of Expression
        /// </summary>
        SqlString SqlString { get; }

        /// <summary>
        /// Returns effected QuerySpaces
        /// </summary>
        IEnumerable<string> QuerySpaces { get; }

        /// <summary>
        /// Returns Query Parameters
        /// </summary>
        List<Parameter> SqlQueryParametersList { get; }

        /// <summary>
        /// Returns Parameters Specifications
        /// </summary>
        IList<IParameterSpecification> ParameterSpecifications { get; }

        /// <summary>
        /// Returns QueryParameter SqlTypes 
        /// </summary>
        SqlType[] QueryParameterTypes { get; }

        /// <summary>
        ///  Execute immediately the query as a single standalone query. Used in case the data-provider does not support batches.
        /// </summary>
        /// <returns>effected row count</returns>
        int ExecuteNonBatched();

        /// <summary>
        ///  Execute immediately the query as a single standalone query. Used in case the data-provider does not support batches.
        /// </summary>
        /// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
        /// <returns>effected row count</returns>
        Task<int> ExecuteNonBatchedAsync(CancellationToken cancellationToken);

        /// <summary>
        /// Initialize the query. Method is called right before batch execution. Can be used for various delayed initialization logic.
        /// </summary>
        /// <param name="session"></param>
        void Init(ISessionImplementor session);
    }
}


using NHibernate;
using NHibernate.Engine;
using NHibernate.Engine.Query;
using NHibernate.Hql;
using NHibernate.Hql.Ast.ANTLR;
using NHibernate.Hql.Ast.ANTLR.Exec;
using NHibernate.Impl;
using NHibernate.Param;
using NHibernate.SqlCommand;
using NHibernate.SqlTypes;
using NHibernate.Util;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace NHibernate.Multi
{
    internal class QueryBatchDmlItem : IQueryBatchDmlItem
    {
        protected readonly AbstractQueryImpl Query;
        public List<Parameter> SqlQueryParametersList { get; protected set; }
        public SqlType[] QueryParameterTypes { get; protected set; }
        public IList<IParameterSpecification> ParameterSpecifications { get; protected set; }
        public SqlString SqlString { get; protected set; }
        public IEnumerable<string> QuerySpaces { get; protected set; }
    
        public AbstractQueryImpl GetQuery()
        {
            return Query;
        }
    
        private static readonly Func<AbstractQueryImpl2, IDictionary<string, TypedValue>, IQueryExpression> ExpandParametersFunc =
        #pragma warning disable S3220 // Method calls should not resolve ambiguously to overloads with "params"
                DelegateFactory.InstanceMethod<Func<AbstractQueryImpl2, IDictionary<string, TypedValue>, IQueryExpression>>("ExpandParameters");
        #pragma warning restore S3220 // Method calls should not resolve ambiguously to overloads with "params"
        private static readonly Func<SqlString, IList<IParameterSpecification>, ISessionImplementor, SqlString> ExpandDynamicFilterParametersFunc =
            DelegateFactory.StaticMethod<FilterHelper, Func<SqlString, IList<IParameterSpecification>, ISessionImplementor, SqlString>>("ExpandDynamicFilterParameters");
        private static readonly Func<QueryTranslatorImpl, IStatementExecutor> StatementExecutorFunc =
            DelegateFactory.FieldGet<QueryTranslatorImpl, IStatementExecutor>("_statementExecutor");
    
        public QueryBatchDmlItem(AbstractQueryImpl query)
        {
            Query = query;
        }
    
        public virtual void Init(ISessionImplementor session)
        {
            if (Query is AbstractQueryImpl2 abstractQueryImpl)
            {
                IQueryExpression queryExpression = ExpandParametersFunc(abstractQueryImpl, Query.GetQueryParameters().NamedParameters);
                IQueryPlan hqlPlan = session.Factory.QueryPlanCache.GetHQLQueryPlan(queryExpression, false, session.EnabledFilters) as QueryExpressionPlan;
                QuerySpaces = hqlPlan.QuerySpaces;
    
                QueryTranslatorImpl queryTranslator = hqlPlan.Translators.First() as QueryTranslatorImpl;
                //Create a copy of Parameters as ExpandDynamicFilterParameters may modify it
                ParameterSpecifications = queryTranslator.SqlAST.Walker.Parameters.ToList();
    
                IStatementExecutor statementExecutor = StatementExecutorFunc(queryTranslator);
                SqlString = statementExecutor.SqlStatements.First();
                if (ExpandDynamicFilterParametersFunc != null)
                {
                    SqlString = ExpandDynamicFilterParametersFunc(SqlString, ParameterSpecifications, session);
                }
                SqlQueryParametersList = SqlString.GetParameters().ToList();
                QueryParameterTypes = ParameterSpecifications.GetQueryParameterTypes(SqlQueryParametersList, session.Factory);
            }
            else if (Query is SqlQueryImpl nativeQueryImp)
            {
                var parameters = Query.GetQueryParameters();
                var namedParameters = parameters.NamedParameters;
                var parameterSpecification = nativeQueryImp.GenerateQuerySpecification(namedParameters);
    
                NativeSQLQueryPlan nativePlan = session.Factory.QueryPlanCache.GetNativeSQLQueryPlan(parameterSpecification);
                SqlString = nativePlan.CustomQuery.SQL;
                //Create a copy of Parameters as ExpandDynamicFilterParameters may modify it
                ParameterSpecifications = nativePlan.CustomQuery.CollectedParametersSpecifications.ToList();
                QuerySpaces = nativePlan.CustomQuery.QuerySpaces;
                if (ExpandDynamicFilterParametersFunc != null)
                {
                    SqlString = ExpandDynamicFilterParametersFunc(SqlString, ParameterSpecifications, session);
                }
                SqlQueryParametersList = SqlString.GetParameters().ToList();
                ParameterSpecifications.ResetEffectiveExpectedType(parameters);
                QueryParameterTypes = ParameterSpecifications.GetQueryParameterTypes(SqlQueryParametersList, session.Factory);
            }
        }
    
        public int ExecuteNonBatched()
        {
            return Query.ExecuteUpdate();
        }
    
        public async Task<int> ExecuteNonBatchedAsync(CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            return await (Query.ExecuteUpdateAsync(cancellationToken)).ConfigureAwait(false);
        }
    }
}

[zabeda]

I have a scenario where having the functionality here would be helpful. I took the example code here and modified the existing UpdateBuilder to return an IQuery rather create another QueryBatch impl. I also modified the SetParameters method of DefaultQueryProvider to be internal rather than public. I did some testing and this appears to works well. My knowledge about the internals of NHibernate are rather limited, but would this change make sense?

// NHibernate.Linq.UpdateBuilder.cs

		/// <summary>
		/// Returns update as an IQuery 
		/// </summary>
		/// <returns>IQuery that performs the update</returns>
		public IQuery CreateQuery(bool isVersioned = false)
		{
			var prov = (ISupportFutureBatchNhQueryProvider) _source.Provider;

			var nhLinqExpression = new NhLinqDmlExpression<TSource>(
				isVersioned 
					? QueryMode.UpdateVersioned 
					: QueryMode.Update, 
				DmlExpressionRewriter.PrepareExpression<TSource>(_source.Expression, _assignments.List), 
				prov.Session.Factory);

			var query = prov.Session.CreateQuery(nhLinqExpression);

			DefaultQueryProvider.SetParameters(query, nhLinqExpression.NamedParameters);
			return query;
		}

Thank you,
Pat

[gokhanabatay]

If you share your full implementation it could be nice, my implementation works as well the main issue as I explained above, we are using reflection to use Nhibernate private/internal methods. To handle reflection performance issue I used Delegates.
https://www.nuget.org/packages/DelegatesFactory/

[zabeda]

This is the modified version of UpdateBuilder. The only significant change was the addition of the CreateQuery method.

namespace NHibernate.Linq
{
	/// <summary>
	/// An update builder on which values to update can be specified.
	/// </summary>
	/// <typeparam name="TSource">The type of the entities to update.</typeparam>
	public partial class UpdateBuilder<TSource>
	{
		private readonly IQueryable<TSource> _source;
		private readonly Assignments<TSource, TSource> _assignments = new Assignments<TSource, TSource>();

		internal UpdateBuilder(IQueryable<TSource> source)
		{
			_source = source;
		}

		/// <summary>
		/// Set the specified property and return this builder.
		/// </summary>
		/// <typeparam name="TProp">The type of the property.</typeparam>
		/// <param name="property">The property.</param>
		/// <param name="expression">The expression that should be assigned to the property.</param>
		/// <returns>This update builder.</returns>
		public UpdateBuilder<TSource> Set<TProp>(Expression<Func<TSource, TProp>> property, Expression<Func<TSource, TProp>> expression)
		{
			_assignments.Set(property, expression);
			return this;
		}

		/// <summary>
		/// Set the specified property and return this builder.
		/// </summary>
		/// <typeparam name="TProp">The type of the property.</typeparam>
		/// <param name="property">The property.</param>
		/// <param name="value">The value.</param>
		/// <returns>This update builder.</returns>
		public UpdateBuilder<TSource> Set<TProp>(Expression<Func<TSource, TProp>> property, TProp value)
		{
			_assignments.Set(property, value);
			return this;
		}

		/// <summary>
		/// Update the entities. The update operation is performed in the database without reading the entities out of it.
		/// </summary>
		/// <returns>The number of updated entities.</returns>
		public int Update()
		{
			return _source.ExecuteUpdate(DmlExpressionRewriter.PrepareExpression<TSource>(_source.Expression, _assignments.List), false);
		}

		/// <summary>
		/// Perform an <c>update versioned</c> on the entities. The update operation is performed in the database without reading the entities out of it.
		/// </summary>
		/// <returns>The number of updated entities.</returns>
		public int UpdateVersioned()
		{
			return _source.ExecuteUpdate(DmlExpressionRewriter.PrepareExpression<TSource>(_source.Expression, _assignments.List), true);
		}

		/// <summary>
		/// Returns the update as an IQuery. 
		/// </summary>
		/// <returns>IQuery that performs the update</returns>
		public IQuery CreateQuery(bool isVersioned = false)
		{
			var prov = (ISupportFutureBatchNhQueryProvider) _source.Provider;

			var nhLinqExpression = new NhLinqDmlExpression<TSource>(
				isVersioned 
					? QueryMode.UpdateVersioned 
					: QueryMode.Update, 
				DmlExpressionRewriter.PrepareExpression<TSource>(_source.Expression, _assignments.List), 
				prov.Session.Factory);

			var query = prov.Session.CreateQuery(nhLinqExpression);
			DefaultQueryProvider.SetParameters(query, nhLinqExpression.NamedParameters);
			return query;
		}
	}
}

The SetParameters method in DefaultQueryProvider was changed to internal, so it could be called.

internal static void SetParameters(IQuery query, IDictionary<string, NamedParameter> parameters)

[zabeda]

Ugh. Apologies. I tested this by calling the Update method directly. Once added to an IQueryBatch and executed from there, I am getting an error related to a null Loader. Will post further if I figure it out.

[zabeda]

@gokhanabatay, I ran into difficulties tracing down the issues I was facing, so I decided to go with your implementation. I did a little refactoring to our code and your solution works well. I did have to make a few small changes, most likely due to API changes. Did you submit your solution for inclusion to NHibernate?

Thank you for taking the time to share your solution here.

[gokhanabatay]

@zabeda I have updated implementation, works with latest NH 5.3.8. Glad to see someone's need.