From: <ric...@us...> - 2009-11-18 15:17:28
|
Revision: 4834 http://nhibernate.svn.sourceforge.net/nhibernate/?rev=4834&view=rev Author: ricbrown Date: 2009-11-18 15:17:20 +0000 (Wed, 18 Nov 2009) Log Message: ----------- Added Subqueries overloads to create ICriterion for QueryOver. Modified Paths: -------------- trunk/nhibernate/src/NHibernate/Criterion/Subqueries.cs trunk/nhibernate/src/NHibernate/NHibernate.csproj trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/SubqueryFixture.cs Added Paths: ----------- trunk/nhibernate/src/NHibernate/Criterion/Lambda/LambdaSubqueryBuilder.cs Added: trunk/nhibernate/src/NHibernate/Criterion/Lambda/LambdaSubqueryBuilder.cs =================================================================== --- trunk/nhibernate/src/NHibernate/Criterion/Lambda/LambdaSubqueryBuilder.cs (rev 0) +++ trunk/nhibernate/src/NHibernate/Criterion/Lambda/LambdaSubqueryBuilder.cs 2009-11-18 15:17:20 UTC (rev 4834) @@ -0,0 +1,195 @@ + +using System; +using System.Collections.Generic; +using System.Linq.Expressions; + +using NHibernate.Impl; +using NHibernate.SqlCommand; + +namespace NHibernate.Criterion.Lambda +{ + + public class LambdaSubqueryBuilder + { + private string propertyName; + private object value; + + /// <summary> + /// Constructed with property name + /// </summary> + public LambdaSubqueryBuilder(string propertyName, object value) + { + this.propertyName = propertyName; + this.value = value; + } + + private AbstractCriterion CreatePropertyCriterion<U>( Func<string, DetachedCriteria, AbstractCriterion> propertyFactoryMethod, + Func<object, DetachedCriteria, AbstractCriterion> valueFactoryMethod, + QueryOver<U> detachedCriteria) + { + if (propertyName != null) + { + return propertyFactoryMethod(propertyName, detachedCriteria.DetachedCriteria); + } + else + { + return valueFactoryMethod(value, detachedCriteria.DetachedCriteria); + } + } + + /// <summary> + /// Add a property equal subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion Eq<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyEq, Subqueries.Eq, detachedCriteria); + } + + /// <summary> + /// Add a property equal all subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion EqAll<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyEqAll, Subqueries.EqAll, detachedCriteria); + } + + /// <summary> + /// Create a property greater than or equal subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion Ge<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyGe, Subqueries.Ge, detachedCriteria); + } + + /// <summary> + /// Create a property greater than or equal all subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion GeAll<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyGeAll, Subqueries.GeAll, detachedCriteria); + } + + /// <summary> + /// Create a property greater than or equal some subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion GeSome<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyGeSome, Subqueries.GeSome, detachedCriteria); + } + + /// <summary> + /// Create a property greater than subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion Gt<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyGt, Subqueries.Gt, detachedCriteria); + } + + /// <summary> + /// Create a property greater than all subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion GtAll<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyGtAll, Subqueries.GtAll, detachedCriteria); + } + + /// <summary> + /// Create a property greater than some subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion GtSome<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyGtSome, Subqueries.GtSome, detachedCriteria); + } + + /// <summary> + /// Create a property in subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion In<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyIn, Subqueries.In, detachedCriteria); + } + + /// <summary> + /// Create a property less than or equal subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion Le<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyLe, Subqueries.Le, detachedCriteria); + } + + /// <summary> + /// Create a property less than or equal all subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion LeAll<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyLeAll, Subqueries.LeAll, detachedCriteria); + } + + /// <summary> + /// Create a property less than or equal some subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion LeSome<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyLeSome, Subqueries.LeSome, detachedCriteria); + } + + /// <summary> + /// Create a property less than subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion Lt<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyLt, Subqueries.Lt, detachedCriteria); + } + + /// <summary> + /// Create a property less than all subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion LtAll<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyLtAll, Subqueries.LtAll, detachedCriteria); + } + + /// <summary> + /// Create a property less than some subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion LtSome<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyLtSome, Subqueries.LtSome, detachedCriteria); + } + + /// <summary> + /// Create a property not equal subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion Ne<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyNe, Subqueries.Ne, detachedCriteria); + } + + /// <summary> + /// Create a property not in subquery criterion + /// </summary> + /// <param name="detachedCriteria">detached subquery</param> + public AbstractCriterion NotIn<U>(QueryOver<U> detachedCriteria) + { + return CreatePropertyCriterion(Subqueries.PropertyNotIn, Subqueries.NotIn, detachedCriteria); + } + + } + +} Modified: trunk/nhibernate/src/NHibernate/Criterion/Subqueries.cs =================================================================== --- trunk/nhibernate/src/NHibernate/Criterion/Subqueries.cs 2009-11-18 12:29:32 UTC (rev 4833) +++ trunk/nhibernate/src/NHibernate/Criterion/Subqueries.cs 2009-11-18 15:17:20 UTC (rev 4834) @@ -1,5 +1,9 @@ using System; +using System.Linq.Expressions; +using NHibernate.Criterion.Lambda; +using NHibernate.Impl; + namespace NHibernate.Criterion { /// <summary> @@ -195,5 +199,124 @@ { return new SelectSubqueryExpression(detachedCriteria); } + + /// <summary> + /// Create a ICriterion for the specified property subquery expression + /// </summary> + /// <typeparam name="T">generic type</typeparam> + /// <param name="expression">lambda expression</param> + /// <returns>returns LambdaSubqueryBuilder</returns> + public static LambdaSubqueryBuilder WhereProperty<T>(Expression<Func<T, object>> expression) + { + string property = ExpressionProcessor.FindMemberExpression(expression.Body); + return new LambdaSubqueryBuilder(property, null); + } + + /// <summary> + /// Create a ICriterion for the specified property subquery expression + /// </summary> + /// <param name="expression">lambda expression</param> + /// <returns>returns LambdaSubqueryBuilder</returns> + public static LambdaSubqueryBuilder WhereProperty(Expression<Func<object>> expression) + { + string property = ExpressionProcessor.FindMemberExpression(expression.Body); + return new LambdaSubqueryBuilder(property, null); + } + + /// <summary> + /// Create a ICriterion for the specified value subquery expression + /// </summary> + /// <param name="value">value</param> + /// <returns>returns LambdaSubqueryBuilder</returns> + public static LambdaSubqueryBuilder WhereValue(object value) + { + return new LambdaSubqueryBuilder(null, value); + } + + /// <summary> + /// Create ICriterion for subquery expression using lambda syntax + /// </summary> + /// <typeparam name="T">type of property</typeparam> + /// <param name="expression">lambda expression</param> + /// <returns>NHibernate.ICriterion.AbstractCriterion</returns> + public static AbstractCriterion Where<T>(Expression<Func<T, bool>> expression) + { + AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<T>(LambdaSubqueryType.Exact, expression); + return criterion; + } + + /// <summary> + /// Create ICriterion for (exact) subquery expression using lambda syntax + /// </summary> + /// <param name="expression">lambda expression</param> + /// <returns>NHibernate.ICriterion.AbstractCriterion</returns> + public static AbstractCriterion Where(Expression<Func<bool>> expression) + { + AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery(LambdaSubqueryType.Exact, expression); + return criterion; + } + + /// <summary> + /// Create ICriterion for (all) subquery expression using lambda syntax + /// </summary> + /// <typeparam name="T">type of property</typeparam> + /// <param name="expression">lambda expression</param> + /// <returns>NHibernate.ICriterion.AbstractCriterion</returns> + public static AbstractCriterion WhereAll<T>(Expression<Func<T, bool>> expression) + { + AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<T>(LambdaSubqueryType.All, expression); + return criterion; + } + + /// <summary> + /// Create ICriterion for (all) subquery expression using lambda syntax + /// </summary> + /// <param name="expression">lambda expression</param> + /// <returns>NHibernate.ICriterion.AbstractCriterion</returns> + public static AbstractCriterion WhereAll(Expression<Func<bool>> expression) + { + AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery(LambdaSubqueryType.All, expression); + return criterion; + } + + /// <summary> + /// Create ICriterion for (some) subquery expression using lambda syntax + /// </summary> + /// <typeparam name="T">type of property</typeparam> + /// <param name="expression">lambda expression</param> + /// <returns>NHibernate.ICriterion.AbstractCriterion</returns> + public static AbstractCriterion WhereSome<T>(Expression<Func<T, bool>> expression) + { + AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<T>(LambdaSubqueryType.Some, expression); + return criterion; + } + + /// <summary> + /// Create ICriterion for (some) subquery expression using lambda syntax + /// </summary> + /// <param name="expression">lambda expression</param> + /// <returns>NHibernate.ICriterion.AbstractCriterion</returns> + public static AbstractCriterion WhereSome(Expression<Func<bool>> expression) + { + AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery(LambdaSubqueryType.Some, expression); + return criterion; + } + + /// <summary> + /// Add an Exists subquery criterion + /// </summary> + public static AbstractCriterion WhereExists<U>(QueryOver<U> detachedQuery) + { + return Subqueries.Exists(detachedQuery.DetachedCriteria); + } + + /// <summary> + /// Add a NotExists subquery criterion + /// </summary> + public static AbstractCriterion WhereNotExists<U>(QueryOver<U> detachedQuery) + { + return Subqueries.NotExists(detachedQuery.DetachedCriteria); + } + } } Modified: trunk/nhibernate/src/NHibernate/NHibernate.csproj =================================================================== --- trunk/nhibernate/src/NHibernate/NHibernate.csproj 2009-11-18 12:29:32 UTC (rev 4833) +++ trunk/nhibernate/src/NHibernate/NHibernate.csproj 2009-11-18 15:17:20 UTC (rev 4834) @@ -505,6 +505,7 @@ <Compile Include="Context\WcfOperationSessionContext.cs" /> <Compile Include="Criterion\GroupedProjection.cs" /> <Compile Include="Criterion\IPropertyProjection.cs" /> + <Compile Include="Criterion\Lambda\LambdaSubqueryBuilder.cs" /> <Compile Include="Criterion\Lambda\QueryOverFetchBuilder.cs" /> <Compile Include="Criterion\Lambda\QueryOverJoinBuilder.cs" /> <Compile Include="Criterion\Lambda\QueryOverLockBuilder.cs" /> Modified: trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/SubqueryFixture.cs =================================================================== --- trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/SubqueryFixture.cs 2009-11-18 12:29:32 UTC (rev 4833) +++ trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/SubqueryFixture.cs 2009-11-18 15:17:20 UTC (rev 4834) @@ -103,6 +103,34 @@ } [Test] + public void PropertyCriterion() + { + ICriteria expected = + CreateTestCriteria(typeof(Person)) + .Add(Subqueries.PropertyEq("Name", DetachedCriteriaName)) + .Add(Subqueries.PropertyGe("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyGt("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyIn("Name", DetachedCriteriaName)) + .Add(Subqueries.PropertyLe("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyLt("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyNe("Name", DetachedCriteriaName)) + .Add(Subqueries.PropertyNotIn("Name", DetachedCriteriaName)); + + var actual = + CreateTestQueryOver<Person>() + .And(Subqueries.WhereProperty<Person>(p => p.Name).Eq(DetachedQueryOverName)) + .And(Subqueries.WhereProperty<Person>(p => p.Age).Ge(DetachedQueryOverAge)) + .And(Subqueries.WhereProperty<Person>(p => p.Age).Gt(DetachedQueryOverAge)) + .And(Subqueries.WhereProperty<Person>(p => p.Name).In(DetachedQueryOverName)) + .And(Subqueries.WhereProperty<Person>(p => p.Age).Le(DetachedQueryOverAge)) + .And(Subqueries.WhereProperty<Person>(p => p.Age).Lt(DetachedQueryOverAge)) + .And(Subqueries.WhereProperty<Person>(p => p.Name).Ne(DetachedQueryOverName)) + .And(Subqueries.WhereProperty<Person>(p => p.Name).NotIn(DetachedQueryOverName)); + + AssertCriteriaAreEqual(expected, actual); + } + + [Test] public void PropertyAlias() { ICriteria expected = @@ -118,6 +146,21 @@ } [Test] + public void PropertyAliasCriterion() + { + ICriteria expected = + CreateTestCriteria(typeof(Person), "personAlias") + .Add(Subqueries.PropertyEq("personAlias.Name", DetachedCriteriaName)); + + Person personAlias = null; + var actual = + CreateTestQueryOver<Person>(() => personAlias) + .And(Subqueries.WhereProperty(() => personAlias.Name).Eq(DetachedQueryOverName)); + + AssertCriteriaAreEqual(expected, actual); + } + + [Test] public void PropertyAll() { ICriteria expected = @@ -140,6 +183,28 @@ } [Test] + public void PropertyAllCriterion() + { + ICriteria expected = + CreateTestCriteria(typeof(Person)) + .Add(Subqueries.PropertyEqAll("Name", DetachedCriteriaName)) + .Add(Subqueries.PropertyGeAll("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyGtAll("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyLeAll("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyLtAll("Age", DetachedCriteriaAge)); + + var actual = + CreateTestQueryOver<Person>() + .And(Subqueries.WhereProperty<Person>(p => p.Name).EqAll(DetachedQueryOverName)) + .And(Subqueries.WhereProperty<Person>(p => p.Age).GeAll(DetachedQueryOverAge)) + .And(Subqueries.WhereProperty<Person>(p => p.Age).GtAll(DetachedQueryOverAge)) + .And(Subqueries.WhereProperty<Person>(p => p.Age).LeAll(DetachedQueryOverAge)) + .And(Subqueries.WhereProperty<Person>(p => p.Age).LtAll(DetachedQueryOverAge)); + + AssertCriteriaAreEqual(expected, actual); + } + + [Test] public void PropertySome() { ICriteria expected = @@ -160,6 +225,26 @@ } [Test] + public void PropertySomeCriterion() + { + ICriteria expected = + CreateTestCriteria(typeof(Person)) + .Add(Subqueries.PropertyGeSome("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyGtSome("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyLeSome("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyLtSome("Age", DetachedCriteriaAge)); + + var actual = + CreateTestQueryOver<Person>() + .And(Subqueries.WhereProperty<Person>(p => p.Age).GeSome(DetachedQueryOverAge)) + .And(Subqueries.WhereProperty<Person>(p => p.Age).GtSome(DetachedQueryOverAge)) + .And(Subqueries.WhereProperty<Person>(p => p.Age).LeSome(DetachedQueryOverAge)) + .And(Subqueries.WhereProperty<Person>(p => p.Age).LtSome(DetachedQueryOverAge)); + + AssertCriteriaAreEqual(expected, actual); + } + + [Test] public void PropertyAsSyntax() { ICriteria expected = @@ -184,6 +269,20 @@ } [Test] + public void PropertyAsSyntaxCriterion() + { + ICriteria expected = + CreateTestCriteria(typeof(Person)) + .Add(Subqueries.PropertyEq("Name", DetachedCriteriaName)); + + var actual = + CreateTestQueryOver<Person>() + .And(Subqueries.Where<Person>(p => p.Name == DetachedQueryOverName.As<string>())); + + AssertCriteriaAreEqual(expected, actual); + } + + [Test] public void PropertyAsSyntaxAlias() { ICriteria expected = @@ -203,6 +302,25 @@ } [Test] + public void PropertyAsSyntaxAliasCriterion() + { + ICriteria expected = + CreateTestCriteria(typeof(Person), "personAlias") + .Add(Subqueries.PropertyEq("personAlias.Name", DetachedCriteriaName)) + .Add(Subqueries.PropertyGtSome("personAlias.Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyLtAll("personAlias.Age", DetachedCriteriaAge)); + + Person personAlias = null; + var actual = + CreateTestQueryOver<Person>(() => personAlias) + .And(Subqueries.Where(() => personAlias.Name == DetachedQueryOverName.As<string>())) + .And(Subqueries.WhereSome(() => personAlias.Age > DetachedQueryOverAge.As<int>())) + .And(Subqueries.WhereAll(() => personAlias.Age < DetachedQueryOverAge.As<int>())); + + AssertCriteriaAreEqual(expected, actual); + } + + [Test] public void PropertyAsAllSyntax() { ICriteria expected = @@ -225,6 +343,28 @@ } [Test] + public void PropertyAsAllSyntaxCriterion() + { + ICriteria expected = + CreateTestCriteria(typeof(Person)) + .Add(Subqueries.PropertyEqAll("Name", DetachedCriteriaName)) + .Add(Subqueries.PropertyGeAll("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyGtAll("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyLeAll("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyLtAll("Age", DetachedCriteriaAge)); + + var actual = + CreateTestQueryOver<Person>() + .And(Subqueries.WhereAll<Person>(p => p.Name == DetachedQueryOverName.As<string>())) + .And(Subqueries.WhereAll<Person>(p => p.Age >= DetachedQueryOverAge.As<int>())) + .And(Subqueries.WhereAll<Person>(p => p.Age > DetachedQueryOverAge.As<int>())) + .And(Subqueries.WhereAll<Person>(p => p.Age <= DetachedQueryOverAge.As<int>())) + .And(Subqueries.WhereAll<Person>(p => p.Age < DetachedQueryOverAge.As<int>())); + + AssertCriteriaAreEqual(expected, actual); + } + + [Test] public void PropertyAsSomeSyntax() { ICriteria expected = @@ -245,6 +385,26 @@ } [Test] + public void PropertyAsSomeSyntaxCrtierion() + { + ICriteria expected = + CreateTestCriteria(typeof(Person)) + .Add(Subqueries.PropertyGeSome("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyGtSome("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyLeSome("Age", DetachedCriteriaAge)) + .Add(Subqueries.PropertyLtSome("Age", DetachedCriteriaAge)); + + var actual = + CreateTestQueryOver<Person>() + .And(Subqueries.WhereSome<Person>(p => p.Age >= DetachedQueryOverAge.As<int>())) + .And(Subqueries.WhereSome<Person>(p => p.Age > DetachedQueryOverAge.As<int>())) + .And(Subqueries.WhereSome<Person>(p => p.Age <= DetachedQueryOverAge.As<int>())) + .And(Subqueries.WhereSome<Person>(p => p.Age < DetachedQueryOverAge.As<int>())); + + AssertCriteriaAreEqual(expected, actual); + } + + [Test] public void Value() { ICriteria expected = @@ -273,6 +433,34 @@ } [Test] + public void ValueCriterion() + { + ICriteria expected = + CreateTestCriteria(typeof(Person)) + .Add(Subqueries.Eq("Name", DetachedCriteriaName)) + .Add(Subqueries.Ge("Age", DetachedCriteriaAge)) + .Add(Subqueries.Gt("Age", DetachedCriteriaAge)) + .Add(Subqueries.In("Name", DetachedCriteriaName)) + .Add(Subqueries.Le("Age", DetachedCriteriaAge)) + .Add(Subqueries.Lt("Age", DetachedCriteriaAge)) + .Add(Subqueries.Ne("Name", DetachedCriteriaName)) + .Add(Subqueries.NotIn("Name", DetachedCriteriaName)); + + var actual = + CreateTestQueryOver<Person>() + .And(Subqueries.WhereValue("Name").Eq(DetachedQueryOverName)) + .And(Subqueries.WhereValue("Age").Ge(DetachedQueryOverAge)) + .And(Subqueries.WhereValue("Age").Gt(DetachedQueryOverAge)) + .And(Subqueries.WhereValue("Name").In(DetachedQueryOverName)) + .And(Subqueries.WhereValue("Age").Le(DetachedQueryOverAge)) + .And(Subqueries.WhereValue("Age").Lt(DetachedQueryOverAge)) + .And(Subqueries.WhereValue("Name").Ne(DetachedQueryOverName)) + .And(Subqueries.WhereValue("Name").NotIn(DetachedQueryOverName)); + + AssertCriteriaAreEqual(expected, actual); + } + + [Test] public void ValueAll() { ICriteria expected = @@ -295,6 +483,28 @@ } [Test] + public void ValueAllCriterion() + { + ICriteria expected = + CreateTestCriteria(typeof(Person)) + .Add(Subqueries.EqAll("Name", DetachedCriteriaName)) + .Add(Subqueries.GeAll("Age", DetachedCriteriaAge)) + .Add(Subqueries.GtAll("Age", DetachedCriteriaAge)) + .Add(Subqueries.LeAll("Age", DetachedCriteriaAge)) + .Add(Subqueries.LtAll("Age", DetachedCriteriaAge)); + + var actual = + CreateTestQueryOver<Person>() + .And(Subqueries.WhereValue("Name").EqAll(DetachedQueryOverName)) + .And(Subqueries.WhereValue("Age").GeAll(DetachedQueryOverAge)) + .And(Subqueries.WhereValue("Age").GtAll(DetachedQueryOverAge)) + .And(Subqueries.WhereValue("Age").LeAll(DetachedQueryOverAge)) + .And(Subqueries.WhereValue("Age").LtAll(DetachedQueryOverAge)); + + AssertCriteriaAreEqual(expected, actual); + } + + [Test] public void ValueSome() { ICriteria expected = @@ -315,6 +525,26 @@ } [Test] + public void ValueSomeCriterion() + { + ICriteria expected = + CreateTestCriteria(typeof(Person)) + .Add(Subqueries.GeSome("Age", DetachedCriteriaAge)) + .Add(Subqueries.GtSome("Age", DetachedCriteriaAge)) + .Add(Subqueries.LeSome("Age", DetachedCriteriaAge)) + .Add(Subqueries.LtSome("Age", DetachedCriteriaAge)); + + var actual = + CreateTestQueryOver<Person>() + .And(Subqueries.WhereValue("Age").GeSome(DetachedQueryOverAge)) + .And(Subqueries.WhereValue("Age").GtSome(DetachedQueryOverAge)) + .And(Subqueries.WhereValue("Age").LeSome(DetachedQueryOverAge)) + .And(Subqueries.WhereValue("Age").LtSome(DetachedQueryOverAge)); + + AssertCriteriaAreEqual(expected, actual); + } + + [Test] public void UntypedSubqueries() { ICriteria expected = @@ -330,6 +560,22 @@ AssertCriteriaAreEqual(expected, actual); } + [Test] + public void UntypedSubqueriesCriterion() + { + ICriteria expected = + CreateTestCriteria(typeof(Person)) + .Add(Subqueries.Exists(DetachedCriteriaChild)) + .Add(Subqueries.NotExists(DetachedCriteriaChild)); + + var actual = + CreateTestQueryOver<Person>() + .And(Subqueries.WhereExists(DetachedQueryOverChild)) + .And(Subqueries.WhereNotExists(DetachedQueryOverChild)); + + AssertCriteriaAreEqual(expected, actual); + } + } } \ No newline at end of file This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |