NH-3435

src/NHibernate.Test/Criteria/ProjectionsTest.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using NHibernate.Criterion;
 using NHibernate.Dialect;
+using NHibernate.SqlCommand;
 using NUnit.Framework;
 
 namespace NHibernate.Test.Criteria
@@ -347,6 +348,82 @@ public void UseNotEqPropertyWithProjection()
 			}
 		}
 
+		[Test]
+		public void UseRootProjection()
+		{
+			//NH-3435
+			using (ISession session = sessions.OpenSession())
+			using (ITransaction tx = session.BeginTransaction())
+			{
+				Course course = new Course();
+				course.CourseCode = "HIB";
+				course.Description = "Hibernate Training";
+				session.Save(course);
+
+				Student gavin = new Student();
+				gavin.Name = "Gavin King";
+				gavin.StudentNumber = 667;
+				session.Save(gavin);
+
+				Enrolment enrolment = new Enrolment();
+				enrolment.Course = course;
+				enrolment.CourseCode = course.CourseCode;
+				enrolment.Semester = 1;
+				enrolment.Year = 1999;
+				enrolment.Student = gavin;
+				enrolment.StudentNumber = gavin.StudentNumber;
+				gavin.Enrolments.Add(enrolment);
+				session.Save(enrolment);
+
+				session.Flush();
+
+				Student g = session.CreateCriteria(typeof(Student))
+					.Add(Expression.IdEq(gavin.StudentNumber))
+					.SetFetchMode("Enrolments", FetchMode.Join)
+					.SetProjection(Projections.RootEntity())
+					.UniqueResult<Student>();
+
+				Assert.AreSame(gavin, g);
+			}
+		}
 
+		[Test]
+		public void UseEntityProjection()
+		{
+			//NH-3435
+			using (ISession session = sessions.OpenSession())
+			using (ITransaction tx = session.BeginTransaction())
+			{
+				Course course = new Course();
+				course.CourseCode = "HIB";
+				course.Description = "Hibernate Training";
+				session.Save(course);
+
+				Student gavin = new Student();
+				gavin.Name = "Gavin King";
+				gavin.StudentNumber = 667;
+				session.Save(gavin);
+
+				Enrolment enrolment = new Enrolment();
+				enrolment.Course = course;
+				enrolment.CourseCode = course.CourseCode;
+				enrolment.Semester = 1;
+				enrolment.Year = 1999;
+				enrolment.Student = gavin;
+				enrolment.StudentNumber = gavin.StudentNumber;
+				gavin.Enrolments.Add(enrolment);
+				session.Save(enrolment);
+
+				session.Flush();
+
+				Student g = session.CreateCriteria(typeof(Enrolment))
+					.Add(Expression.And(Expression.Eq("StudentNumber", gavin.StudentNumber), Expression.Eq("CourseCode", course.CourseCode)))
+					.CreateAlias("Student", "s", JoinType.InnerJoin)
+					.SetProjection(Projections.Entity<Student>("s"))
+					.UniqueResult<Student>();
+
+				Assert.AreSame(gavin, g);
+			}
+		}
 	}
 }

src/NHibernate.Test/Linq/QueryAsReadOnlyTests.cs

@@ -0,0 +1,35 @@
+using System.Linq;
+using NHibernate.AdoNet;
+using NHibernate.Cfg;
+using NHibernate.Engine;
+using NHibernate.Linq;
+using NUnit.Framework;
+
+namespace NHibernate.Test.Linq
+{
+	public class QueryAsReadOnlyTests : LinqTestCase
+	{
+		[Test]
+		public void CanSetReadOnlyOnSimpeLinqQueries()
+		{
+			//NH-3658
+			var result = (from e in db.Customers
+						  where e.CompanyName == "Corp"
+						  select e).AsReadOnly().ToList();
+
+			Assert.IsTrue(result.All(x => session.IsReadOnly(x)));
+		}
+
+		[Test]
+		public void CanSetReadOnlyOnComplexLinqQueries()
+		{
+			//NH-3658
+			var result = (from e in db.Customers
+						  where e.CompanyName == "Corp"
+						  orderby e.ContactName
+						  select e).Skip(1).Take(10).AsReadOnly().ToList();
+
+			Assert.IsTrue(result.All(x => session.IsReadOnly(x)));
+		}
+	}
+}

src/NHibernate.Test/NHibernate.Test.csproj

@@ -519,6 +519,7 @@
     <Compile Include="Linq\DateTimeTests.cs" />
     <Compile Include="Linq\ExpressionSessionLeakTest.cs" />
     <Compile Include="Linq\LoggingTests.cs" />
+    <Compile Include="Linq\QueryAsReadOnlyTests.cs" />
     <Compile Include="Linq\QueryTimeoutTests.cs" />
     <Compile Include="Linq\JoinTests.cs" />
     <Compile Include="Linq\CustomExtensionsExample.cs" />
@@ -529,7 +530,7 @@
     <Compile Include="Linq\ExtensionMethods.cs" />
     <Compile Include="Linq\FunctionTests.cs" />
     <Compile Include="Linq\LinqQuerySamples.cs" />
-    <Compile Include="Linq\LinqReadonlyTestsContext.cs" />
+    <Compile Include="Linq\LinqReadOnlyTestsContext.cs" />
     <Compile Include="Linq\LinqTestCase.cs" />
     <Compile Include="Linq\LinqToHqlGeneratorsRegistryFactoryTest.cs" />
     <Compile Include="Linq\MethodCallTests.cs" />
@@ -3630,4 +3631,4 @@ if exist hibernate.cfg.xml (del hibernate.cfg.xml)
 if exist "$(ProjectDir)hibernate.cfg.xml" (copy "$(ProjectDir)hibernate.cfg.xml" "hibernate.cfg.xml")
 copy /y "..\..\..\NHibernate.DomainModel\ABC.hbm.xml" "ABC.hbm.xml"</PostBuildEvent>
   </PropertyGroup>
-</Project>
+</Project>

src/NHibernate.TestDatabaseSetup/NHibernate.TestDatabaseSetup.csproj

@@ -58,6 +58,9 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Microsoft.Data.Services">
+      <HintPath>..\..\lib\net\Microsoft.Data.Services.dll</HintPath>
+    </Reference>
     <Reference Include="FirebirdSql.Data.FirebirdClient">
       <HintPath>..\..\lib\teamcity\firebird\FirebirdSql.Data.FirebirdClient.dll</HintPath>
     </Reference>

src/NHibernate.TestDatabaseSetup/TestDatabaseSetup.build

@@ -22,6 +22,7 @@
 			<include name="FirebirdSql.Data.FirebirdClient.dll" />
 			<include name="System.Data.SqlServerCe.dll" />
 			<include name="Npgsql.dll" />
+			<include name="Microsoft.Data.Services.dll" />
 		</assemblyfileset>
 	</target>
 	<target name="generate-assemblyinfo" depends="init common.generate-assemblyinfo" />

src/NHibernate/Criterion/BaseEntityProjection.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NHibernate;
+using NHibernate.Criterion;
+using NHibernate.Engine;
+using NHibernate.Persister.Entity;
+using NHibernate.SqlCommand;
+using NHibernate.Type;
+
+namespace NHibernate.Criterion
+{
+	[Serializable]
+	public abstract class BaseEntityProjection : IProjection
+	{
+		private string alias = null;
+		private string [] columnAliases = null;
+		private bool lazy = true;
+
+		protected BaseEntityProjection(System.Type rootEntity, string alias)
+		{
+			this.RootEntity = rootEntity;
+			this.alias = alias;
+		}
+
+		protected System.Type RootEntity
+		{
+			get;
+			private set;
+		}
+
+		public BaseEntityProjection SetLazy(bool lazy)
+		{
+			this.lazy = lazy;
+
+			return (this);
+		}
+
+		string[] IProjection.Aliases
+		{
+			get
+			{
+				return (this.columnAliases.ToArray());
+			}
+		}
+
+		TypedValue[] IProjection.GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
+		{
+			throw new NotImplementedException();
+		}
+
+		IType[] IProjection.GetTypes(string alias, ICriteria criteria, ICriteriaQuery criteriaQuery)
+		{
+			return (new IType[] { criteriaQuery.GetType(criteria, alias) });
+		}
+
+		private void SetFields(ICriteria criteria)
+		{
+			if (this.RootEntity == null)
+			{
+				this.RootEntity = criteria.GetRootEntityTypeIfAvailable();
+			}
+
+			if (this.alias == null)
+			{
+				this.alias = criteria.Alias;
+			}
+		}
+
+		IType[] IProjection.GetTypes(ICriteria criteria, ICriteriaQuery criteriaQuery)
+		{
+			this.SetFields(criteria);
+
+			return (new IType[] { new ManyToOneType(this.RootEntity.FullName, this.lazy) });
+		}
+
+		bool IProjection.IsAggregate
+		{
+			get { return (false); }
+		}
+
+		bool IProjection.IsGrouped
+		{
+			get { return (false); }
+		}
+
+		SqlString IProjection.ToGroupSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
+		{
+			throw new NotImplementedException();
+		}
+
+		SqlString IProjection.ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
+		{
+			this.SetFields(criteria);
+
+			SqlStringBuilder builder = new SqlStringBuilder();
+			AbstractEntityPersister persister = criteriaQuery.Factory.TryGetEntityPersister(this.RootEntity.FullName) as AbstractEntityPersister;
+			ICriteria subcriteria = criteria.GetCriteriaByAlias(this.alias);
+
+			this.columnAliases = persister.GetIdentifierAliases(string.Empty);
+
+			string[] columnNames = persister.GetPropertyColumnNames(persister.IdentifierPropertyName).Select(x => string.Concat(criteriaQuery.GetSQLAlias(subcriteria, persister.IdentifierPropertyName), ".", criteriaQuery.Factory.Dialect.QuoteForColumnName(x))).ToArray();
+
+			for (int i = 0; i < columnNames.Length; ++i)
+			{
+				builder.Add(String.Format("{0} as {1}", columnNames[i], this.columnAliases[i]));
+
+				if (i < columnNames.Length - 1)
+				{
+					builder.Add(", ");
+				}
+			}
+
+			return (builder.ToSqlString());
+		}
+
+		public string[] GetColumnAliases(int position, ICriteria criteria, ICriteriaQuery criteriaQuery)
+		{
+			return ((this as IProjection).Aliases);
+		}
+
+		public string[] GetColumnAliases(string alias, int position, ICriteria criteria, ICriteriaQuery criteriaQuery)
+		{
+			return ((this as IProjection).Aliases);
+		}
+	}
+}

src/NHibernate/Criterion/EntityProjection.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace NHibernate.Criterion
+{
+	[Serializable]
+	public class EntityProjection : BaseEntityProjection
+	{
+		public EntityProjection(System.Type rootEntity, String alias) : base(rootEntity, alias)
+		{
+		}
+	}
+
+	[Serializable]
+	public class EntityProjection<T> : EntityProjection
+	{
+		public EntityProjection(String alias) : base(typeof(T), alias)
+		{
+		}
+	}
+}

src/NHibernate/Criterion/Projections.cs

@@ -16,6 +16,31 @@ namespace NHibernate.Criterion
 	/// </summary>
 	public static class Projections
 	{
+		/// <summary>
+		/// Return the root entity.
+		/// </summary>
+		/// <returns>The root entity.</returns>
+		public static IProjection RootEntity()
+		{
+			return (new RootEntityProjection());
+		}
+
+		/// <summary>
+		/// Return an aliased entity.
+		/// </summary>
+		/// <param name="type">The type of the entity.</param>
+		/// <param name="alias">The alias of the entity.</param>
+		/// <returns>A projection of the entity.</returns>
+		public static IProjection Entity(System.Type type, string alias)
+		{
+			return (new EntityProjection(type, alias));
+		}
+
+		public static IProjection Entity<T>(string alias)
+		{
+			return (new EntityProjection<T>(alias));
+		}
+
 		/// <summary>
 		/// Create a distinct projection from a projection
 		/// </summary>

src/NHibernate/Criterion/RootEntityProjection.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace NHibernate.Criterion
+{
+	[Serializable]
+	public class RootEntityProjection : BaseEntityProjection
+	{
+		public RootEntityProjection() : base(null, null)
+		{
+		}
+	}
+}

src/NHibernate/Linq/GroupBy/AggregatingGroupByRewriter.cs

@@ -38,6 +38,7 @@ public static class AggregatingGroupByRewriter
 				typeof (AnyResultOperator),
 				typeof (AllResultOperator),
 				typeof (TimeoutResultOperator),
+				typeof (AsReadOnlyResultOperator),
 			};
 
 		public static void ReWrite(QueryModel queryModel)

src/NHibernate/Linq/LinqExtensionMethods.cs

@@ -20,6 +20,15 @@ public static IQueryable<T> Query<T>(this IStatelessSession session)
 			return new NhQueryable<T>(session.GetSessionImplementation());
 		}
 
+		public static IQueryable<T> AsReadOnly<T>(this IQueryable<T> query)
+		{
+			var method = ReflectionHelper.GetMethodDefinition(() => AsReadOnly<object>(null)).MakeGenericMethod(typeof(T));
+
+			var callExpression = Expression.Call(method, query.Expression);
+
+			return new NhQueryable<T>(query.Provider, callExpression);
+		}
+
 		public static IQueryable<T> Cacheable<T>(this IQueryable<T> query)
 		{
 			var method = ReflectionHelper.GetMethodDefinition(() => Cacheable<object>(null)).MakeGenericMethod(typeof (T));