Menu
▾
▴
[Nhibernate-commit] SF.net SVN: nhibernate:[5544] trunk/nhibernate/src/NHibernate
|
From: <ric...@us...> - 2011-03-26 18:52:00
|
Revision: 5544
http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5544&view=rev
Author: ricbrown
Date: 2011-03-26 18:51:53 +0000 (Sat, 26 Mar 2011)
Log Message:
-----------
NH-2592 (Add ICriteria functionality missing in QueryOver) - added overloads for on-clause in left joins
Modified Paths:
--------------
trunk/nhibernate/src/NHibernate/Criterion/DetachedCriteria.cs
trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverJoinBuilder.cs
trunk/nhibernate/src/NHibernate/Criterion/QueryOver.cs
trunk/nhibernate/src/NHibernate/IQueryOver.cs
trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/IntegrationFixture.cs
trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/QueryOverFixture.cs
Modified: trunk/nhibernate/src/NHibernate/Criterion/DetachedCriteria.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/DetachedCriteria.cs 2011-03-26 18:27:30 UTC (rev 5543)
+++ trunk/nhibernate/src/NHibernate/Criterion/DetachedCriteria.cs 2011-03-26 18:51:53 UTC (rev 5544)
@@ -155,6 +155,11 @@
return new DetachedCriteria(impl, criteria.CreateCriteria(associationPath, alias, joinType));
}
+ public DetachedCriteria CreateCriteria(string associationPath, string alias, JoinType joinType, ICriterion withClause)
+ {
+ return new DetachedCriteria(impl, criteria.CreateCriteria(associationPath, alias, joinType, withClause));
+ }
+
public string Alias
{
get { return criteria.Alias; }
Modified: trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverJoinBuilder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverJoinBuilder.cs 2011-03-26 18:27:30 UTC (rev 5543)
+++ trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverJoinBuilder.cs 2011-03-26 18:51:53 UTC (rev 5544)
@@ -28,11 +28,41 @@
return root.JoinQueryOver<U>(path, alias, joinType);
}
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, Expression<Func<U,bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, Expression<Func<bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, ICriterion withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, withClause);
+ }
+
public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias)
{
return root.JoinQueryOver<U>(path, alias, joinType);
}
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias, Expression<Func<U,bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias, Expression<Func<bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias, ICriterion withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, withClause);
+ }
+
public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path)
{
return root.JoinQueryOver<U>(path, joinType);
@@ -48,11 +78,41 @@
return root.JoinQueryOver<U>(path, alias, joinType);
}
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, Expression<Func<U,bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, Expression<Func<bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, ICriterion withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, withClause);
+ }
+
public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias)
{
return root.JoinQueryOver<U>(path, alias, joinType);
}
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, Expression<Func<U,bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, Expression<Func<bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, ICriterion withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, withClause);
+ }
+
}
public class IQueryOverJoinBuilder<TRoot,TSubType> : QueryOverJoinBuilderBase<IQueryOver<TRoot,TSubType>, TRoot, TSubType>
@@ -74,11 +134,41 @@
return root.JoinQueryOver<U>(path, alias, joinType);
}
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, Expression<Func<U,bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, Expression<Func<bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, ICriterion withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, withClause);
+ }
+
public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias)
{
return root.JoinQueryOver<U>(path, alias, joinType);
}
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias, Expression<Func<U,bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias, Expression<Func<bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias, ICriterion withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, withClause);
+ }
+
public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path)
{
return root.JoinQueryOver<U>(path, joinType);
@@ -94,11 +184,41 @@
return root.JoinQueryOver<U>(path, alias, joinType);
}
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, Expression<Func<U,bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, Expression<Func<bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, ICriterion withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, withClause);
+ }
+
public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias)
{
return root.JoinQueryOver<U>(path, alias, joinType);
}
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, Expression<Func<U,bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, Expression<Func<bool>> withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, ICriterion withClause)
+ {
+ return root.JoinQueryOver<U>(path, alias, joinType, withClause);
+ }
+
}
public class QueryOverJoinBuilderBase<TReturn, TRoot, TSubType> where TReturn : IQueryOver<TRoot,TSubType>
@@ -118,11 +238,71 @@
return (TReturn)root.JoinAlias(path, alias, joinType);
}
+ public TReturn JoinAlias<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, Expression<Func<U,bool>> withClause)
+ {
+ return (TReturn)root.JoinAlias(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public TReturn JoinAlias<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, Expression<Func<bool>> withClause)
+ {
+ return (TReturn)root.JoinAlias(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public TReturn JoinAlias<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, ICriterion withClause)
+ {
+ return (TReturn)root.JoinAlias(path, alias, joinType, withClause);
+ }
+
+ public TReturn JoinAlias<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, Expression<Func<U,bool>> withClause)
+ {
+ return (TReturn)root.JoinAlias(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public TReturn JoinAlias<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, Expression<Func<bool>> withClause)
+ {
+ return (TReturn)root.JoinAlias(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public TReturn JoinAlias<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, ICriterion withClause)
+ {
+ return (TReturn)root.JoinAlias(path, alias, joinType, withClause);
+ }
+
public TReturn JoinAlias(Expression<Func<object>> path, Expression<Func<object>> alias)
{
return (TReturn)root.JoinAlias(path, alias, joinType);
}
+ public TReturn JoinAlias<U>(Expression<Func<U>> path, Expression<Func<U>> alias, Expression<Func<U,bool>> withClause)
+ {
+ return (TReturn)root.JoinAlias(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public TReturn JoinAlias<U>(Expression<Func<U>> path, Expression<Func<U>> alias, Expression<Func<bool>> withClause)
+ {
+ return (TReturn)root.JoinAlias(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public TReturn JoinAlias<U>(Expression<Func<U>> path, Expression<Func<U>> alias, ICriterion withClause)
+ {
+ return (TReturn)root.JoinAlias(path, alias, joinType, withClause);
+ }
+
+ public TReturn JoinAlias<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, Expression<Func<U,bool>> withClause)
+ {
+ return (TReturn)root.JoinAlias(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public TReturn JoinAlias<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, Expression<Func<bool>> withClause)
+ {
+ return (TReturn)root.JoinAlias(path, alias, joinType, ExpressionProcessor.ProcessExpression(withClause));
+ }
+
+ public TReturn JoinAlias<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, ICriterion withClause)
+ {
+ return (TReturn)root.JoinAlias(path, alias, joinType, withClause);
+ }
+
}
}
Modified: trunk/nhibernate/src/NHibernate/Criterion/QueryOver.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/QueryOver.cs 2011-03-26 18:27:30 UTC (rev 5543)
+++ trunk/nhibernate/src/NHibernate/Criterion/QueryOver.cs 2011-03-26 18:51:53 UTC (rev 5544)
@@ -182,6 +182,12 @@
return this;
}
+ private QueryOver<TRoot> ReadOnly()
+ {
+ criteria.SetReadOnly(true);
+ return this;
+ }
+
/// <summary>
/// Method to allow comparison of detached query in Lambda expression
/// e.g., p => p.Name == myQuery.As<string>
@@ -251,6 +257,9 @@
IQueryOver<TRoot> IQueryOver<TRoot>.CacheRegion(string cacheRegion)
{ return CacheRegion(cacheRegion); }
+ IQueryOver<TRoot> IQueryOver<TRoot>.ReadOnly()
+ { return ReadOnly(); }
+
}
/// <summary>
@@ -499,6 +508,16 @@
joinType));
}
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ {
+ return new QueryOver<TRoot,U>(impl,
+ criteria.CreateCriteria(
+ ExpressionProcessor.FindMemberExpression(path.Body),
+ ExpressionProcessor.FindMemberExpression(alias.Body),
+ joinType,
+ withClause));
+ }
+
public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias, JoinType joinType)
{
return new QueryOver<TRoot,U>(impl,
@@ -508,6 +527,16 @@
joinType));
}
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ {
+ return new QueryOver<TRoot,U>(impl,
+ criteria.CreateCriteria(
+ ExpressionProcessor.FindMemberExpression(path.Body),
+ ExpressionProcessor.FindMemberExpression(alias.Body),
+ joinType,
+ withClause));
+ }
+
public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias)
{
return new QueryOver<TRoot,U>(impl,
@@ -547,6 +576,16 @@
joinType));
}
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ {
+ return new QueryOver<TRoot,U>(impl,
+ criteria.CreateCriteria(
+ ExpressionProcessor.FindMemberExpression(path.Body),
+ ExpressionProcessor.FindMemberExpression(alias.Body),
+ joinType,
+ withClause));
+ }
+
public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType)
{
return new QueryOver<TRoot,U>(impl,
@@ -556,6 +595,16 @@
joinType));
}
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ {
+ return new QueryOver<TRoot,U>(impl,
+ criteria.CreateCriteria(
+ ExpressionProcessor.FindMemberExpression(path.Body),
+ ExpressionProcessor.FindMemberExpression(alias.Body),
+ joinType,
+ withClause));
+ }
+
public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, JoinType joinType)
{
return new QueryOver<TRoot,U>(impl,
@@ -596,6 +645,24 @@
joinType);
}
+ public QueryOver<TRoot,TSubType> JoinAlias<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ {
+ return AddAlias(
+ ExpressionProcessor.FindMemberExpression(path.Body),
+ ExpressionProcessor.FindMemberExpression(alias.Body),
+ joinType,
+ withClause);
+ }
+
+ public QueryOver<TRoot,TSubType> JoinAlias<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ {
+ return AddAlias(
+ ExpressionProcessor.FindMemberExpression(path.Body),
+ ExpressionProcessor.FindMemberExpression(alias.Body),
+ joinType,
+ withClause);
+ }
+
public QueryOver<TRoot,TSubType> JoinAlias(Expression<Func<object>> path, Expression<Func<object>> alias, JoinType joinType)
{
return AddAlias(
@@ -604,6 +671,24 @@
joinType);
}
+ public QueryOver<TRoot,TSubType> JoinAlias<U>(Expression<Func<U>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ {
+ return AddAlias(
+ ExpressionProcessor.FindMemberExpression(path.Body),
+ ExpressionProcessor.FindMemberExpression(alias.Body),
+ joinType,
+ withClause);
+ }
+
+ public QueryOver<TRoot,TSubType> JoinAlias<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ {
+ return AddAlias(
+ ExpressionProcessor.FindMemberExpression(path.Body),
+ ExpressionProcessor.FindMemberExpression(alias.Body),
+ joinType,
+ withClause);
+ }
+
public QueryOverJoinBuilder<TRoot,TSubType> Inner
{
get { return new QueryOverJoinBuilder<TRoot,TSubType>(this, JoinType.InnerJoin); }
@@ -630,6 +715,12 @@
return this;
}
+ private QueryOver<TRoot,TSubType> AddAlias(string path, string alias, JoinType joinType, ICriterion withClause)
+ {
+ criteria.CreateAlias(path, alias, joinType, withClause);
+ return this;
+ }
+
private QueryOver<TRoot,TSubType> Add(Expression<Func<TSubType, bool>> expression)
{
criteria.Add(ExpressionProcessor.ProcessExpression<TSubType>(expression));
@@ -772,9 +863,15 @@
IQueryOver<TRoot,U> IQueryOver<TRoot,TSubType>.JoinQueryOver<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, JoinType joinType)
{ return JoinQueryOver(path, alias, joinType); }
+ IQueryOver<TRoot,U> IQueryOver<TRoot,TSubType>.JoinQueryOver<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ { return JoinQueryOver(path, alias, joinType, withClause); }
+
IQueryOver<TRoot,U> IQueryOver<TRoot,TSubType>.JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias, JoinType joinType)
{ return JoinQueryOver(path, alias, joinType); }
+ IQueryOver<TRoot,U> IQueryOver<TRoot,TSubType>.JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ { return JoinQueryOver(path, alias, joinType, withClause); }
+
IQueryOver<TRoot,U> IQueryOver<TRoot,TSubType>.JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path)
{ return JoinQueryOver(path); }
@@ -796,9 +893,15 @@
IQueryOver<TRoot,U> IQueryOver<TRoot,TSubType>.JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType)
{ return JoinQueryOver(path, alias, joinType); }
+ IQueryOver<TRoot,U> IQueryOver<TRoot,TSubType>.JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ { return JoinQueryOver(path, alias, joinType, withClause); }
+
IQueryOver<TRoot,U> IQueryOver<TRoot,TSubType>.JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType)
{ return JoinQueryOver(path, alias, joinType); }
+ IQueryOver<TRoot,U> IQueryOver<TRoot,TSubType>.JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ { return JoinQueryOver(path, alias, joinType, withClause); }
+
IQueryOver<TRoot,TSubType> IQueryOver<TRoot,TSubType>.JoinAlias(Expression<Func<TSubType, object>> path, Expression<Func<object>> alias)
{ return JoinAlias(path, alias); }
@@ -808,9 +911,21 @@
IQueryOver<TRoot,TSubType> IQueryOver<TRoot,TSubType>.JoinAlias(Expression<Func<TSubType, object>> path, Expression<Func<object>> alias, JoinType joinType)
{ return JoinAlias(path, alias, joinType); }
+ IQueryOver<TRoot,TSubType> IQueryOver<TRoot,TSubType>.JoinAlias<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ { return JoinAlias(path, alias, joinType, withClause); }
+
+ IQueryOver<TRoot,TSubType> IQueryOver<TRoot,TSubType>.JoinAlias<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ { return JoinAlias(path, alias, joinType, withClause); }
+
IQueryOver<TRoot,TSubType> IQueryOver<TRoot,TSubType>.JoinAlias(Expression<Func<object>> path, Expression<Func<object>> alias, JoinType joinType)
{ return JoinAlias(path, alias, joinType); }
+ IQueryOver<TRoot,TSubType> IQueryOver<TRoot,TSubType>.JoinAlias<U>(Expression<Func<U>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ { return JoinAlias(path, alias, joinType, withClause); }
+
+ IQueryOver<TRoot,TSubType> IQueryOver<TRoot,TSubType>.JoinAlias<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause)
+ { return JoinAlias(path, alias, joinType, withClause); }
+
IQueryOverJoinBuilder<TRoot,TSubType> IQueryOver<TRoot,TSubType>.Inner
{ get { return new IQueryOverJoinBuilder<TRoot,TSubType>(this, JoinType.InnerJoin); } }
Modified: trunk/nhibernate/src/NHibernate/IQueryOver.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/IQueryOver.cs 2011-03-26 18:27:30 UTC (rev 5543)
+++ trunk/nhibernate/src/NHibernate/IQueryOver.cs 2011-03-26 18:51:53 UTC (rev 5544)
@@ -154,6 +154,12 @@
/// for the default query cache</param>
IQueryOver<TRoot> CacheRegion(string cacheRegion);
+ /// <summary>
+ /// Set the read-only mode for entities (and proxies) loaded by this QueryOver.
+ /// (see <see cref="ICriteria.SetReadOnly" />).
+ /// </summary>
+ IQueryOver<TRoot> ReadOnly();
+
}
/// <summary>
@@ -431,11 +437,33 @@
/// <param name="path">Lambda expression returning association path</param>
/// <param name="alias">Lambda expression returning alias reference</param>
/// <param name="joinType">Type of join</param>
+ /// <param name="withClause">Additional criterion for the SQL on clause</param>
/// <returns>The created "sub criteria"</returns>
+ IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause);
+
+ /// <summary>
+ /// Creates a new NHibernate.IQueryOver<TRoot, U>, "rooted" at the associated entity
+ /// </summary>
+ /// <typeparam name="U">Type of sub-criteria</typeparam>
+ /// <param name="path">Lambda expression returning association path</param>
+ /// <param name="alias">Lambda expression returning alias reference</param>
+ /// <param name="joinType">Type of join</param>
+ /// <returns>The created "sub criteria"</returns>
IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias, JoinType joinType);
/// <summary>
/// Creates a new NHibernate.IQueryOver<TRoot, U>, "rooted" at the associated entity
+ /// </summary>
+ /// <typeparam name="U">Type of sub-criteria</typeparam>
+ /// <param name="path">Lambda expression returning association path</param>
+ /// <param name="alias">Lambda expression returning alias reference</param>
+ /// <param name="joinType">Type of join</param>
+ /// <param name="withClause">Additional criterion for the SQL on clause</param>
+ /// <returns>The created "sub criteria"</returns>
+ IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause);
+
+ /// <summary>
+ /// Creates a new NHibernate.IQueryOver<TRoot, U>, "rooted" at the associated entity
/// specifying a collection for the join.
/// </summary>
/// <typeparam name="U">Type of sub-criteria (type of the collection)</typeparam>
@@ -511,10 +539,34 @@
/// <param name="path">Lambda expression returning association path</param>
/// <param name="alias">Lambda expression returning alias reference</param>
/// <param name="joinType">Type of join</param>
+ /// <param name="withClause">Additional criterion for the SQL on clause</param>
/// <returns>The created "sub criteria"</returns>
+ IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause);
+
+ /// <summary>
+ /// Creates a new NHibernate.IQueryOver<TRoot, U>, "rooted" at the associated entity
+ /// specifying a collection for the join.
+ /// </summary>
+ /// <typeparam name="U">Type of sub-criteria (type of the collection)</typeparam>
+ /// <param name="path">Lambda expression returning association path</param>
+ /// <param name="alias">Lambda expression returning alias reference</param>
+ /// <param name="joinType">Type of join</param>
+ /// <returns>The created "sub criteria"</returns>
IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType);
/// <summary>
+ /// Creates a new NHibernate.IQueryOver<TRoot, U>, "rooted" at the associated entity
+ /// specifying a collection for the join.
+ /// </summary>
+ /// <typeparam name="U">Type of sub-criteria (type of the collection)</typeparam>
+ /// <param name="path">Lambda expression returning association path</param>
+ /// <param name="alias">Lambda expression returning alias reference</param>
+ /// <param name="joinType">Type of join</param>
+ /// <param name="withClause">Additional criterion for the SQL on clause</param>
+ /// <returns>The created "sub criteria"</returns>
+ IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause);
+
+ /// <summary>
/// Join an association, assigning an alias to the joined entity
/// </summary>
/// <param name="path">Lambda expression returning association path</param>
@@ -545,9 +597,51 @@
/// <param name="path">Lambda expression returning association path</param>
/// <param name="alias">Lambda expression returning alias reference</param>
/// <param name="joinType">Type of join</param>
+ /// <param name="withClause">Additional criterion for the SQL on clause</param>
/// <returns>criteria instance</returns>
+ IQueryOver<TRoot,TSubType> JoinAlias<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause);
+
+ /// <summary>
+ /// Join an association, assigning an alias to the joined entity
+ /// </summary>
+ /// <typeparam name="U">Type of sub-criteria (type of the collection)</typeparam>
+ /// <param name="path">Lambda expression returning association path</param>
+ /// <param name="alias">Lambda expression returning alias reference</param>
+ /// <param name="joinType">Type of join</param>
+ /// <param name="withClause">Additional criterion for the SQL on clause</param>
+ /// <returns>criteria instance</returns>
+ IQueryOver<TRoot,TSubType> JoinAlias<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause);
+
+ /// <summary>
+ /// Join an association, assigning an alias to the joined entity
+ /// </summary>
+ /// <param name="path">Lambda expression returning association path</param>
+ /// <param name="alias">Lambda expression returning alias reference</param>
+ /// <param name="joinType">Type of join</param>
+ /// <returns>criteria instance</returns>
IQueryOver<TRoot,TSubType> JoinAlias(Expression<Func<object>> path, Expression<Func<object>> alias, JoinType joinType);
+ /// <summary>
+ /// Join an association, assigning an alias to the joined entity
+ /// </summary>
+ /// <param name="path">Lambda expression returning association path</param>
+ /// <param name="alias">Lambda expression returning alias reference</param>
+ /// <param name="joinType">Type of join</param>
+ /// <param name="withClause">Additional criterion for the SQL on clause</param>
+ /// <returns>criteria instance</returns>
+ IQueryOver<TRoot,TSubType> JoinAlias<U>(Expression<Func<U>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause);
+
+ /// <summary>
+ /// Join an association, assigning an alias to the joined entity
+ /// </summary>
+ /// <typeparam name="U">Type of sub-criteria (type of the collection)</typeparam>
+ /// <param name="path">Lambda expression returning association path</param>
+ /// <param name="alias">Lambda expression returning alias reference</param>
+ /// <param name="joinType">Type of join</param>
+ /// <param name="withClause">Additional criterion for the SQL on clause</param>
+ /// <returns>criteria instance</returns>
+ IQueryOver<TRoot,TSubType> JoinAlias<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias, JoinType joinType, ICriterion withClause);
+
IQueryOverJoinBuilder<TRoot,TSubType> Inner { get; }
IQueryOverJoinBuilder<TRoot,TSubType> Left { get; }
IQueryOverJoinBuilder<TRoot,TSubType> Right { get; }
Modified: trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/IntegrationFixture.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/IntegrationFixture.cs 2011-03-26 18:27:30 UTC (rev 5543)
+++ trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/IntegrationFixture.cs 2011-03-26 18:51:53 UTC (rev 5544)
@@ -4,6 +4,7 @@
using System.Linq;
using NUnit.Framework;
+using SharpTestsEx;
using NHibernate.Criterion;
using NHibernate.Transform;
@@ -181,6 +182,79 @@
}
[Test]
+ public void OnClause()
+ {
+ using (ISession s = OpenSession())
+ using (ITransaction t = s.BeginTransaction())
+ {
+ s.Save(new Person() { Name = "John" }
+ .AddChild(new Child() { Nickname = "John"})
+ .AddChild(new Child() { Nickname = "Judy"}));
+
+ s.Save(new Person() { Name = "Jean" });
+ s.Save(new Child() { Nickname = "James" });
+
+ t.Commit();
+ }
+
+ using (ISession s = OpenSession())
+ {
+ Child childAlias = null;
+ Person parentAlias = null;
+ var children =
+ s.QueryOver(() => childAlias)
+ .Left.JoinQueryOver(c => c.Parent, () => parentAlias, p => p.Name == childAlias.Nickname)
+ .WhereRestrictionOn(p => p.Name).IsNotNull
+ .List();
+
+ children.Should().Have.Count.EqualTo(1);
+ }
+
+ using (ISession s = OpenSession())
+ {
+ Child childAlias = null;
+ Person parentAlias = null;
+ var parentNames =
+ s.QueryOver<Child>(() => childAlias)
+ .Left.JoinAlias(c => c.Parent, () => parentAlias, p => p.Name == childAlias.Nickname)
+ .Select(c => parentAlias.Name)
+ .List<string>();
+
+ parentNames
+ .Where(n => !string.IsNullOrEmpty(n))
+ .Should().Have.Count.EqualTo(1);
+ }
+
+ using (ISession s = OpenSession())
+ {
+ Person personAlias = null;
+ Child childAlias = null;
+ var people =
+ s.QueryOver<Person>(() => personAlias)
+ .Left.JoinQueryOver(p => p.Children, () => childAlias, c => c.Nickname == personAlias.Name)
+ .WhereRestrictionOn(c => c.Nickname).IsNotNull
+ .List();
+
+ people.Should().Have.Count.EqualTo(1);
+ }
+
+ using (ISession s = OpenSession())
+ {
+ Person personAlias = null;
+ Child childAlias = null;
+ var childNames =
+ s.QueryOver<Person>(() => personAlias)
+ .Left.JoinAlias(p => p.Children, () => childAlias, c => c.Nickname == personAlias.Name)
+ .Select(p => childAlias.Nickname)
+ .List<string>();
+
+ childNames
+ .Where(n => !string.IsNullOrEmpty(n))
+ .Should().Have.Count.EqualTo(1);
+ }
+ }
+
+ [Test]
public void UniqueResult()
{
using (ISession s = OpenSession())
Modified: trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/QueryOverFixture.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/QueryOverFixture.cs 2011-03-26 18:27:30 UTC (rev 5543)
+++ trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/QueryOverFixture.cs 2011-03-26 18:51:53 UTC (rev 5544)
@@ -412,6 +412,198 @@
}
[Test]
+ public void OnClause_SubCriteria()
+ {
+ ICriteria expected =
+ CreateTestCriteria(typeof(Person))
+ .CreateCriteria("PersonList", "alias1", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "many func t,bool"))
+ .CreateCriteria("PersonList", "alias2", JoinType.LeftOuterJoin, Restrictions.Eq("alias1.Name", "many func bool"))
+ .CreateCriteria("PersonList", "alias3", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "many private"))
+ .CreateCriteria("Father", "alias4", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "one func t,bool"))
+ .CreateCriteria("Father", "alias5", JoinType.LeftOuterJoin, Restrictions.Eq("alias4.Name", "one func bool"))
+ .CreateCriteria("Father", "alias6", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "one private"))
+ .CreateCriteria("alias1.PersonList", "alias7", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a many func t,bool"))
+ .CreateCriteria("alias2.PersonList", "alias8", JoinType.LeftOuterJoin, Restrictions.Eq("alias1.Name", "a many func bool"))
+ .CreateCriteria("alias3.PersonList", "alias9", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a many private"))
+ .CreateCriteria("alias4.Father", "alias10", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a one func t,bool"))
+ .CreateCriteria("alias5.Father", "alias11", JoinType.LeftOuterJoin, Restrictions.Eq("alias4.Name", "a one func bool"))
+ .CreateCriteria("alias6.Father", "alias12", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a one private"));
+
+ Person alias1 = null;
+ Person alias2 = null;
+ Person alias3 = null;
+ Person alias4 = null;
+ Person alias5 = null;
+ Person alias6 = null;
+ Person alias7 = null;
+ Person alias8 = null;
+ Person alias9 = null;
+ Person alias10 = null;
+ Person alias11 = null;
+ Person alias12 = null;
+ IQueryOver<Person> actual =
+ CreateTestQueryOver<Person>()
+ .Left.JoinQueryOver(p => p.PersonList, () => alias1, p => p.Name == "many func t,bool")
+ .Left.JoinQueryOver(p => p.PersonList, () => alias2, () => alias1.Name == "many func bool")
+ .Left.JoinQueryOver(p => p.PersonList, () => alias3, Restrictions.Eq("Name", "many private"))
+ .Left.JoinQueryOver(p => p.Father, () => alias4, p => p.Name == "one func t,bool")
+ .Left.JoinQueryOver(p => p.Father, () => alias5, () => alias4.Name == "one func bool")
+ .Left.JoinQueryOver(p => p.Father, () => alias6, p => p.Name == "one private")
+ .Left.JoinQueryOver(() => alias1.PersonList, () => alias7, p => p.Name == "a many func t,bool")
+ .Left.JoinQueryOver(() => alias2.PersonList, () => alias8, () => alias1.Name == "a many func bool")
+ .Left.JoinQueryOver(() => alias3.PersonList, () => alias9, Restrictions.Eq("Name", "a many private"))
+ .Left.JoinQueryOver(() => alias4.Father, () => alias10, p => p.Name == "a one func t,bool")
+ .Left.JoinQueryOver(() => alias5.Father, () => alias11, () => alias4.Name == "a one func bool")
+ .Left.JoinQueryOver(() => alias6.Father, () => alias12, p => p.Name == "a one private");
+
+ AssertCriteriaAreEqual(expected, actual);
+ }
+
+ [Test]
+ public void OnClauseDetached_SubCriteria()
+ {
+ DetachedCriteria expected =
+ DetachedCriteria.For<Person>()
+ .CreateCriteria("PersonList", "alias1", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "many func t,bool"))
+ .CreateCriteria("PersonList", "alias2", JoinType.LeftOuterJoin, Restrictions.Eq("alias1.Name", "many func bool"))
+ .CreateCriteria("PersonList", "alias3", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "many private"))
+ .CreateCriteria("Father", "alias4", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "one func t,bool"))
+ .CreateCriteria("Father", "alias5", JoinType.LeftOuterJoin, Restrictions.Eq("alias4.Name", "one func bool"))
+ .CreateCriteria("Father", "alias6", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "one private"))
+ .CreateCriteria("alias1.PersonList", "alias7", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a many func t,bool"))
+ .CreateCriteria("alias2.PersonList", "alias8", JoinType.LeftOuterJoin, Restrictions.Eq("alias1.Name", "a many func bool"))
+ .CreateCriteria("alias3.PersonList", "alias9", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a many private"))
+ .CreateCriteria("alias4.Father", "alias10", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a one func t,bool"))
+ .CreateCriteria("alias5.Father", "alias11", JoinType.LeftOuterJoin, Restrictions.Eq("alias4.Name", "a one func bool"))
+ .CreateCriteria("alias6.Father", "alias12", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a one private"));
+
+ Person alias1 = null;
+ Person alias2 = null;
+ Person alias3 = null;
+ Person alias4 = null;
+ Person alias5 = null;
+ Person alias6 = null;
+ Person alias7 = null;
+ Person alias8 = null;
+ Person alias9 = null;
+ Person alias10 = null;
+ Person alias11 = null;
+ Person alias12 = null;
+ QueryOver<Person> actual =
+ QueryOver.Of<Person>()
+ .Left.JoinQueryOver(p => p.PersonList, () => alias1, p => p.Name == "many func t,bool")
+ .Left.JoinQueryOver(p => p.PersonList, () => alias2, () => alias1.Name == "many func bool")
+ .Left.JoinQueryOver(p => p.PersonList, () => alias3, Restrictions.Eq("Name", "many private"))
+ .Left.JoinQueryOver(p => p.Father, () => alias4, p => p.Name == "one func t,bool")
+ .Left.JoinQueryOver(p => p.Father, () => alias5, () => alias4.Name == "one func bool")
+ .Left.JoinQueryOver(p => p.Father, () => alias6, p => p.Name == "one private")
+ .Left.JoinQueryOver(() => alias1.PersonList, () => alias7, p => p.Name == "a many func t,bool")
+ .Left.JoinQueryOver(() => alias2.PersonList, () => alias8, () => alias1.Name == "a many func bool")
+ .Left.JoinQueryOver(() => alias3.PersonList, () => alias9, Restrictions.Eq("Name", "a many private"))
+ .Left.JoinQueryOver(() => alias4.Father, () => alias10, p => p.Name == "a one func t,bool")
+ .Left.JoinQueryOver(() => alias5.Father, () => alias11, () => alias4.Name == "a one func bool")
+ .Left.JoinQueryOver(() => alias6.Father, () => alias12, p => p.Name == "a one private");
+
+ AssertCriteriaAreEqual(expected, actual);
+ }
+
+ [Test]
+ public void OnClause_Alias()
+ {
+ ICriteria expected =
+ CreateTestCriteria(typeof(Person))
+ .CreateAlias("PersonList", "alias1", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "many func t,bool"))
+ .CreateAlias("PersonList", "alias2", JoinType.LeftOuterJoin, Restrictions.Eq("alias1.Name", "many func bool"))
+ .CreateAlias("PersonList", "alias3", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "many private"))
+ .CreateAlias("Father", "alias4", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "one func t,bool"))
+ .CreateAlias("Father", "alias5", JoinType.LeftOuterJoin, Restrictions.Eq("alias4.Name", "one func bool"))
+ .CreateAlias("Father", "alias6", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "one private"))
+ .CreateAlias("alias1.PersonList", "alias7", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a many func t,bool"))
+ .CreateAlias("alias2.PersonList", "alias8", JoinType.LeftOuterJoin, Restrictions.Eq("alias1.Name", "a many func bool"))
+ .CreateAlias("alias3.PersonList", "alias9", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a many private"))
+ .CreateAlias("alias4.Father", "alias10", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a one func t,bool"))
+ .CreateAlias("alias5.Father", "alias11", JoinType.LeftOuterJoin, Restrictions.Eq("alias4.Name", "a one func bool"))
+ .CreateAlias("alias6.Father", "alias12", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a one private"));
+
+ Person alias1 = null;
+ Person alias2 = null;
+ Person alias3 = null;
+ Person alias4 = null;
+ Person alias5 = null;
+ Person alias6 = null;
+ Person alias7 = null;
+ Person alias8 = null;
+ Person alias9 = null;
+ Person alias10 = null;
+ Person alias11 = null;
+ Person alias12 = null;
+ IQueryOver<Person> actual =
+ CreateTestQueryOver<Person>()
+ .Left.JoinAlias(p => p.PersonList, () => alias1, p => p.Name == "many func t,bool")
+ .Left.JoinAlias(p => p.PersonList, () => alias2, () => alias1.Name == "many func bool")
+ .Left.JoinAlias(p => p.PersonList, () => alias3, Restrictions.Eq("Name", "many private"))
+ .Left.JoinAlias(p => p.Father, () => alias4, p => p.Name == "one func t,bool")
+ .Left.JoinAlias(p => p.Father, () => alias5, () => alias4.Name == "one func bool")
+ .Left.JoinAlias(p => p.Father, () => alias6, p => p.Name == "one private")
+ .Left.JoinAlias(() => alias1.PersonList, () => alias7, p => p.Name == "a many func t,bool")
+ .Left.JoinAlias(() => alias2.PersonList, () => alias8, () => alias1.Name == "a many func bool")
+ .Left.JoinAlias(() => alias3.PersonList, () => alias9, Restrictions.Eq("Name", "a many private"))
+ .Left.JoinAlias(() => alias4.Father, () => alias10, p => p.Name == "a one func t,bool")
+ .Left.JoinAlias(() => alias5.Father, () => alias11, () => alias4.Name == "a one func bool")
+ .Left.JoinAlias(() => alias6.Father, () => alias12, p => p.Name == "a one private");
+
+ AssertCriteriaAreEqual(expected, actual);
+ }
+
+ [Test]
+ public void OnClauseDetached_Alias()
+ {
+ DetachedCriteria expected =
+ DetachedCriteria.For<Person>()
+ .CreateAlias("PersonList", "alias1", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "many func t,bool"))
+ .CreateAlias("PersonList", "alias2", JoinType.LeftOuterJoin, Restrictions.Eq("alias1.Name", "many func bool"))
+ .CreateAlias("PersonList", "alias3", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "many private"))
+ .CreateAlias("Father", "alias4", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "one func t,bool"))
+ .CreateAlias("Father", "alias5", JoinType.LeftOuterJoin, Restrictions.Eq("alias4.Name", "one func bool"))
+ .CreateAlias("Father", "alias6", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "one private"))
+ .CreateAlias("alias1.PersonList", "alias7", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a many func t,bool"))
+ .CreateAlias("alias2.PersonList", "alias8", JoinType.LeftOuterJoin, Restrictions.Eq("alias1.Name", "a many func bool"))
+ .CreateAlias("alias3.PersonList", "alias9", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a many private"))
+ .CreateAlias("alias4.Father", "alias10", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a one func t,bool"))
+ .CreateAlias("alias5.Father", "alias11", JoinType.LeftOuterJoin, Restrictions.Eq("alias4.Name", "a one func bool"))
+ .CreateAlias("alias6.Father", "alias12", JoinType.LeftOuterJoin, Restrictions.Eq("Name", "a one private"));
+
+ Person alias1 = null;
+ Person alias2 = null;
+ Person alias3 = null;
+ Person alias4 = null;
+ Person alias5 = null;
+ Person alias6 = null;
+ Person alias7 = null;
+ Person alias8 = null;
+ Person alias9 = null;
+ Person alias10 = null;
+ Person alias11 = null;
+ Person alias12 = null;
+ QueryOver<Person> actual =
+ QueryOver.Of<Person>()
+ .Left.JoinAlias(p => p.PersonList, () => alias1, p => p.Name == "many func t,bool")
+ .Left.JoinAlias(p => p.PersonList, () => alias2, () => alias1.Name == "many func bool")
+ .Left.JoinAlias(p => p.PersonList, () => alias3, Restrictions.Eq("Name", "many private"))
+ .Left.JoinAlias(p => p.Father, () => alias4, p => p.Name == "one func t,bool")
+ .Left.JoinAlias(p => p.Father, () => alias5, () => alias4.Name == "one func bool")
+ .Left.JoinAlias(p => p.Father, () => alias6, p => p.Name == "one private")
+ .Left.JoinAlias(() => alias1.PersonList, () => alias7, p => p.Name == "a many func t,bool")
+ .Left.JoinAlias(() => alias2.PersonList, () => alias8, () => alias1.Name == "a many func bool")
+ .Left.JoinAlias(() => alias3.PersonList, () => alias9, Restrictions.Eq("Name", "a many private"))
+ .Left.JoinAlias(() => alias4.Father, () => alias10, p => p.Name == "a one func t,bool")
+ .Left.JoinAlias(() => alias5.Father, () => alias11, () => alias4.Name == "a one func bool")
+ .Left.JoinAlias(() => alias6.Father, () => alias12, p => p.Name == "a one private");
+
+ AssertCriteriaAreEqual(expected, actual);
+ }
+
+ [Test]
public void OrderBy()
{
ICriteria expected =
@@ -571,6 +763,20 @@
}
[Test]
+ public void Readonly()
+ {
+ ICriteria expected =
+ CreateTestCriteria(typeof(Person))
+ .SetReadOnly(true);
+
+ IQueryOver<Person> actual =
+ CreateTestQueryOver<Person>()
+ .ReadOnly();
+
+ AssertCriteriaAreEqual(expected, actual);
+ }
+
+ [Test]
public void DetachedQueryOver()
{
DetachedCriteria expected =
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
