diff --git a/src/NHibernate.Test/Async/NHSpecificTest/GH1547/Fixture.cs b/src/NHibernate.Test/Async/NHSpecificTest/GH1547/Fixture.cs
new file mode 100644
index 00000000000..8ff5cd8b37e
--- /dev/null
+++ b/src/NHibernate.Test/Async/NHSpecificTest/GH1547/Fixture.cs
@@ -0,0 +1,193 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by AsyncGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Common;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using NHibernate.Cfg;
+using NHibernate.Driver;
+using NHibernate.Engine;
+using NHibernate.Engine.Query;
+using NHibernate.SqlCommand;
+using NHibernate.SqlTypes;
+using NHibernate.Util;
+using NSubstitute;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.GH1547
+{
+	using System.Threading.Tasks;
+	using System.Threading;
+	[TestFixture, Explicit("Contains only performances benchmark")]
+	public class FixtureAsync : BugTestCase
+	{
+		protected override void Configure(Configuration configuration)
+		{
+			base.Configure(configuration);
+
+			var driverClass = ReflectHelper.ClassForName(configuration.GetProperty(Cfg.Environment.ConnectionDriver));
+			DriverForSubstitutedCommand.DriverClass = driverClass;
+
+			configuration.SetProperty(
+				Cfg.Environment.ConnectionDriver,
+				typeof(DriverForSubstitutedCommand).AssemblyQualifiedName);
+		}
+
+		protected override void DropSchema()
+		{
+			(Sfi.ConnectionProvider.Driver as DriverForSubstitutedCommand)?.CleanUp();
+			base.DropSchema();
+		}
+
+		[Test]
+		public Task SimpleLinqPerfAsync()
+		{
+			return BenchmarkAsync(
+				"Simple LINQ",
+				s =>
+					s
+						.Query<Entity>()
+						.Where(e => e.Name == "Bob"));
+		}
+
+		[Test]
+		public Task LinqWithNonParameterizedConstantPerfAsync()
+		{
+			return BenchmarkAsync(
+				"Non parameterized constant",
+				s =>
+					s
+						.Query<Entity>()
+						.Where(e => e.Name == "Bob")
+						.Select(e => new { e, c = 2 }));
+		}
+
+		[Test]
+		public Task LinqWithListParameterPerfAsync()
+		{
+			try
+			{
+				var names = new[] { "Bob", "Sally" };
+				return BenchmarkAsync(
+				"List parameter",
+				s =>
+					s
+						.Query<Entity>()
+						.Where(e => names.Contains(e.Name)));
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
+		}
+
+		private async Task BenchmarkAsync<T>(string test, Func<ISession, IQueryable<T>> queryFactory, CancellationToken cancellationToken = default(CancellationToken))
+		{
+			var driver = (DriverForSubstitutedCommand) Sfi.ConnectionProvider.Driver;
+			var timings = new List<double>();
+			var sw = new Stopwatch();
+
+			var cache = (SoftLimitMRUCache)
+				typeof(QueryPlanCache)
+					.GetField("planCache", BindingFlags.Instance | BindingFlags.NonPublic)
+					.GetValue(Sfi.QueryPlanCache);
+
+			using (var session = OpenSession())
+			using (var tx = session.BeginTransaction())
+			{
+				using (driver.SubstituteCommand())
+				{
+					var query = queryFactory(session);
+					// Warm up.
+					await (RunBenchmarkUnitAsync(cache, query));
+
+					for (var j = 0; j < 1000; j++)
+					{
+						sw.Restart();
+						await (RunBenchmarkUnitAsync(cache, query));
+						sw.Stop();
+						timings.Add(sw.Elapsed.TotalMilliseconds);
+					}
+				}
+
+				await (tx.CommitAsync(cancellationToken));
+			}
+
+			var avg = timings.Average();
+			Console.WriteLine(
+				$"{test} average time: {avg}ms (s {Math.Sqrt(timings.Sum(t => Math.Pow(t - avg, 2)) / (timings.Count - 1))}ms)");
+		}
+
+		private static Task RunBenchmarkUnitAsync<T>(SoftLimitMRUCache cache, IQueryable<T> query)
+		{
+			try
+			{
+				// Do enough iterations for having a significant elapsed time in milliseconds.
+				for (var i = 0; i < 20; i++)
+				{
+					// Always clear the query plan cache before running the query, otherwise the impact of 1547
+					// change would be hidden by it. Simulates having many different queries run.
+					cache.Clear();
+					Assert.That(query.ToList, Throws.Nothing);
+				}
+				return Task.CompletedTask;
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
+		}
+	}
+
+	public partial class DriverForSubstitutedCommand : IDriver
+	{
+
+		#region Firebird mess
+
+		#endregion
+		#region Pure forwarding
+
+		#endregion
+
+		private partial class SubstituteDbCommand : DbCommand
+		{
+
+			protected override Task<DbDataReader> ExecuteDbDataReaderAsync(CommandBehavior behavior, CancellationToken cancellationToken)
+			{
+				try
+				{
+					return Task.FromResult<DbDataReader>(_substituteReader);
+				}
+				catch (Exception ex)
+				{
+					return Task.FromException<DbDataReader>(ex);
+				}
+			}
+
+			public override Task<int> ExecuteNonQueryAsync(CancellationToken cancellationToken)
+			{
+				return Task.FromResult<int>(0);
+			}
+
+			public override Task<object> ExecuteScalarAsync(CancellationToken cancellationToken)
+			{
+				return Task.FromResult<object>(null);
+			}
+
+			#region Pure forwarding
+
+			#endregion
+		}
+	}
+}
diff --git a/src/NHibernate.Test/NHSpecificTest/GH1547/Entity.cs b/src/NHibernate.Test/NHSpecificTest/GH1547/Entity.cs
new file mode 100644
index 00000000000..32477a1206d
--- /dev/null
+++ b/src/NHibernate.Test/NHSpecificTest/GH1547/Entity.cs
@@ -0,0 +1,10 @@
+using System;
+
+namespace NHibernate.Test.NHSpecificTest.GH1547
+{
+	class Entity
+	{
+		public virtual Guid Id { get; set; }
+		public virtual string Name { get; set; }
+	}
+}
diff --git a/src/NHibernate.Test/NHSpecificTest/GH1547/Fixture.cs b/src/NHibernate.Test/NHSpecificTest/GH1547/Fixture.cs
new file mode 100644
index 00000000000..5dc6705647b
--- /dev/null
+++ b/src/NHibernate.Test/NHSpecificTest/GH1547/Fixture.cs
@@ -0,0 +1,344 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Common;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using NHibernate.Cfg;
+using NHibernate.Driver;
+using NHibernate.Engine;
+using NHibernate.Engine.Query;
+using NHibernate.SqlCommand;
+using NHibernate.SqlTypes;
+using NHibernate.Util;
+using NSubstitute;
+using NUnit.Framework;
+
+namespace NHibernate.Test.NHSpecificTest.GH1547
+{
+	[TestFixture, Explicit("Contains only performances benchmark")]
+	public class Fixture : BugTestCase
+	{
+		protected override void Configure(Configuration configuration)
+		{
+			base.Configure(configuration);
+
+			var driverClass = ReflectHelper.ClassForName(configuration.GetProperty(Cfg.Environment.ConnectionDriver));
+			DriverForSubstitutedCommand.DriverClass = driverClass;
+
+			configuration.SetProperty(
+				Cfg.Environment.ConnectionDriver,
+				typeof(DriverForSubstitutedCommand).AssemblyQualifiedName);
+		}
+
+		protected override void DropSchema()
+		{
+			(Sfi.ConnectionProvider.Driver as DriverForSubstitutedCommand)?.CleanUp();
+			base.DropSchema();
+		}
+
+		[Test]
+		public void SimpleLinqPerf()
+		{
+			Benchmark(
+				"Simple LINQ",
+				s =>
+					s
+						.Query<Entity>()
+						.Where(e => e.Name == "Bob"));
+		}
+
+		[Test]
+		public void LinqWithNonParameterizedConstantPerf()
+		{
+			Benchmark(
+				"Non parameterized constant",
+				s =>
+					s
+						.Query<Entity>()
+						.Where(e => e.Name == "Bob")
+						.Select(e => new { e, c = 2 }));
+		}
+
+		[Test]
+		public void LinqWithListParameterPerf()
+		{
+			var names = new[] { "Bob", "Sally" };
+			Benchmark(
+				"List parameter",
+				s =>
+					s
+						.Query<Entity>()
+						.Where(e => names.Contains(e.Name)));
+		}
+
+		private void Benchmark<T>(string test, Func<ISession, IQueryable<T>> queryFactory)
+		{
+			var driver = (DriverForSubstitutedCommand) Sfi.ConnectionProvider.Driver;
+			var timings = new List<double>();
+			var sw = new Stopwatch();
+
+			var cache = (SoftLimitMRUCache)
+				typeof(QueryPlanCache)
+					.GetField("planCache", BindingFlags.Instance | BindingFlags.NonPublic)
+					.GetValue(Sfi.QueryPlanCache);
+
+			using (var session = OpenSession())
+			using (var tx = session.BeginTransaction())
+			{
+				using (driver.SubstituteCommand())
+				{
+					var query = queryFactory(session);
+					// Warm up.
+					RunBenchmarkUnit(cache, query);
+
+					for (var j = 0; j < 1000; j++)
+					{
+						sw.Restart();
+						RunBenchmarkUnit(cache, query);
+						sw.Stop();
+						timings.Add(sw.Elapsed.TotalMilliseconds);
+					}
+				}
+
+				tx.Commit();
+			}
+
+			var avg = timings.Average();
+			Console.WriteLine(
+				$"{test} average time: {avg}ms (s {Math.Sqrt(timings.Sum(t => Math.Pow(t - avg, 2)) / (timings.Count - 1))}ms)");
+		}
+
+		private static void RunBenchmarkUnit<T>(SoftLimitMRUCache cache, IQueryable<T> query)
+		{
+			// Do enough iterations for having a significant elapsed time in milliseconds.
+			for (var i = 0; i < 20; i++)
+			{
+				// Always clear the query plan cache before running the query, otherwise the impact of 1547
+				// change would be hidden by it. Simulates having many different queries run.
+				cache.Clear();
+				Assert.That(query.ToList, Throws.Nothing);
+			}
+		}
+	}
+
+	public partial class DriverForSubstitutedCommand : IDriver
+	{
+		internal static System.Type DriverClass { get; set; }
+
+		private readonly IDriver _driverImplementation;
+		private bool _commandSubstituted;
+
+		public DriverForSubstitutedCommand()
+		{
+			_driverImplementation = (IDriver) Cfg.Environment.BytecodeProvider.ObjectsFactory.CreateInstance(DriverClass);
+		}
+
+		DbCommand IDriver.GenerateCommand(CommandType type, SqlString sqlString, SqlType[] parameterTypes)
+		{
+			var cmd = _driverImplementation.GenerateCommand(type, sqlString, parameterTypes);
+			if (!_commandSubstituted)
+				return cmd;
+			return new SubstituteDbCommand(cmd);
+		}
+
+		public IDisposable SubstituteCommand()
+		{
+			_commandSubstituted = true;
+			return new EndSubstitute(this);
+		}
+
+		#region Firebird mess
+
+		public void CleanUp()
+		{
+			if (_driverImplementation is FirebirdClientDriver fbDriver)
+			{
+				// Firebird will pool each connection created during the test and will marked as used any table
+				// referenced by queries. It will at best delays those tables drop until connections are actually
+				// closed, or immediately fail dropping them.
+				// This results in other tests failing when they try to create tables with same name.
+				// By clearing the connection pool the tables will get dropped. This is done by the following code.
+				// Moved from NH1908 test case, contributed by Amro El-Fakharany.
+				fbDriver.ClearPool(null);
+			}
+		}
+
+		#endregion
+
+		#region Pure forwarding
+
+		DbParameter IDriver.GenerateParameter(DbCommand command, string name, SqlType sqlType)
+		{
+			return _driverImplementation.GenerateParameter(command, name, sqlType);
+		}
+
+		void IDriver.Configure(IDictionary<string, string> settings)
+		{
+			_driverImplementation.Configure(settings);
+		}
+
+		DbConnection IDriver.CreateConnection()
+		{
+			return _driverImplementation.CreateConnection();
+		}
+
+		bool IDriver.SupportsMultipleOpenReaders => _driverImplementation.SupportsMultipleOpenReaders;
+
+		void IDriver.PrepareCommand(DbCommand command)
+		{
+			_driverImplementation.PrepareCommand(command);
+		}
+
+		void IDriver.RemoveUnusedCommandParameters(DbCommand cmd, SqlString sqlString)
+		{
+			_driverImplementation.RemoveUnusedCommandParameters(cmd, sqlString);
+		}
+
+		void IDriver.ExpandQueryParameters(DbCommand cmd, SqlString sqlString, SqlType[] parameterTypes)
+		{
+			_driverImplementation.ExpandQueryParameters(cmd, sqlString, parameterTypes);
+		}
+
+		IResultSetsCommand IDriver.GetResultSetsCommand(ISessionImplementor session)
+		{
+			return _driverImplementation.GetResultSetsCommand(session);
+		}
+
+		bool IDriver.SupportsMultipleQueries => _driverImplementation.SupportsMultipleQueries;
+
+		void IDriver.AdjustCommand(DbCommand command)
+		{
+			_driverImplementation.AdjustCommand(command);
+		}
+
+		bool IDriver.RequiresTimeSpanForTime => _driverImplementation.RequiresTimeSpanForTime;
+
+		bool IDriver.SupportsSystemTransactions => _driverImplementation.SupportsSystemTransactions;
+
+		bool IDriver.SupportsNullEnlistment => _driverImplementation.SupportsNullEnlistment;
+
+		bool IDriver.SupportsEnlistmentWhenAutoEnlistmentIsDisabled =>
+			_driverImplementation.SupportsEnlistmentWhenAutoEnlistmentIsDisabled;
+
+		bool IDriver.HasDelayedDistributedTransactionCompletion =>
+			_driverImplementation.HasDelayedDistributedTransactionCompletion;
+
+		DateTime IDriver.MinDate => _driverImplementation.MinDate;
+
+		#endregion
+
+		private class EndSubstitute : IDisposable
+		{
+			private readonly DriverForSubstitutedCommand _driver;
+
+			public EndSubstitute(DriverForSubstitutedCommand driver)
+			{
+				_driver = driver;
+			}
+
+			public void Dispose()
+			{
+				_driver._commandSubstituted = false;
+			}
+		}
+
+		private partial class SubstituteDbCommand : DbCommand
+		{
+			private static readonly DbDataReader _substituteReader = Substitute.For<DbDataReader>();
+			private readonly DbCommand _concreteCommand;
+
+			public SubstituteDbCommand(DbCommand concreteCommand)
+			{
+				_concreteCommand = concreteCommand;
+			}
+
+			protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior)
+			{
+				return _substituteReader;
+			}
+
+			public override void Prepare()
+			{
+			}
+
+			public override int ExecuteNonQuery()
+			{
+				return 0;
+			}
+
+			public override object ExecuteScalar()
+			{
+				return null;
+			}
+
+			protected override void Dispose(bool disposing)
+			{
+				base.Dispose(disposing);
+				if (disposing)
+				{
+					_concreteCommand.Dispose();
+				}
+			}
+
+			#region Pure forwarding
+
+			public override string CommandText
+			{
+				get => _concreteCommand.CommandText;
+				set => _concreteCommand.CommandText = value;
+			}
+
+			public override int CommandTimeout
+			{
+				get => _concreteCommand.CommandTimeout;
+				set => _concreteCommand.CommandTimeout = value;
+			}
+
+			public override CommandType CommandType
+			{
+				get => _concreteCommand.CommandType;
+				set => _concreteCommand.CommandType = value;
+			}
+
+			public override UpdateRowSource UpdatedRowSource
+			{
+				get => _concreteCommand.UpdatedRowSource;
+				set => _concreteCommand.UpdatedRowSource = value;
+			}
+
+			protected override DbConnection DbConnection
+			{
+				get => _concreteCommand.Connection;
+				set => _concreteCommand.Connection = value;
+			}
+
+			protected override DbParameterCollection DbParameterCollection => _concreteCommand.Parameters;
+
+			protected override DbTransaction DbTransaction
+			{
+				get => _concreteCommand.Transaction;
+				set => _concreteCommand.Transaction = value;
+			}
+
+			public override bool DesignTimeVisible
+			{
+				get => _concreteCommand.DesignTimeVisible;
+				set => _concreteCommand.DesignTimeVisible = value;
+			}
+
+			public override void Cancel()
+			{
+				_concreteCommand.Cancel();
+			}
+
+			protected override DbParameter CreateDbParameter()
+			{
+				return _concreteCommand.CreateParameter();
+			}
+
+			#endregion
+		}
+	}
+}
diff --git a/src/NHibernate.Test/NHSpecificTest/GH1547/Mappings.hbm.xml b/src/NHibernate.Test/NHSpecificTest/GH1547/Mappings.hbm.xml
new file mode 100644
index 00000000000..1af20ef529a
--- /dev/null
+++ b/src/NHibernate.Test/NHSpecificTest/GH1547/Mappings.hbm.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="NHibernate.Test" namespace="NHibernate.Test.NHSpecificTest.GH1547">
+
+	<class name="Entity">
+		<id name="Id" generator="guid.comb" />
+		<property name="Name" />
+	</class>
+
+</hibernate-mapping>
diff --git a/src/NHibernate/Async/Impl/ExpressionQueryImpl.cs b/src/NHibernate/Async/Impl/ExpressionQueryImpl.cs
index eb721ab3c05..a0eb03f8f15 100644
--- a/src/NHibernate/Async/Impl/ExpressionQueryImpl.cs
+++ b/src/NHibernate/Async/Impl/ExpressionQueryImpl.cs
@@ -8,7 +8,6 @@
 //------------------------------------------------------------------------------
 
 
-using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
@@ -26,7 +25,7 @@ namespace NHibernate.Impl
 	using System.Threading.Tasks;
 	using System.Threading;
 
-	partial class ExpressionFilterImpl : ExpressionQueryImpl
+	internal partial class ExpressionFilterImpl : ExpressionQueryImpl
 	{
 
 		public override async Task<IList> ListAsync(CancellationToken cancellationToken = default(CancellationToken))
diff --git a/src/NHibernate/Impl/ExpressionQueryImpl.cs b/src/NHibernate/Impl/ExpressionQueryImpl.cs
index c4cce671ef4..b27380eb7f5 100644
--- a/src/NHibernate/Impl/ExpressionQueryImpl.cs
+++ b/src/NHibernate/Impl/ExpressionQueryImpl.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
@@ -21,8 +20,17 @@ public ExpressionQueryImpl(IQueryExpression queryExpression, ISessionImplementor
 			QueryExpression = queryExpression;
 		}
 
+		protected ExpressionQueryImpl(
+			IQueryExpression queryExpression, ISessionImplementor session, ParameterMetadata parameterMetadata, bool isFilter)
+			: this(queryExpression, session, parameterMetadata)
+		{
+			_isFilter = isFilter;
+		}
+
 		public IQueryExpression QueryExpression { get; private set; }
 
+		protected readonly bool _isFilter;
+
 		/// <summary> 
 		/// Warning: adds new parameters to the argument by side-effect, as well as mutating the query expression tree!
 		/// </summary>
@@ -74,11 +82,13 @@ protected override IQueryExpression ExpandParameters(IDictionary<string, TypedVa
 			}
 
 			//TODO: Do we need to translate expression one more time here?
-			var newTree = ParameterExpander.Expand(QueryExpression.Translate(Session.Factory, false), map);
+			// This is not much an issue anymore: ExpressionQueryImpl are currently created only with NhLinqExpression
+			// which do cache their translation.
+			var newTree = ParameterExpander.Expand(QueryExpression.Translate(Session.Factory, _isFilter), map);
 			var key = new StringBuilder(QueryExpression.Key);
 
 			foreach (var pair in map)
-							   {
+			{
 				key.Append(' ');
 				key.Append(pair.Key);
 				key.Append(':');
@@ -90,12 +100,12 @@ protected override IQueryExpression ExpandParameters(IDictionary<string, TypedVa
 		}
 	}
 
-	partial class ExpressionFilterImpl : ExpressionQueryImpl
+	internal partial class ExpressionFilterImpl : ExpressionQueryImpl
 	{
 		private readonly object collection;
 
 		public ExpressionFilterImpl(IQueryExpression queryExpression, object collection, ISessionImplementor session, ParameterMetadata parameterMetadata) 
-			: base(queryExpression, session, parameterMetadata)
+			: base(queryExpression, session, parameterMetadata, true)
 		{
 			this.collection = collection;
 		}
diff --git a/src/NHibernate/Linq/NhLinqExpression.cs b/src/NHibernate/Linq/NhLinqExpression.cs
index 5b9f20fccbe..50ec325c47f 100644
--- a/src/NHibernate/Linq/NhLinqExpression.cs
+++ b/src/NHibernate/Linq/NhLinqExpression.cs
@@ -68,6 +68,14 @@ public NhLinqExpression(Expression expression, ISessionFactoryImplementor sessio
 
 		public IASTNode Translate(ISessionFactoryImplementor sessionFactory, bool filter)
 		{
+			if (ExpressionToHqlTranslationResults != null)
+			{
+				// Query has already been translated. Arguments do not really matter, because queries are anyway tied
+				// to a single session factory and cannot switch from being a filter query (query on a mapped collection)
+				// or not.
+				return DuplicateTree(ExpressionToHqlTranslationResults.Statement.AstNode);
+			}
+
 			var requiredHqlParameters = new List<NamedParameterDescriptor>();
 			var queryModel = NhRelinqQueryParser.Parse(_expression);
 			var visitorParameters = new VisitorParameters(sessionFactory, _constantToParameterMap, requiredHqlParameters,
@@ -88,7 +96,8 @@ public IASTNode Translate(ISessionFactoryImplementor sessionFactory, bool filter
 					.Except(requiredHqlParameters.Select(p => p.Name))
 					.Any();
 
-			return ExpressionToHqlTranslationResults.Statement.AstNode;
+			// The ast node may be altered by caller, duplicate it for preserving the original one.
+			return DuplicateTree(ExpressionToHqlTranslationResults.Statement.AstNode);
 		}
 
 		internal void CopyExpressionTranslation(NhLinqExpression other)
@@ -98,5 +107,15 @@ internal void CopyExpressionTranslation(NhLinqExpression other)
 			// Type could have been overridden by translation.
 			Type = other.Type;
 		}
+
+		private static IASTNode DuplicateTree(IASTNode ast)
+		{
+			var thisNode = ast.DupNode();
+			foreach (var child in ast)
+			{
+				thisNode.AddChild(DuplicateTree(child));
+			}
+			return thisNode;
+		}
 	}
 }