Merge branch 'master' into TypedValue

Author: fredericDelaporte

build-common/NHibernate.props

@@ -10,6 +10,9 @@
     <AssemblyVersion>$(VersionMajor).$(VersionMinor).0.0</AssemblyVersion>
     <FileVersion>$(VersionPrefix).0</FileVersion>
 
+    <NhAppTargetFrameworks>net461;netcoreapp2.0</NhAppTargetFrameworks>
+    <NhLibTargetFrameworks>net461;netcoreapp2.0;netstandard2.0</NhLibTargetFrameworks>
+
     <Product>NHibernate</Product>
     <Company>NHibernate.info</Company>
     <Copyright>Licensed under LGPL.</Copyright>

doc/reference/modules/performance.xml

@@ -235,20 +235,20 @@ int accessLevel = permissions["accounts"];  // Error!]]></programlisting>
                 <literal>left join fetch</literal> in HQL. This tells NHibernate to fetch 
                 the association eagerly in the first select, using an outer join. In the
                 <literal>ICriteria</literal> query API, you would use
-                <literal>SetFetchMode(FetchMode.Join)</literal>.
+                <literal>Fetch()</literal>.
             </para>
 
             <para>
                 If you ever feel like you wish you could change the fetching strategy used by
                 <literal>Get()</literal> or <literal>Load()</literal>, simply use a 
                 <literal>ICriteria</literal> query, for example:
             </para>
-            
+
             <programlisting><![CDATA[User user = session.CreateCriteria(typeof(User))
-    .SetFetchMode("Permissions", FetchMode.Join)
+    .Fetch(SelectMode.Fetch, "Permissions")
     .Add( Expression.Eq("Id", userId) )
     .UniqueResult<User>();]]></programlisting>
-                
+
             <para>
                 (This is NHibernate's equivalent of what some <emphasis>ORM</emphasis> solutions call a "fetch plan".)
             </para>
@@ -475,7 +475,7 @@ using(var iter = session
                         <literal>NHibernateUtil.Initialize()</literal> for each collection that will
                         be needed in the web tier (this call must occur before the session is closed)
                         or retrieves the collection eagerly using a NHibernate query with a
-                        <literal>FETCH</literal> clause or a <literal>FetchMode.Join</literal> in
+                        <literal>FETCH</literal> clause or a <literal>SelectMode.Fetch</literal> in
                         <literal>ICriteria</literal>. This is usually easier if you adopt the
                         <emphasis>Command</emphasis> pattern instead of a <emphasis>Session Facade</emphasis>.
                     </para>

doc/reference/modules/query_criteria.xml

@@ -175,13 +175,13 @@ foreach ( IDictionary map in cats )
 
         <para>
             You may specify association fetching semantics at runtime using
-            <literal>SetFetchMode()</literal>.
+            <literal>Fetch()</literal>.
         </para>
 
         <programlisting><![CDATA[var cats = sess.CreateCriteria<Cat>()
     .Add( Expression.Like("Name", "Fritz%") )
-    .SetFetchMode("Mate", FetchMode.Eager)
-    .SetFetchMode("Kittens", FetchMode.Eager)
+    .Fetch(SelectMode.Fetch, "Mate")
+    .Fetch(SelectMode.Fetch, "Kittens")
     .List<Cat>();]]></programlisting>
 
         <para>

src/NHibernate.DomainModel/NHibernate.DomainModel.csproj

@@ -2,7 +2,7 @@
   <Import Project="../../build-common/NHibernate.props" />
   <PropertyGroup>
     <Description>The Domain Model used by the Unit Tests.</Description>
-    <TargetFrameworks>netstandard2.0;net461;netcoreapp2.0</TargetFrameworks>
+    <TargetFrameworks>$(NhLibTargetFrameworks)</TargetFrameworks>
     <IsTestProject>true</IsTestProject>
     <NoWarn>$(NoWarn);3001;3002;3003;3005</NoWarn>
   </PropertyGroup>

src/NHibernate.Test.VisualBasic/NHibernate.Test.VisualBasic.vbproj

@@ -2,7 +2,7 @@
   <Import Project="../../build-common/NHibernate.props" />
   <PropertyGroup>
     <Description>The Visual Basic Unit Tests for NHibernate.</Description>
-    <TargetFrameworks>net461;netcoreapp2.0</TargetFrameworks>
+    <TargetFrameworks>$(NhAppTargetFrameworks)</TargetFrameworks>
     <IsTestProject>true</IsTestProject>
     <NoWarn>$(NoWarn);3001;3002;3003;3005</NoWarn>
     <OptionExplicit>On</OptionExplicit>

src/NHibernate.Test/Async/CfgTest/LoadMemoryOnlyAssembyTest.cs

@@ -0,0 +1,155 @@
+//------------------------------------------------------------------------------
+// <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 NUnit.Framework;
+using System.CodeDom.Compiler;
+using System.Linq;
+using Microsoft.CSharp;
+using System.Reflection;
+using NHibernate.Engine;
+using NHibernate.Mapping.ByCode;
+using NHibernate.Tool.hbm2ddl;
+
+namespace NHibernate.Test.CfgTest
+{
+	using System.Threading.Tasks;
+	[TestFixture]
+	public class LoadMemoryOnlyAssembyTestAsync
+	{
+		[Test]
+		public async Task CompileMappingForDynamicInMemoryAssemblyAsync()
+		{
+			const int assemblyGenerateCount = 10;
+			var code = GenerateCode(assemblyGenerateCount);
+			var assembly = CompileAssembly(code);
+
+			var config = TestConfigurationHelper.GetDefaultConfiguration();
+			var mapper = new ModelMapper();
+			mapper.AddMappings(assembly.GetExportedTypes());
+			config.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());
+
+			Assert.That(config.ClassMappings, Has.Count.EqualTo(assemblyGenerateCount), "Not all virtual assembly mapped");
+
+			// Ascertain the mappings are usable.
+			using (var sf = config.BuildSessionFactory())
+			{
+				var se = new SchemaExport(config);
+				await (se.CreateAsync(false, true));
+				try
+				{
+					using (var s = sf.OpenSession())
+					using (var tx = s.BeginTransaction())
+					{
+						foreach (var entityClass in assembly.GetExportedTypes()
+						                                    .Where(t => !typeof(IConformistHoldersProvider).IsAssignableFrom(t)))
+						{
+							var ctor = entityClass.GetConstructor(Array.Empty<System.Type>());
+							Assert.That(ctor, Is.Not.Null, $"Default constructor for {entityClass} not found");
+							var entity = ctor.Invoke(Array.Empty<object>());
+							await (s.SaveAsync(entity));
+						}
+
+						await (tx.CommitAsync());
+					}
+
+					using (var s = sf.OpenSession())
+					using (var tx = s.BeginTransaction())
+					{
+						var entities = await (s.CreateQuery("from System.Object").ListAsync<object>());
+						Assert.That(entities, Has.Count.EqualTo(assemblyGenerateCount), "Not all expected entities were persisted");
+
+						await (tx.CommitAsync());
+					}
+				}
+				finally
+				{
+					TestCase.DropSchema(false, se, (ISessionFactoryImplementor) sf);
+				}
+			}
+		}
+
+		private static string[] GenerateCode(int assemblyCount)
+		{
+			const string codeTemplate = @"
+using NHibernate.Mapping.ByCode.Conformist;
+
+public class Entity$$INDEX$$
+{
+	public virtual int ID { get; set; }
+	public virtual string Name { get; set; }
+}
+
+public class Entity$$INDEX$$Map : ClassMapping<Entity$$INDEX$$>
+{
+	public Entity$$INDEX$$Map () 
+	{
+		Table(""Entity$$INDEX$$"");
+
+		Id(x => x.ID, m =>
+		{
+			m.Column(""`ID`"");
+		});
+
+		Property(x => x.Name, m =>
+		{
+			m.Column(""`Name`"");
+		});
+	}
+}";
+			var code = new string[assemblyCount];
+			for (var i = 0; i < code.Length; i++)
+				code[i] = codeTemplate.Replace("$$INDEX$$", i.ToString("000"));
+			return code;
+		}
+
+		private static Assembly CompileAssembly(string[] code)
+		{
+			var parameters = new CompilerParameters
+			{
+				GenerateInMemory = true,
+				TreatWarningsAsErrors = false,
+				GenerateExecutable = false,
+				CompilerOptions = "/optimize"
+			};
+			parameters.ReferencedAssemblies.AddRange(
+				new[]
+				{
+					"System.dll",
+					"System.Core.dll",
+					"System.Data.dll",
+					new Uri(typeof(Cfg.Environment).Assembly.EscapedCodeBase).LocalPath
+				});
+
+			try
+			{
+				using (var provider = new CSharpCodeProvider())
+				{
+					var compile = provider.CompileAssemblyFromSource(parameters, code);
+
+					if (compile.Errors.HasErrors)
+					{
+						var text = "Compile error: " +
+						           string.Join(System.Environment.NewLine, compile.Errors.Cast<CompilerError>());
+
+						Assert.Fail(text);
+					}
+
+					return compile.CompiledAssembly;
+				}
+			}
+			catch (PlatformNotSupportedException e)
+			{
+				Assert.Inconclusive(e.Message);
+				return null;
+			}
+		}
+	}
+}

src/NHibernate.Test/Async/Criteria/CriteriaQueryTest.cs

@@ -1089,7 +1089,7 @@ public async Task ProjectionsTestAsync()
 
 			object g = await (s.CreateCriteria(typeof(Student))
 				.Add(Expression.IdEq(667L))
-				.SetFetchMode("enrolments", FetchMode.Join)
+				.Fetch("enrolments")
 				//.setFetchMode("enrolments.course", FetchMode.JOIN) //TODO: would love to make that work...
 				.UniqueResultAsync());
 			Assert.AreSame(gavin, g);
@@ -1279,7 +1279,7 @@ public async Task CloningProjectionsTestAsync()
 
 			ICriteria criteriaToClone6 = s.CreateCriteria(typeof(Student))
 				.Add(Expression.IdEq(667L))
-				.SetFetchMode("enrolments", FetchMode.Join);
+				.Fetch("enrolments");
 			object g = await (CriteriaTransformer.Clone(criteriaToClone6)
 				.UniqueResultAsync());
 			Assert.AreSame(gavin, g);
@@ -2426,7 +2426,7 @@ public async Task SubcriteriaJoinTypesAsync()
 			}
 
 			result = await (session.CreateCriteria(typeof(Student))
-				.SetFetchMode("PreferredCourse", FetchMode.Join)
+				.Fetch("PreferredCourse")
 				.CreateCriteria("PreferredCourse", JoinType.LeftOuterJoin)
 				.AddOrder(Order.Asc("CourseCode"))
 				.ListAsync());
@@ -2436,7 +2436,7 @@ public async Task SubcriteriaJoinTypesAsync()
 			Assert.IsNotNull(result[2]);
 
 			result = await (session.CreateCriteria(typeof(Student))
-				.SetFetchMode("PreferredCourse", FetchMode.Join)
+				.Fetch("PreferredCourse")
 				.CreateAlias("PreferredCourse", "pc", JoinType.LeftOuterJoin)
 				.AddOrder(Order.Asc("pc.CourseCode"))
 				.ListAsync());

src/NHibernate.Test/Async/Criteria/EntityProjectionsTest.cs

@@ -228,6 +228,26 @@ public async Task EntityProjectionAsSelectExpressionAsync()
 				Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
 			}
 		}
+		
+		[Test]
+		public async Task EntityProjectionAsSelectExpressionForArgumentAliasAsync()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			using (var session = OpenSession())
+			{
+				EntitySimpleChild child1 = null;
+				var complex = await (session
+					.QueryOver<EntityComplex>()
+					.JoinAlias(ep => ep.Child1, () => child1)
+					.Select(ec => ec.AsEntity())
+					.Take(1).SingleOrDefaultAsync());
+
+				Assert.That(complex, Is.Not.Null);
+				Assert.That(NHibernateUtil.IsInitialized(complex), Is.True, "Object must be initialized");
+				Assert.That(NHibernateUtil.IsInitialized(complex.Child1), Is.False, "Object must be lazy");
+				Assert.That(sqlLog.Appender.GetEvents().Length, Is.EqualTo(1), "Only one SQL select is expected");
+			}
+		}
 
 		[Test]
 		public async Task EntityProjectionLockModeAsync()

src/NHibernate.Test/Async/Criteria/Lambda/IntegrationFixture.cs

@@ -290,7 +290,7 @@ public async Task OverrideEagerJoinAsync()
 			{
 				var persons =
 					await (s.QueryOver<Parent>()
-						.Fetch(p => p.Children).Lazy
+						.Fetch(SelectMode.Skip, p => p.Children)
 						.ListAsync());
 
 				Assert.That(persons.Count, Is.EqualTo(1));