Menu
▾
▴
[Nhibernate-commit] SF.net SVN: nhibernate:[4876] trunk/nhibernate/src/NHibernate
|
From: <ric...@us...> - 2009-11-30 13:28:14
|
Revision: 4876
http://nhibernate.svn.sourceforge.net/nhibernate/?rev=4876&view=rev
Author: ricbrown
Date: 2009-11-30 13:28:06 +0000 (Mon, 30 Nov 2009)
Log Message:
-----------
Refactored generic type naming for IQueryOver and removed a couple of compiler warnings.
Modified Paths:
--------------
trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverFetchBuilder.cs
trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverJoinBuilder.cs
trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverLockBuilder.cs
trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverOrderBuilder.cs
trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverProjectionBuilder.cs
trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverRestrictionBuilder.cs
trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryBuilder.cs
trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryPropertyBuilder.cs
trunk/nhibernate/src/NHibernate/Criterion/QueryOver.cs
trunk/nhibernate/src/NHibernate/IQueryOver.cs
trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/LambdaFixtureBase.cs
Modified: trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverFetchBuilder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverFetchBuilder.cs 2009-11-30 03:21:02 UTC (rev 4875)
+++ trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverFetchBuilder.cs 2009-11-30 13:28:06 UTC (rev 4876)
@@ -9,35 +9,35 @@
namespace NHibernate.Criterion
{
- public class QueryOverFetchBuilder<S,T> : QueryOverFetchBuilderBase<QueryOver<S,T>, S, T>
+ public class QueryOverFetchBuilder<TRoot,TSubType> : QueryOverFetchBuilderBase<QueryOver<TRoot,TSubType>, TRoot, TSubType>
{
- public QueryOverFetchBuilder(QueryOver<S,T> root, Expression<Func<S, object>> path)
+ public QueryOverFetchBuilder(QueryOver<TRoot,TSubType> root, Expression<Func<TRoot, object>> path)
: base(root, path) { }
}
- public class IQueryOverFetchBuilder<S,T> : QueryOverFetchBuilderBase<IQueryOver<S,T>, S, T>
+ public class IQueryOverFetchBuilder<TRoot,TSubType> : QueryOverFetchBuilderBase<IQueryOver<TRoot,TSubType>, TRoot, TSubType>
{
- public IQueryOverFetchBuilder(IQueryOver<S,T> root, Expression<Func<S, object>> path)
+ public IQueryOverFetchBuilder(IQueryOver<TRoot,TSubType> root, Expression<Func<TRoot, object>> path)
: base(root, path) { }
}
- public class QueryOverFetchBuilderBase<R, S, T> where R : IQueryOver<S,T>
+ public class QueryOverFetchBuilderBase<TReturn, TRoot, TSubType> where TReturn : IQueryOver<TRoot,TSubType>
{
- protected R root;
+ protected TReturn root;
protected string path;
- protected QueryOverFetchBuilderBase(R root, Expression<Func<S, object>> path)
+ protected QueryOverFetchBuilderBase(TReturn root, Expression<Func<TRoot, object>> path)
{
this.root = root;
this.path = ExpressionProcessor.FindMemberExpression(path.Body);
}
- public R Eager
+ public TReturn Eager
{
get
{
@@ -46,7 +46,7 @@
}
}
- public R Lazy
+ public TReturn Lazy
{
get
{
@@ -55,7 +55,7 @@
}
}
- public R Default
+ public TReturn Default
{
get
{
Modified: trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverJoinBuilder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverJoinBuilder.cs 2009-11-30 03:21:02 UTC (rev 4875)
+++ trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverJoinBuilder.cs 2009-11-30 13:28:06 UTC (rev 4876)
@@ -9,118 +9,118 @@
namespace NHibernate.Criterion.Lambda
{
- public class QueryOverJoinBuilder<S,T> : QueryOverJoinBuilderBase<QueryOver<S,T>, S, T>
+ public class QueryOverJoinBuilder<TRoot,TSubType> : QueryOverJoinBuilderBase<QueryOver<TRoot,TSubType>, TRoot, TSubType>
{
- public QueryOverJoinBuilder(QueryOver<S,T> root, JoinType joinType) : base(root, joinType) { }
+ public QueryOverJoinBuilder(QueryOver<TRoot,TSubType> root, JoinType joinType) : base(root, joinType) { }
- public QueryOver<S,U> JoinQueryOver<U>(Expression<Func<T, U>> path)
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path)
{
return root.JoinQueryOver<U>(path, joinType);
}
- public QueryOver<S,U> JoinQueryOver<U>(Expression<Func<U>> path)
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path)
{
return root.JoinQueryOver<U>(path, joinType);
}
- public QueryOver<S,U> JoinQueryOver<U>(Expression<Func<T, U>> path, Expression<Func<U>> alias)
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias)
{
return root.JoinQueryOver<U>(path, alias, joinType);
}
- public QueryOver<S,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias)
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias)
{
return root.JoinQueryOver<U>(path, alias, joinType);
}
- public QueryOver<S,U> JoinQueryOver<U>(Expression<Func<T, IEnumerable<U>>> path)
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path)
{
return root.JoinQueryOver<U>(path, joinType);
}
- public QueryOver<S,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path)
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path)
{
return root.JoinQueryOver<U>(path, joinType);
}
- public QueryOver<S,U> JoinQueryOver<U>(Expression<Func<T, IEnumerable<U>>> path, Expression<Func<U>> alias)
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias)
{
return root.JoinQueryOver<U>(path, alias, joinType);
}
- public QueryOver<S,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias)
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias)
{
return root.JoinQueryOver<U>(path, alias, joinType);
}
}
- public class IQueryOverJoinBuilder<S,T> : QueryOverJoinBuilderBase<IQueryOver<S,T>, S, T>
+ public class IQueryOverJoinBuilder<TRoot,TSubType> : QueryOverJoinBuilderBase<IQueryOver<TRoot,TSubType>, TRoot, TSubType>
{
- public IQueryOverJoinBuilder(IQueryOver<S,T> root, JoinType joinType) : base(root, joinType) { }
+ public IQueryOverJoinBuilder(IQueryOver<TRoot,TSubType> root, JoinType joinType) : base(root, joinType) { }
- public IQueryOver<S,U> JoinQueryOver<U>(Expression<Func<T, U>> path)
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path)
{
return root.JoinQueryOver<U>(path, joinType);
}
- public IQueryOver<S,U> JoinQueryOver<U>(Expression<Func<U>> path)
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path)
{
return root.JoinQueryOver<U>(path, joinType);
}
- public IQueryOver<S,U> JoinQueryOver<U>(Expression<Func<T, U>> path, Expression<Func<U>> alias)
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias)
{
return root.JoinQueryOver<U>(path, alias, joinType);
}
- public IQueryOver<S,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias)
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias)
{
return root.JoinQueryOver<U>(path, alias, joinType);
}
- public IQueryOver<S,U> JoinQueryOver<U>(Expression<Func<T, IEnumerable<U>>> path)
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path)
{
return root.JoinQueryOver<U>(path, joinType);
}
- public IQueryOver<S,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path)
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path)
{
return root.JoinQueryOver<U>(path, joinType);
}
- public IQueryOver<S,U> JoinQueryOver<U>(Expression<Func<T, IEnumerable<U>>> path, Expression<Func<U>> alias)
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, IEnumerable<U>>> path, Expression<Func<U>> alias)
{
return root.JoinQueryOver<U>(path, alias, joinType);
}
- public IQueryOver<S,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias)
+ public IQueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<IEnumerable<U>>> path, Expression<Func<U>> alias)
{
return root.JoinQueryOver<U>(path, alias, joinType);
}
}
- public class QueryOverJoinBuilderBase<R, S, T> where R : IQueryOver<S,T>
+ public class QueryOverJoinBuilderBase<TReturn, TRoot, TSubType> where TReturn : IQueryOver<TRoot,TSubType>
{
- protected R root;
+ protected TReturn root;
protected JoinType joinType;
- public QueryOverJoinBuilderBase(R root, JoinType joinType)
+ public QueryOverJoinBuilderBase(TReturn root, JoinType joinType)
{
this.root = root;
this.joinType = joinType;
}
- public R JoinAlias(Expression<Func<T, object>> path, Expression<Func<object>> alias)
+ public TReturn JoinAlias(Expression<Func<TSubType, object>> path, Expression<Func<object>> alias)
{
- return (R)root.JoinAlias(path, alias, joinType);
+ return (TReturn)root.JoinAlias(path, alias, joinType);
}
- public R JoinAlias(Expression<Func<object>> path, Expression<Func<object>> alias)
+ public TReturn JoinAlias(Expression<Func<object>> path, Expression<Func<object>> alias)
{
- return (R)root.JoinAlias(path, alias, joinType);
+ return (TReturn)root.JoinAlias(path, alias, joinType);
}
}
Modified: trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverLockBuilder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverLockBuilder.cs 2009-11-30 03:21:02 UTC (rev 4875)
+++ trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverLockBuilder.cs 2009-11-30 13:28:06 UTC (rev 4876)
@@ -9,29 +9,29 @@
namespace NHibernate.Criterion.Lambda
{
- public class QueryOverLockBuilder<S,T> : QueryOverLockBuilderBase<QueryOver<S,T>, S, T>
+ public class QueryOverLockBuilder<TRoot,TSubType> : QueryOverLockBuilderBase<QueryOver<TRoot,TSubType>, TRoot, TSubType>
{
- public QueryOverLockBuilder(QueryOver<S,T> root, Expression<Func<object>> alias)
+ public QueryOverLockBuilder(QueryOver<TRoot,TSubType> root, Expression<Func<object>> alias)
: base(root, alias) { }
}
- public class IQueryOverLockBuilder<S,T> : QueryOverLockBuilderBase<IQueryOver<S,T>, S, T>
+ public class IQueryOverLockBuilder<TRoot,TSubType> : QueryOverLockBuilderBase<IQueryOver<TRoot,TSubType>, TRoot, TSubType>
{
- public IQueryOverLockBuilder(IQueryOver<S,T> root, Expression<Func<object>> alias)
+ public IQueryOverLockBuilder(IQueryOver<TRoot,TSubType> root, Expression<Func<object>> alias)
: base(root, alias) { }
}
- public class QueryOverLockBuilderBase<R, S, T> where R : IQueryOver<S,T>
+ public class QueryOverLockBuilderBase<TReturn, TRoot, TSubType> where TReturn : IQueryOver<TRoot,TSubType>
{
- protected R root;
+ protected TReturn root;
protected string alias;
- protected QueryOverLockBuilderBase(R root, Expression<Func<object>> alias)
+ protected QueryOverLockBuilderBase(TReturn root, Expression<Func<object>> alias)
{
this.root = root;
@@ -47,7 +47,7 @@
root.UnderlyingCriteria.SetLockMode(lockMode);
}
- public R Force
+ public TReturn Force
{
get
{
@@ -56,7 +56,7 @@
}
}
- public R None
+ public TReturn None
{
get
{
@@ -65,7 +65,7 @@
}
}
- public R Read
+ public TReturn Read
{
get
{
@@ -74,7 +74,7 @@
}
}
- public R Upgrade
+ public TReturn Upgrade
{
get
{
@@ -83,7 +83,7 @@
}
}
- public R UpgradeNoWait
+ public TReturn UpgradeNoWait
{
get
{
@@ -92,7 +92,7 @@
}
}
- public R Write
+ public TReturn Write
{
get
{
Modified: trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverOrderBuilder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverOrderBuilder.cs 2009-11-30 03:21:02 UTC (rev 4875)
+++ trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverOrderBuilder.cs 2009-11-30 13:28:06 UTC (rev 4876)
@@ -9,47 +9,47 @@
namespace NHibernate.Criterion.Lambda
{
- public class QueryOverOrderBuilder<S,T> : QueryOverOrderBuilderBase<QueryOver<S,T>, S, T>
+ public class QueryOverOrderBuilder<TRoot,TSubType> : QueryOverOrderBuilderBase<QueryOver<TRoot,TSubType>, TRoot, TSubType>
{
- public QueryOverOrderBuilder(QueryOver<S,T> root, Expression<Func<T, object>> path) : base(root, path)
+ public QueryOverOrderBuilder(QueryOver<TRoot,TSubType> root, Expression<Func<TSubType, object>> path) : base(root, path)
{}
- public QueryOverOrderBuilder(QueryOver<S,T> root, Expression<Func<object>> path) : base(root, path)
+ public QueryOverOrderBuilder(QueryOver<TRoot,TSubType> root, Expression<Func<object>> path) : base(root, path)
{}
}
- public class IQueryOverOrderBuilder<S,T> : QueryOverOrderBuilderBase<IQueryOver<S,T>, S, T>
+ public class IQueryOverOrderBuilder<TRoot,TSubType> : QueryOverOrderBuilderBase<IQueryOver<TRoot,TSubType>, TRoot, TSubType>
{
- public IQueryOverOrderBuilder(IQueryOver<S,T> root, Expression<Func<T, object>> path) : base(root, path)
+ public IQueryOverOrderBuilder(IQueryOver<TRoot,TSubType> root, Expression<Func<TSubType, object>> path) : base(root, path)
{}
- public IQueryOverOrderBuilder(IQueryOver<S,T> root, Expression<Func<object>> path) : base(root, path)
+ public IQueryOverOrderBuilder(IQueryOver<TRoot,TSubType> root, Expression<Func<object>> path) : base(root, path)
{}
}
- public class QueryOverOrderBuilderBase<R, S, T> where R : IQueryOver<S, T>
+ public class QueryOverOrderBuilderBase<TReturn, TRoot, TSubType> where TReturn : IQueryOver<TRoot, TSubType>
{
- protected R root;
+ protected TReturn root;
protected LambdaExpression path;
- protected QueryOverOrderBuilderBase(R root, Expression<Func<T, object>> path)
+ protected QueryOverOrderBuilderBase(TReturn root, Expression<Func<TSubType, object>> path)
{
this.root = root;
this.path = path;
}
- protected QueryOverOrderBuilderBase(R root, Expression<Func<object>> path)
+ protected QueryOverOrderBuilderBase(TReturn root, Expression<Func<object>> path)
{
this.root = root;
this.path = path;
}
- public R Asc
+ public TReturn Asc
{
get
{
@@ -58,7 +58,7 @@
}
}
- public R Desc
+ public TReturn Desc
{
get
{
Modified: trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverProjectionBuilder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverProjectionBuilder.cs 2009-11-30 03:21:02 UTC (rev 4875)
+++ trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverProjectionBuilder.cs 2009-11-30 13:28:06 UTC (rev 4876)
@@ -9,15 +9,15 @@
namespace NHibernate.Criterion.Lambda
{
- public class QueryOverProjectionBuilder<R, S, T>
+ public class QueryOverProjectionBuilder<TReturn, TRoot, TSubType>
{
- private R fluentReturn;
- private IQueryOver<S,T> criteria;
+ private TReturn fluentReturn;
+ private IQueryOver<TRoot,TSubType> criteria;
private ProjectionList projectionList;
private IProjection lastProjection = null;
- public QueryOverProjectionBuilder(R fluentReturn, IQueryOver<S,T> criteria)
+ public QueryOverProjectionBuilder(TReturn fluentReturn, IQueryOver<TRoot,TSubType> criteria)
{
this.fluentReturn = fluentReturn;
this.criteria = criteria;
@@ -39,7 +39,7 @@
/// <summary>
/// Create the ProjectionList and return to the query
/// </summary>
- public R EndSelect
+ public TReturn EndSelect
{
get
{
@@ -52,7 +52,7 @@
/// <summary>
/// Create an alias for the previous projection
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> WithAlias(Expression<Func<object>> alias)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> WithAlias(Expression<Func<object>> alias)
{
string aliasContainer = ExpressionProcessor.FindMemberExpression(alias.Body);
lastProjection = Projections.Alias(lastProjection, aliasContainer);
@@ -62,7 +62,7 @@
/// <summary>
/// Select an arbitrary projection
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> Select(IProjection projection)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> Select(IProjection projection)
{
PushProjection(projection);
return this;
@@ -71,7 +71,7 @@
/// <summary>
/// A property average value
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectAvg(Expression<Func<T, object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectAvg(Expression<Func<TSubType, object>> expression)
{
PushProjection(Projections.Avg(expression));
return this;
@@ -80,7 +80,7 @@
/// <summary>
/// A property average value
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectAvg(Expression<Func<object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectAvg(Expression<Func<object>> expression)
{
PushProjection(Projections.Avg(expression));
return this;
@@ -89,7 +89,7 @@
/// <summary>
/// A property value count
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectCount(Expression<Func<T, object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectCount(Expression<Func<TSubType, object>> expression)
{
PushProjection(Projections.Count(expression));
return this;
@@ -98,7 +98,7 @@
/// <summary>
/// A property value count
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectCount(Expression<Func<object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectCount(Expression<Func<object>> expression)
{
PushProjection(Projections.Count(expression));
return this;
@@ -107,7 +107,7 @@
/// <summary>
/// A distinct property value count
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectCountDistinct(Expression<Func<T, object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectCountDistinct(Expression<Func<TSubType, object>> expression)
{
PushProjection(Projections.CountDistinct(expression));
return this;
@@ -116,7 +116,7 @@
/// <summary>
/// A distinct property value count
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectCountDistinct(Expression<Func<object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectCountDistinct(Expression<Func<object>> expression)
{
PushProjection(Projections.CountDistinct(expression));
return this;
@@ -125,7 +125,7 @@
/// <summary>
/// A grouping property value
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectGroup(Expression<Func<T, object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectGroup(Expression<Func<TSubType, object>> expression)
{
PushProjection(Projections.Group(expression));
return this;
@@ -134,7 +134,7 @@
/// <summary>
/// A grouping property value
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectGroup(Expression<Func<object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectGroup(Expression<Func<object>> expression)
{
PushProjection(Projections.Group(expression));
return this;
@@ -143,7 +143,7 @@
/// <summary>
/// A property maximum value
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectMax(Expression<Func<T, object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectMax(Expression<Func<TSubType, object>> expression)
{
PushProjection(Projections.Max(expression));
return this;
@@ -152,7 +152,7 @@
/// <summary>
/// A property maximum value
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectMax(Expression<Func<object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectMax(Expression<Func<object>> expression)
{
PushProjection(Projections.Max(expression));
return this;
@@ -161,7 +161,7 @@
/// <summary>
/// A property minimum value
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectMin(Expression<Func<T, object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectMin(Expression<Func<TSubType, object>> expression)
{
PushProjection(Projections.Min(expression));
return this;
@@ -170,7 +170,7 @@
/// <summary>
/// A property minimum value
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectMin(Expression<Func<object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectMin(Expression<Func<object>> expression)
{
PushProjection(Projections.Min(expression));
return this;
@@ -179,7 +179,7 @@
/// <summary>
/// A projected property value
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> Select(Expression<Func<T, object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> Select(Expression<Func<TSubType, object>> expression)
{
PushProjection(Projections.Property(expression));
return this;
@@ -188,13 +188,13 @@
/// <summary>
/// A projected property value
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> Select(Expression<Func<object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> Select(Expression<Func<object>> expression)
{
PushProjection(Projections.Property(expression));
return this;
}
- public QueryOverProjectionBuilder<R, S, T> SelectSubQuery<U>(QueryOver<U> detachedQueryOver)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectSubQuery<U>(QueryOver<U> detachedQueryOver)
{
PushProjection(Projections.SubQuery(detachedQueryOver));
return this;
@@ -203,7 +203,7 @@
/// <summary>
/// A property value sum
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectSum(Expression<Func<T, object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectSum(Expression<Func<TSubType, object>> expression)
{
PushProjection(Projections.Sum(expression));
return this;
@@ -212,7 +212,7 @@
/// <summary>
/// A property value sum
/// </summary>
- public QueryOverProjectionBuilder<R, S, T> SelectSum(Expression<Func<object>> expression)
+ public QueryOverProjectionBuilder<TReturn, TRoot, TSubType> SelectSum(Expression<Func<object>> expression)
{
PushProjection(Projections.Sum(expression));
return this;
Modified: trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverRestrictionBuilder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverRestrictionBuilder.cs 2009-11-30 03:21:02 UTC (rev 4875)
+++ trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverRestrictionBuilder.cs 2009-11-30 13:28:06 UTC (rev 4876)
@@ -10,51 +10,51 @@
namespace NHibernate.Criterion.Lambda
{
- public class QueryOverRestrictionBuilder<S,T> : QueryOverRestrictionBuilderBase<QueryOver<S,T>, S, T>
+ public class QueryOverRestrictionBuilder<TRoot,TSubType> : QueryOverRestrictionBuilderBase<QueryOver<TRoot,TSubType>, TRoot, TSubType>
{
- public QueryOverRestrictionBuilder(QueryOver<S,T> root, string propertyName)
+ public QueryOverRestrictionBuilder(QueryOver<TRoot,TSubType> root, string propertyName)
: base(root, propertyName) { }
}
- public class IQueryOverRestrictionBuilder<S,T> : QueryOverRestrictionBuilderBase<IQueryOver<S,T>, S, T>
+ public class IQueryOverRestrictionBuilder<TRoot,TSubType> : QueryOverRestrictionBuilderBase<IQueryOver<TRoot,TSubType>, TRoot, TSubType>
{
- public IQueryOverRestrictionBuilder(IQueryOver<S,T> root, string propertyName)
+ public IQueryOverRestrictionBuilder(IQueryOver<TRoot,TSubType> root, string propertyName)
: base(root, propertyName) { }
}
- public class QueryOverRestrictionBuilderBase<R,S,T>
- where R : IQueryOver<S,T>
+ public class QueryOverRestrictionBuilderBase<TReturn,TRoot,TSubType>
+ where TReturn : IQueryOver<TRoot,TSubType>
{
public class LambdaBetweenBuilder
{
- private R root;
+ private TReturn root;
private string propertyName;
private object lo;
- public LambdaBetweenBuilder(R root, string propertyName, object lo)
+ public LambdaBetweenBuilder(TReturn root, string propertyName, object lo)
{
this.root = root;
this.propertyName = propertyName;
this.lo = lo;
}
- public R And(object hi)
+ public TReturn And(object hi)
{
- return (R)root.And(Restrictions.Between(propertyName, lo, hi));
+ return (TReturn)root.And(Restrictions.Between(propertyName, lo, hi));
}
}
- private R root;
+ private TReturn root;
private string propertyName;
/// <summary>
/// Constructed with property name
/// </summary>
- public QueryOverRestrictionBuilderBase(R root, string propertyName)
+ public QueryOverRestrictionBuilderBase(TReturn root, string propertyName)
{
this.root = root;
this.propertyName = propertyName;
@@ -71,97 +71,97 @@
/// <summary>
/// Apply an "in" constraint to the named property
/// </summary>
- public R IsIn(ICollection values)
+ public TReturn IsIn(ICollection values)
{
- return (R)root.And(Restrictions.In(propertyName, values));
+ return (TReturn)root.And(Restrictions.In(propertyName, values));
}
/// <summary>
/// Apply an "in" constraint to the named property
/// </summary>
- public R IsIn(object[] values)
+ public TReturn IsIn(object[] values)
{
- return (R)root.And(Restrictions.In(propertyName, values));
+ return (TReturn)root.And(Restrictions.In(propertyName, values));
}
/// <summary>
/// Apply an "in" constraint to the named property
/// </summary>
- public R IsInG<T>(ICollection<T> values)
+ public TReturn IsInG<T>(ICollection<T> values)
{
- return (R)root.And(Restrictions.InG(propertyName, values));
+ return (TReturn)root.And(Restrictions.InG(propertyName, values));
}
/// <summary>
/// A case-insensitive "like", similar to Postgres "ilike" operator
/// </summary>
- public R IsInsensitiveLike(object value)
+ public TReturn IsInsensitiveLike(object value)
{
- return (R)root.And(Restrictions.InsensitiveLike(propertyName, value));
+ return (TReturn)root.And(Restrictions.InsensitiveLike(propertyName, value));
}
/// <summary>
/// A case-insensitive "like", similar to Postgres "ilike" operator
/// </summary>
- public R IsInsensitiveLike(string value, MatchMode matchMode)
+ public TReturn IsInsensitiveLike(string value, MatchMode matchMode)
{
- return (R)root.And(Restrictions.InsensitiveLike(propertyName, value, matchMode));
+ return (TReturn)root.And(Restrictions.InsensitiveLike(propertyName, value, matchMode));
}
/// <summary>
/// Apply an "is empty" constraint to the named property
/// </summary>
- public R IsEmpty
+ public TReturn IsEmpty
{
- get { return (R)root.And(Restrictions.IsEmpty(propertyName)); }
+ get { return (TReturn)root.And(Restrictions.IsEmpty(propertyName)); }
}
/// <summary>
/// Apply a "not is empty" constraint to the named property
/// </summary>
- public R IsNotEmpty
+ public TReturn IsNotEmpty
{
- get { return (R)root.And(Restrictions.IsNotEmpty(propertyName)); }
+ get { return (TReturn)root.And(Restrictions.IsNotEmpty(propertyName)); }
}
/// <summary>
/// Apply an "is null" constraint to the named property
/// </summary>
- public R IsNull
+ public TReturn IsNull
{
- get { return (R)root.And(Restrictions.IsNull(propertyName)); }
+ get { return (TReturn)root.And(Restrictions.IsNull(propertyName)); }
}
/// <summary>
/// Apply an "not is null" constraint to the named property
/// </summary>
- public R IsNotNull
+ public TReturn IsNotNull
{
- get { return (R)root.And(Restrictions.IsNotNull(propertyName)); }
+ get { return (TReturn)root.And(Restrictions.IsNotNull(propertyName)); }
}
/// <summary>
/// Apply a "like" constraint to the named property
/// </summary>
- public R IsLike(object value)
+ public TReturn IsLike(object value)
{
- return (R)root.And(Restrictions.Like(propertyName, value));
+ return (TReturn)root.And(Restrictions.Like(propertyName, value));
}
/// <summary>
/// Apply a "like" constraint to the named property
/// </summary>
- public R IsLike(string value, MatchMode matchMode)
+ public TReturn IsLike(string value, MatchMode matchMode)
{
- return (R)root.And(Restrictions.Like(propertyName, value, matchMode));
+ return (TReturn)root.And(Restrictions.Like(propertyName, value, matchMode));
}
/// <summary>
/// Apply a "like" constraint to the named property
/// </summary>
- public R IsLike(string value, MatchMode matchMode, char? escapeChar)
+ public TReturn IsLike(string value, MatchMode matchMode, char? escapeChar)
{
- return (R)root.And(Restrictions.Like(propertyName, value, matchMode, escapeChar));
+ return (TReturn)root.And(Restrictions.Like(propertyName, value, matchMode, escapeChar));
}
}
Modified: trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryBuilder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryBuilder.cs 2009-11-30 03:21:02 UTC (rev 4875)
+++ trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryBuilder.cs 2009-11-30 13:28:06 UTC (rev 4876)
@@ -9,30 +9,30 @@
namespace NHibernate.Criterion.Lambda
{
- public class QueryOverSubqueryBuilder<S,T> : QueryOverSubqueryBuilderBase<QueryOver<S,T>, S, T, QueryOverSubqueryPropertyBuilder<S,T>>
+ public class QueryOverSubqueryBuilder<TRoot,TSubType> : QueryOverSubqueryBuilderBase<QueryOver<TRoot,TSubType>, TRoot, TSubType, QueryOverSubqueryPropertyBuilder<TRoot,TSubType>>
{
- public QueryOverSubqueryBuilder(QueryOver<S,T> root)
+ public QueryOverSubqueryBuilder(QueryOver<TRoot,TSubType> root)
: base(root) { }
}
- public class IQueryOverSubqueryBuilder<S,T> : QueryOverSubqueryBuilderBase<IQueryOver<S,T>, S, T, IQueryOverSubqueryPropertyBuilder<S,T>>
+ public class IQueryOverSubqueryBuilder<TRoot,TSubType> : QueryOverSubqueryBuilderBase<IQueryOver<TRoot,TSubType>, TRoot, TSubType, IQueryOverSubqueryPropertyBuilder<TRoot,TSubType>>
{
- public IQueryOverSubqueryBuilder(IQueryOver<S,T> root)
+ public IQueryOverSubqueryBuilder(IQueryOver<TRoot,TSubType> root)
: base(root) { }
}
- public class QueryOverSubqueryBuilderBase<R, S, T, B>
- where R : IQueryOver<S,T>
- where B : QueryOverSubqueryPropertyBuilderBase, new()
+ public class QueryOverSubqueryBuilderBase<TReturn, TRoot, TSubType, TBuilderType>
+ where TReturn : IQueryOver<TRoot,TSubType>
+ where TBuilderType : QueryOverSubqueryPropertyBuilderBase, new()
{
- protected R root;
+ protected TReturn root;
- protected QueryOverSubqueryBuilderBase(R root)
+ protected QueryOverSubqueryBuilderBase(TReturn root)
{
this.root = root;
}
@@ -40,7 +40,7 @@
/// <summary>
/// Add an Exists subquery criterion
/// </summary>
- public R WhereExists<U>(QueryOver<U> detachedQuery)
+ public TReturn WhereExists<U>(QueryOver<U> detachedQuery)
{
root.And(Subqueries.Exists(detachedQuery.DetachedCriteria));
return root;
@@ -49,7 +49,7 @@
/// <summary>
/// Add a NotExists subquery criterion
/// </summary>
- public R WhereNotExists<U>(QueryOver<U> detachedQuery)
+ public TReturn WhereNotExists<U>(QueryOver<U> detachedQuery)
{
root.And(Subqueries.NotExists(detachedQuery.DetachedCriteria));
return root;
@@ -59,9 +59,9 @@
/// Subquery expression in the format
/// .Where(t => t.Property [==, !=, >, etc.] detachedQueryOver.As<propertyType>())
/// </summary>
- public R Where(Expression<Func<T, bool>> expression)
+ public TReturn Where(Expression<Func<TSubType, bool>> expression)
{
- AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<T>(LambdaSubqueryType.Exact, expression);
+ AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<TSubType>(LambdaSubqueryType.Exact, expression);
root.And(criterion);
return root;
}
@@ -70,7 +70,7 @@
/// Subquery expression in the format
/// .Where(() => alias.Property [==, !=, >, etc.] detachedQueryOver.As<propertyType>())
/// </summary>
- public R Where(Expression<Func<bool>> expression)
+ public TReturn Where(Expression<Func<bool>> expression)
{
AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery(LambdaSubqueryType.Exact, expression);
root.And(criterion);
@@ -81,9 +81,9 @@
/// Subquery expression in the format
/// .WhereAll(t => t.Property [==, !=, >, etc.] detachedQueryOver.As<propertyType>())
/// </summary>
- public R WhereAll(Expression<Func<T, bool>> expression)
+ public TReturn WhereAll(Expression<Func<TSubType, bool>> expression)
{
- AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<T>(LambdaSubqueryType.All, expression);
+ AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<TSubType>(LambdaSubqueryType.All, expression);
root.And(criterion);
return root;
}
@@ -92,7 +92,7 @@
/// Subquery expression in the format
/// .WhereAll(() => alias.Property [==, !=, >, etc.] detachedQueryOver.As<propertyType>())
/// </summary>
- public R WhereAll(Expression<Func<bool>> expression)
+ public TReturn WhereAll(Expression<Func<bool>> expression)
{
AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery(LambdaSubqueryType.All, expression);
root.And(criterion);
@@ -103,9 +103,9 @@
/// Subquery expression in the format
/// .WhereSome(t => t.Property [==, !=, >, etc.] detachedQueryOver.As<propertyType>())
/// </summary>
- public R WhereSome(Expression<Func<T, bool>> expression)
+ public TReturn WhereSome(Expression<Func<TSubType, bool>> expression)
{
- AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<T>(LambdaSubqueryType.Some, expression);
+ AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<TSubType>(LambdaSubqueryType.Some, expression);
root.And(criterion);
return root;
}
@@ -114,28 +114,28 @@
/// Subquery expression in the format
/// .WhereSome(() => alias.Property [==, !=, >, etc.] detachedQueryOver.As<propertyType>())
/// </summary>
- public R WhereSome(Expression<Func<bool>> expression)
+ public TReturn WhereSome(Expression<Func<bool>> expression)
{
AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery(LambdaSubqueryType.Some, expression);
root.And(criterion);
return root;
}
- public B WhereProperty(Expression<Func<T, object>> expression)
+ public TBuilderType WhereProperty(Expression<Func<TSubType, object>> expression)
{
string property = ExpressionProcessor.FindMemberExpression(expression.Body);
- return (B)new B().Set(root, property, null);
+ return (TBuilderType)new TBuilderType().Set(root, property, null);
}
- public B WhereProperty(Expression<Func<object>> expression)
+ public TBuilderType WhereProperty(Expression<Func<object>> expression)
{
string property = ExpressionProcessor.FindMemberExpression(expression.Body);
- return (B)new B().Set(root, property, null);
+ return (TBuilderType)new TBuilderType().Set(root, property, null);
}
- public B WhereValue(object value)
+ public TBuilderType WhereValue(object value)
{
- return (B)new B().Set(root, null, value);
+ return (TBuilderType)new TBuilderType().Set(root, null, value);
}
}
Modified: trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryPropertyBuilder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryPropertyBuilder.cs 2009-11-30 03:21:02 UTC (rev 4875)
+++ trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryPropertyBuilder.cs 2009-11-30 13:28:06 UTC (rev 4876)
@@ -9,7 +9,7 @@
namespace NHibernate.Criterion.Lambda
{
- public class QueryOverSubqueryPropertyBuilder<S,T> : QueryOverSubqueryPropertyBuilderBase<QueryOver<S,T>, S, T>
+ public class QueryOverSubqueryPropertyBuilder<TRoot,TSubType> : QueryOverSubqueryPropertyBuilderBase<QueryOver<TRoot,TSubType>, TRoot, TSubType>
{
public QueryOverSubqueryPropertyBuilder()
@@ -17,7 +17,7 @@
}
- public class IQueryOverSubqueryPropertyBuilder<S,T> : QueryOverSubqueryPropertyBuilderBase<IQueryOver<S,T>, S, T>
+ public class IQueryOverSubqueryPropertyBuilder<TRoot,TSubType> : QueryOverSubqueryPropertyBuilderBase<IQueryOver<TRoot,TSubType>, TRoot, TSubType>
{
public IQueryOverSubqueryPropertyBuilder()
@@ -32,11 +32,11 @@
internal abstract QueryOverSubqueryPropertyBuilderBase Set(object root, string path, object value);
}
- public class QueryOverSubqueryPropertyBuilderBase<R, S, T> : QueryOverSubqueryPropertyBuilderBase
- where R : IQueryOver<S,T>
+ public class QueryOverSubqueryPropertyBuilderBase<TReturn, TRoot, TSubType> : QueryOverSubqueryPropertyBuilderBase
+ where TReturn : IQueryOver<TRoot,TSubType>
{
- protected R root;
+ protected TReturn root;
protected string path;
protected object value;
@@ -46,7 +46,7 @@
internal override QueryOverSubqueryPropertyBuilderBase Set(object root, string path, object value)
{
- this.root = (R)root;
+ this.root = (TReturn)root;
this.path = path;
this.value = value;
return this;
@@ -71,7 +71,7 @@
/// Add a property equal subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R Eq<U>(QueryOver<U> detachedCriteria)
+ public TReturn Eq<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyEq, Subqueries.Eq, detachedCriteria);
return root;
@@ -81,7 +81,7 @@
/// Add a property equal all subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R EqAll<U>(QueryOver<U> detachedCriteria)
+ public TReturn EqAll<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyEqAll, Subqueries.EqAll, detachedCriteria);
return root;
@@ -91,7 +91,7 @@
/// Create a property greater than or equal subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R Ge<U>(QueryOver<U> detachedCriteria)
+ public TReturn Ge<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyGe, Subqueries.Ge, detachedCriteria);
return root;
@@ -101,7 +101,7 @@
/// Create a property greater than or equal all subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R GeAll<U>(QueryOver<U> detachedCriteria)
+ public TReturn GeAll<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyGeAll, Subqueries.GeAll, detachedCriteria);
return root;
@@ -111,7 +111,7 @@
/// Create a property greater than or equal some subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R GeSome<U>(QueryOver<U> detachedCriteria)
+ public TReturn GeSome<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyGeSome, Subqueries.GeSome, detachedCriteria);
return root;
@@ -121,7 +121,7 @@
/// Create a property greater than subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R Gt<U>(QueryOver<U> detachedCriteria)
+ public TReturn Gt<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyGt, Subqueries.Gt, detachedCriteria);
return root;
@@ -131,7 +131,7 @@
/// Create a property greater than all subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R GtAll<U>(QueryOver<U> detachedCriteria)
+ public TReturn GtAll<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyGtAll, Subqueries.GtAll, detachedCriteria);
return root;
@@ -141,7 +141,7 @@
/// Create a property greater than some subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R GtSome<U>(QueryOver<U> detachedCriteria)
+ public TReturn GtSome<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyGtSome, Subqueries.GtSome, detachedCriteria);
return root;
@@ -151,7 +151,7 @@
/// Create a property in subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R In<U>(QueryOver<U> detachedCriteria)
+ public TReturn In<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyIn, Subqueries.In, detachedCriteria);
return root;
@@ -161,7 +161,7 @@
/// Create a property less than or equal subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R Le<U>(QueryOver<U> detachedCriteria)
+ public TReturn Le<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyLe, Subqueries.Le, detachedCriteria);
return root;
@@ -171,7 +171,7 @@
/// Create a property less than or equal all subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R LeAll<U>(QueryOver<U> detachedCriteria)
+ public TReturn LeAll<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyLeAll, Subqueries.LeAll, detachedCriteria);
return root;
@@ -181,7 +181,7 @@
/// Create a property less than or equal some subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R LeSome<U>(QueryOver<U> detachedCriteria)
+ public TReturn LeSome<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyLeSome, Subqueries.LeSome, detachedCriteria);
return root;
@@ -191,7 +191,7 @@
/// Create a property less than subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R Lt<U>(QueryOver<U> detachedCriteria)
+ public TReturn Lt<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyLt, Subqueries.Lt, detachedCriteria);
return root;
@@ -201,7 +201,7 @@
/// Create a property less than all subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R LtAll<U>(QueryOver<U> detachedCriteria)
+ public TReturn LtAll<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyLtAll, Subqueries.LtAll, detachedCriteria);
return root;
@@ -211,7 +211,7 @@
/// Create a property less than some subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R LtSome<U>(QueryOver<U> detachedCriteria)
+ public TReturn LtSome<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyLtSome, Subqueries.LtSome, detachedCriteria);
return root;
@@ -221,7 +221,7 @@
/// Create a property not equal subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R Ne<U>(QueryOver<U> detachedCriteria)
+ public TReturn Ne<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyNe, Subqueries.Ne, detachedCriteria);
return root;
@@ -231,7 +231,7 @@
/// Create a property not in subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
- public R NotIn<U>(QueryOver<U> detachedCriteria)
+ public TReturn NotIn<U>(QueryOver<U> detachedCriteria)
{
AddSubquery(Subqueries.PropertyNotIn, Subqueries.NotIn, detachedCriteria);
return root;
Modified: trunk/nhibernate/src/NHibernate/Criterion/QueryOver.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/QueryOver.cs 2009-11-30 03:21:02 UTC (rev 4875)
+++ trunk/nhibernate/src/NHibernate/Criterion/QueryOver.cs 2009-11-30 13:28:06 UTC (rev 4876)
@@ -4,6 +4,7 @@
using System.Linq.Expressions;
using NHibernate.Criterion.Lambda;
+using NHibernate.Engine;
using NHibernate.Impl;
using NHibernate.SqlCommand;
@@ -14,8 +15,8 @@
public class QueryOver
{
- protected ICriteria _criteria;
- protected CriteriaImpl _impl;
+ protected ICriteria criteria;
+ protected CriteriaImpl impl;
protected QueryOver() { }
@@ -31,74 +32,83 @@
public ICriteria UnderlyingCriteria
{
- get { return _criteria; }
+ get { return criteria; }
}
public DetachedCriteria DetachedCriteria
{
- get { return new DetachedCriteria(_impl, _impl); }
+ get { return new DetachedCriteria(impl, impl); }
}
}
[Serializable]
- public class QueryOver<T> : QueryOver, IQueryOver<T>
+ public class QueryOver<TRoot> : QueryOver, IQueryOver<TRoot>
{
- private IList<T> List()
+ private IList<TRoot> List()
{
- return _criteria.List<T>();
+ return criteria.List<TRoot>();
}
private IList<U> List<U>()
{
- return _criteria.List<U>();
+ return criteria.List<U>();
}
- private T UniqueResult()
+ private TRoot UniqueResult()
{
- return _criteria.UniqueResult<T>();
+ return criteria.UniqueResult<TRoot>();
}
private U UniqueResult<U>()
{
- return _criteria.UniqueResult<U>();
+ return criteria.UniqueResult<U>();
}
- private IEnumerable<T> Future()
+ private IEnumerable<TRoot> Future()
{
- return _criteria.Future<T>();
+ return criteria.Future<TRoot>();
}
private IEnumerable<U> Future<U>()
{
- return _criteria.Future<U>();
+ return criteria.Future<U>();
}
- private IFutureValue<T> FutureValue()
+ private IFutureValue<TRoot> FutureValue()
{
- return _criteria.FutureValue<T>();
+ return criteria.FutureValue<TRoot>();
}
private IFutureValue<U> FutureValue<U>()
{
- return _criteria.FutureValue<U>();
+ return criteria.FutureValue<U>();
}
/// <summary>
- /// Get an executable instance of <c>IQueryOver<T></c>,
+ /// Get an executable instance of <c>IQueryOver<TRoot></c>,
/// to actually run the query.</summary>
- public IQueryOver<T> GetExecutableQueryOver(ISession session)
+ public IQueryOver<TRoot,TRoot> GetExecutableQueryOver(ISession session)
{
- _impl.Session = session.GetSessionImplementation();
- return this;
+ impl.Session = session.GetSessionImplementation();
+ return new QueryOver<TRoot,TRoot>(impl);
}
/// <summary>
+ /// Get an executable instance of <c>IQueryOver<TRoot></c>,
+ /// to actually run the query.</summary>
+ public IQueryOver<TRoot,TRoot> GetExecutableQueryOver(IStatelessSession session)
+ {
+ impl.Session = (ISessionImplementor)session;
+ return new QueryOver<TRoot,TRoot>(impl);
+ }
+
+ /// <summary>
/// Method to allow comparison of detached query in Lambda expression
/// e.g., p => p.Name == myQuery.As<string>
/// </summary>
- /// <typeparam name="S">type returned by query</typeparam>
+ /// <typeparam name="S">type returned (projected) by query</typeparam>
/// <returns>throws an exception if evaluated directly at runtime.</returns>
public S As<S>()
{
@@ -106,358 +116,358 @@
}
- ICriteria IQueryOver<T>.UnderlyingCriteria
+ ICriteria IQueryOver<TRoot>.UnderlyingCriteria
{ get { return UnderlyingCriteria; } }
- IList<T> IQueryOver<T>.List()
+ IList<TRoot> IQueryOver<TRoot>.List()
{ return List(); }
- IList<U> IQueryOver<T>.List<U>()
+ IList<U> IQueryOver<TRoot>.List<U>()
{ return List<U>(); }
- T IQueryOver<T>.UniqueResult()
+ TRoot IQueryOver<TRoot>.UniqueResult()
{ return UniqueResult(); }
- U IQueryOver<T>.UniqueResult<U>()
+ U IQueryOver<TRoot>.UniqueResult<U>()
{ return UniqueResult<U>(); }
- IEnumerable<T> IQueryOver<T>.Future()
+ IEnumerable<TRoot> IQueryOver<TRoot>.Future()
{ return Future(); }
- IEnumerable<U> IQueryOver<T>.Future<U>()
+ IEnumerable<U> IQueryOver<TRoot>.Future<U>()
{ return Future<U>(); }
- IFutureValue<T> IQueryOver<T>.FutureValue()
+ IFutureValue<TRoot> IQueryOver<TRoot>.FutureValue()
{ return FutureValue(); }
- IFutureValue<U> IQueryOver<T>.FutureValue<U>()
+ IFutureValue<U> IQueryOver<TRoot>.FutureValue<U>()
{ return FutureValue<U>(); }
}
/// <summary>
- /// Implementation of the <see cref="IQueryOver<T>"/> interface
+ /// Implementation of the <see cref="IQueryOver<TRoot, TSubType>"/> interface
/// </summary>
[Serializable]
- public class QueryOver<R,T> : QueryOver<R>, IQueryOver<R,T>
+ public class QueryOver<TRoot,TSubType> : QueryOver<TRoot>, IQueryOver<TRoot,TSubType>
{
protected internal QueryOver()
{
- _impl = new CriteriaImpl(typeof(T), null);
- _criteria = _impl;
+ impl = new CriteriaImpl(typeof(TRoot), null);
+ criteria = impl;
}
- protected internal QueryOver(Expression<Func<T>> alias)
+ protected internal QueryOver(Expression<Func<TSubType>> alias)
{
string aliasPath = ExpressionProcessor.FindMemberExpression(alias.Body);
- _impl = new CriteriaImpl(typeof(T), aliasPath, null);
- _criteria = _impl;
+ impl = new CriteriaImpl(typeof(TRoot), aliasPath, null);
+ criteria = impl;
}
protected internal QueryOver(CriteriaImpl impl)
{
- _impl = impl;
- _criteria = impl;
+ this.impl = impl;
+ this.criteria = impl;
}
protected internal QueryOver(CriteriaImpl rootImpl, ICriteria criteria)
{
- _impl = rootImpl;
- _criteria = criteria;
+ this.impl = rootImpl;
+ this.criteria = criteria;
}
- public QueryOver<R,T> And(Expression<Func<T, bool>> expression)
+ public QueryOver<TRoot,TSubType> And(Expression<Func<TSubType, bool>> expression)
{
return Add(expression);
}
- public QueryOver<R,T> And(Expression<Func<bool>> expression)
+ public QueryOver<TRoot,TSubType> And(Expression<Func<bool>> expression)
{
return Add(expression);
}
- public QueryOver<R,T> And(ICriterion expression)
+ public QueryOver<TRoot,TSubType> And(ICriterion expression)
{
return Add(expression);
}
- public QueryOver<R,T> AndNot(Expression<Func<T, bool>> expression)
+ public QueryOver<TRoot,TSubType> AndNot(Expression<Func<TSubType, bool>> expression)
{
return AddNot(expression);
}
- public QueryOver<R,T> AndNot(Expression<Func<bool>> expression)
+ public QueryOver<TRoot,TSubType> AndNot(Expression<Func<bool>> expression)
{
return AddNot(expression);
}
- public QueryOverRestrictionBuilder<R,T> AndRestrictionOn(Expression<Func<T, object>> expression)
+ public QueryOverRestrictionBuilder<TRoot,TSubType> AndRestrictionOn(Expression<Func<TSubType, object>> expression)
{
- return new QueryOverRestrictionBuilder<R,T>(this, ExpressionProcessor.FindMemberExpression(expression.Body));
+ return new QueryOverRestrictionBuilder<TRoot,TSubType>(this, ExpressionProcessor.FindMemberExpression(expression.Body));
}
- public QueryOverRestrictionBuilder<R,T> AndRestrictionOn(Expression<Func<object>> expression)
+ public QueryOverRestrictionBuilder<TRoot,TSubType> AndRestrictionOn(Expression<Func<object>> expression)
{
- return new QueryOverRestrictionBuilder<R,T>(this, ExpressionProcessor.FindMemberExpression(expression.Body));
+ return new QueryOverRestrictionBuilder<TRoot,TSubType>(this, ExpressionProcessor.FindMemberExpression(expression.Body));
}
- public QueryOver<R,T> Where(Expression<Func<T, bool>> expression)
+ public QueryOver<TRoot,TSubType> Where(Expression<Func<TSubType, bool>> expression)
{
return Add(expression);
}
- public QueryOver<R,T> Where(Expression<Func<bool>> expression)
+ public QueryOver<TRoot,TSubType> Where(Expression<Func<bool>> expression)
{
return Add(expression);
}
- public QueryOver<R,T> Where(ICriterion expression)
+ public QueryOver<TRoot,TSubType> Where(ICriterion expression)
{
return Add(expression);
}
- public QueryOver<R,T> WhereNot(Expression<Func<T, bool>> expression)
+ public QueryOver<TRoot,TSubType> WhereNot(Expression<Func<TSubType, bool>> expression)
{
return AddNot(expression);
}
- public QueryOver<R,T> WhereNot(Expression<Func<bool>> expression)
+ public QueryOver<TRoot,TSubType> WhereNot(Expression<Func<bool>> expression)
{
return AddNot(expression);
}
- public QueryOverRestrictionBuilder<R,T> WhereRestrictionOn(Expression<Func<T, object>> expression)
+ public QueryOverRestrictionBuilder<TRoot,TSubType> WhereRestrictionOn(Expression<Func<TSubType, object>> expression)
{
- return new QueryOverRestrictionBuilder<R,T>(this, ExpressionProcessor.FindMemberExpression(expression.Body));
+ return new QueryOverRestrictionBuilder<TRoot,TSubType>(this, ExpressionProcessor.FindMemberExpression(expression.Body));
}
- public QueryOverRestrictionBuilder<R,T> WhereRestrictionOn(Expression<Func<object>> expression)
+ public QueryOverRestrictionBuilder<TRoot,TSubType> WhereRestrictionOn(Expression<Func<object>> expression)
{
- return new QueryOverRestrictionBuilder<R,T>(this, ExpressionProcessor.FindMemberExpression(expression.Body));
+ return new QueryOverRestrictionBuilder<TRoot,TSubType>(this, ExpressionProcessor.FindMemberExpression(expression.Body));
}
- public QueryOver<R,T> Select(params Expression<Func<R, object>>[] projections)
+ public QueryOver<TRoot,TSubType> Select(params Expression<Func<TRoot, object>>[] projections)
{
List<IProjection> projectionList = new List<IProjection>();
foreach (var projection in projections)
projectionList.Add(Projections.Property(ExpressionProcessor.FindMemberExpression(projection.Body)));
- _criteria.SetProjection(projectionList.ToArray());
+ criteria.SetProjection(projectionList.ToArray());
return this;
}
- public QueryOver<R,T> Select(params IProjection[] projections)
+ public QueryOver<TRoot,TSubType> Select(params IProjection[] projections)
{
- _criteria.SetProjection(projections);
+ criteria.SetProjection(projections);
return this;
}
- QueryOverProjectionBuilder<QueryOver<R,T>, R, T> SelectList
+ QueryOverProjectionBuilder<QueryOver<TRoot,TSubType>, TRoot, TSubType> SelectList
{
- get { return new QueryOverProjectionBuilder<QueryOver<R,T>, R, T>(this, this); }
+ get { return new QueryOverProjectionBuilder<QueryOver<TRoot,TSubType>, TRoot, TSubType>(this, this); }
}
- public QueryOverOrderBuilder<R,T> OrderBy(Expression<Func<T, object>> path)
+ public QueryOverOrderBuilder<TRoot,TSubType> OrderBy(Expression<Func<TSubType, object>> path)
{
- return new QueryOverOrderBuilder<R,T>(this, path);
+ return new QueryOverOrderBuilder<TRoot,TSubType>(this, path);
}
- public QueryOverOrderBuilder<R,T> OrderBy(Expression<Func<object>> path)
+ public QueryOverOrderBuilder<TRoot,TSubType> OrderBy(Expression<Func<object>> path)
{
- return new QueryOverOrderBuilder<R,T>(this, path);
+ return new QueryOverOrderBuilder<TRoot,TSubType>(this, path);
}
- public QueryOverOrderBuilder<R,T> ThenBy(Expression<Func<T, object>> path)
+ public QueryOverOrderBuilder<TRoot,TSubType> ThenBy(Expression<Func<TSubType, object>> path)
{
- return new QueryOverOrderBuilder<R,T>(this, path);
+ return new QueryOverOrderBuilder<TRoot,TSubType>(this, path);
}
- public QueryOverOrderBuilder<R,T> ThenBy(Expression<Func<object>> path)
+ public QueryOverOrderBuilder<TRoot,TSubType> ThenBy(Expression<Func<object>> path)
{
- return new QueryOverOrderBuilder<R,T>(this, path);
+ return new QueryOverOrderBuilder<TRoot,TSubType>(this, path);
}
- public QueryOver<R,T> Skip(int firstResult)
+ public QueryOver<TRoot,TSubType> Skip(int firstResult)
{
- _criteria.SetFirstResult(firstResult);
+ criteria.SetFirstResult(firstResult);
return this;
}
- public QueryOver<R,T> Take(int maxResults)
+ public QueryOver<TRoot,TSubType> Take(int maxResults)
{
- _criteria.SetMaxResults(maxResults);
+ criteria.SetMaxResults(maxResults);
return this;
}
- public QueryOver<R,T> Cacheable()
+ public QueryOver<TRoot,TSubType> Cacheable()
{
- _criteria.SetCacheable(true);
+ criteria.SetCacheable(true);
return this;
}
- public QueryOver<R,T> CacheMode(CacheMode cacheMode)
+ public QueryOver<TRoot,TSubType> CacheMode(CacheMode cacheMode)
{
- _criteria.SetCacheMode(cacheMode);
+ criteria.SetCacheMode(cacheMode);
return this;
}
- public QueryOver<R,T> CacheRegion(string cacheRegion)
+ public QueryOver<TRoot,TSubType> CacheRegion(string cacheRegion)
{
- _criteria.SetCacheRegion(cacheRegion);
+ criteria.SetCacheRegion(cacheRegion);
return this;
}
- public QueryOverSubqueryBuilder<R,T> WithSubquery
+ public QueryOverSubqueryBuilder<TRoot,TSubType> WithSubquery
{
- get { return new QueryOverSubqueryBuilder<R,T>(this); }
+ get { return new QueryOverSubqueryBuilder<TRoot,TSubType>(this); }
}
- public QueryOverFetchBuilder<R,T> Fetch(Expression<Func<R, object>> path)
+ public QueryOverFetchBuilder<TRoot,TSubType> Fetch(Expression<Func<TRoot, object>> path)
{
- return new QueryOverFetchBuilder<R,T>(this, path);
+ return new QueryOverFetchBuilder<TRoot,TSubType>(this, path);
}
- public QueryOverLockBuilder<R,T> Lock()
+ public QueryOverLockBuilder<TRoot,TSubType> Lock()
{
- return new QueryOverLockBuilder<R,T>(this, null);
+ return new QueryOverLockBuilder<TRoot,TSubType>(this, null);
}
- public QueryOverLockBuilder<R,T> Lock(Expression<Func<object>> alias)
+ public QueryOverLockBuilder<TRoot,TSubType> Lock(Expression<Func<object>> alias)
{
- return new QueryOverLockBuilder<R,T>(this, alias);
+ return new QueryOverLockBuilder<TRoot,TSubType>(this, alias);
}
- public QueryOver<R,U> JoinQueryOver<U>(Expression<Func<T, U>> path)
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path)
{
- return new QueryOver<R,U>(_impl,
- _criteria.CreateCriteria(
+ return new QueryOver<TRoot,U>(impl,
+ criteria.CreateCriteria(
ExpressionProcessor.FindMemberExpression(path.Body)));
}
- public QueryOver<R,U> JoinQueryOver<U>(Expression<Func<U>> path)
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path)
{
- return new QueryOver<R,U>(_impl,
- _criteria.CreateCriteria(
+ return new QueryOver<TRoot,U>(impl,
+ criteria.CreateCriteria(
ExpressionProcessor.FindMemberExpression(path.Body)));
}
- public QueryOver<R,U> JoinQueryOver<U>(Expression<Func<T, U>> path, Expression<Func<U>> alias)
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path, Expression<Func<U>> alias)
{
- return new QueryOver<R,U>(_impl,
- _criteria.CreateCriteria(
+ return new QueryOver<TRoot,U>(impl,
+ criteria.CreateCriteria(
ExpressionProcessor.FindMemberExpression(path.Body),
ExpressionProcessor.FindMemberExpression(alias.Body)));
}
- public QueryOver<R,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias)
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<U>> path, Expression<Func<U>> alias)
{
- return new QueryOver<R,U>(_impl,
- _criteria.CreateCriteria(
+ return new QueryOver<TRoot,U>(impl,
+ criteria.CreateCriteria(
ExpressionProcessor.FindMemberExpression(path.Body),
ExpressionProcessor.FindMemberExpression(alias.Body)));
}
- public QueryOver<R,U> JoinQueryOver<U>(Expression<Func<T, U>> path, JoinType joinType)
+ public QueryOver<TRoot,U> JoinQueryOver<U>(Expression<Func<TSubType, U>> path, JoinType joinType)
{
- return new QueryOver<R,U>(_impl,
- _criteria.CreateCriteria(
+ return new QueryOver<TRoot,U>(impl,
+ criteria.CreateCriteria(
ExpressionProcessor.FindMemberExpression(path.Body),
joinType));
}
- public QueryOver<R,U> JoinQueryOver<U>(Expression<Func<U>> path,...
[truncated message content] |
