Menu
▾
▴
[Nhibernate-commit] SF.net SVN: nhibernate:[4834] trunk/nhibernate/src/NHibernate
|
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.
|
