Menu
▾
▴
[Nhibernate-commit] SF.net SVN: nhibernate:[4827] trunk/nhibernate/src/NHibernate
|
From: <ric...@us...> - 2009-11-10 18:07:33
|
Revision: 4827
http://nhibernate.svn.sourceforge.net/nhibernate/?rev=4827&view=rev
Author: ricbrown
Date: 2009-11-10 18:07:01 +0000 (Tue, 10 Nov 2009)
Log Message:
-----------
Added remaining (inline) QueryOver subquery overloads.
Modified Paths:
--------------
trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryBuilder.cs
trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryPropertyBuilder.cs
trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/SubqueryFixture.cs
Modified: trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryBuilder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryBuilder.cs 2009-11-10 14:19:09 UTC (rev 4826)
+++ trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryBuilder.cs 2009-11-10 18:07:01 UTC (rev 4827)
@@ -38,6 +38,24 @@
}
/// <summary>
+ /// Add an Exists subquery criterion
+ /// </summary>
+ public R WhereExists<U>(QueryOver<U> detachedQuery)
+ {
+ root.And(Subqueries.Exists(detachedQuery.DetachedCriteria));
+ return root;
+ }
+
+ /// <summary>
+ /// Add a NotExists subquery criterion
+ /// </summary>
+ public R WhereNotExists<U>(QueryOver<U> detachedQuery)
+ {
+ root.And(Subqueries.NotExists(detachedQuery.DetachedCriteria));
+ return root;
+ }
+
+ /// <summary>
/// Subquery expression in the format
/// .Where(t => t.Property [==, !=, >, etc.] detachedQueryOver.As<propertyType>())
/// </summary>
@@ -48,12 +66,73 @@
return root;
}
+ /// <summary>
+ /// Subquery expression in the format
+ /// .Where(() => alias.Property [==, !=, >, etc.] detachedQueryOver.As<propertyType>())
+ /// </summary>
+ public R Where(Expression<Func<bool>> expression)
+ {
+ AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery(LambdaSubqueryType.Exact, expression);
+ root.And(criterion);
+ return root;
+ }
+
+ /// <summary>
+ /// Subquery expression in the format
+ /// .WhereAll(t => t.Property [==, !=, >, etc.] detachedQueryOver.As<propertyType>())
+ /// </summary>
+ public R WhereAll(Expression<Func<T, bool>> expression)
+ {
+ AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<T>(LambdaSubqueryType.All, expression);
+ root.And(criterion);
+ return root;
+ }
+
+ /// <summary>
+ /// Subquery expression in the format
+ /// .WhereAll(() => alias.Property [==, !=, >, etc.] detachedQueryOver.As<propertyType>())
+ /// </summary>
+ public R WhereAll(Expression<Func<bool>> expression)
+ {
+ AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery(LambdaSubqueryType.All, expression);
+ root.And(criterion);
+ return root;
+ }
+
+ /// <summary>
+ /// Subquery expression in the format
+ /// .WhereSome(t => t.Property [==, !=, >, etc.] detachedQueryOver.As<propertyType>())
+ /// </summary>
+ public R WhereSome(Expression<Func<T, bool>> expression)
+ {
+ AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery<T>(LambdaSubqueryType.Some, expression);
+ root.And(criterion);
+ return root;
+ }
+
+ /// <summary>
+ /// Subquery expression in the format
+ /// .WhereSome(() => alias.Property [==, !=, >, etc.] detachedQueryOver.As<propertyType>())
+ /// </summary>
+ public R WhereSome(Expression<Func<bool>> expression)
+ {
+ AbstractCriterion criterion = ExpressionProcessor.ProcessSubquery(LambdaSubqueryType.Some, expression);
+ root.And(criterion);
+ return root;
+ }
+
public S WhereProperty(Expression<Func<T, object>> expression)
{
string property = ExpressionProcessor.FindMemberExpression(expression.Body);
return (S)new S().Set(root, property, null);
}
+ public S WhereProperty(Expression<Func<object>> expression)
+ {
+ string property = ExpressionProcessor.FindMemberExpression(expression.Body);
+ return (S)new S().Set(root, property, null);
+ }
+
public S WhereValue(object value)
{
return (S)new S().Set(root, null, value);
Modified: trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryPropertyBuilder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryPropertyBuilder.cs 2009-11-10 14:19:09 UTC (rev 4826)
+++ trunk/nhibernate/src/NHibernate/Criterion/Lambda/QueryOverSubqueryPropertyBuilder.cs 2009-11-10 18:07:01 UTC (rev 4827)
@@ -78,6 +78,16 @@
}
/// <summary>
+ /// Add a property equal all subquery criterion
+ /// </summary>
+ /// <param name="detachedCriteria">detached subquery</param>
+ public R EqAll<U>(QueryOver<U> detachedCriteria)
+ {
+ AddSubquery(Subqueries.PropertyEqAll, Subqueries.EqAll, detachedCriteria);
+ return root;
+ }
+
+ /// <summary>
/// Create a property greater than or equal subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
@@ -88,6 +98,26 @@
}
/// <summary>
+ /// Create a property greater than or equal all subquery criterion
+ /// </summary>
+ /// <param name="detachedCriteria">detached subquery</param>
+ public R GeAll<U>(QueryOver<U> detachedCriteria)
+ {
+ AddSubquery(Subqueries.PropertyGeAll, Subqueries.GeAll, detachedCriteria);
+ return root;
+ }
+
+ /// <summary>
+ /// Create a property greater than or equal some subquery criterion
+ /// </summary>
+ /// <param name="detachedCriteria">detached subquery</param>
+ public R GeSome<U>(QueryOver<U> detachedCriteria)
+ {
+ AddSubquery(Subqueries.PropertyGeSome, Subqueries.GeSome, detachedCriteria);
+ return root;
+ }
+
+ /// <summary>
/// Create a property greater than subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
@@ -98,6 +128,26 @@
}
/// <summary>
+ /// Create a property greater than all subquery criterion
+ /// </summary>
+ /// <param name="detachedCriteria">detached subquery</param>
+ public R GtAll<U>(QueryOver<U> detachedCriteria)
+ {
+ AddSubquery(Subqueries.PropertyGtAll, Subqueries.GtAll, detachedCriteria);
+ return root;
+ }
+
+ /// <summary>
+ /// Create a property greater than some subquery criterion
+ /// </summary>
+ /// <param name="detachedCriteria">detached subquery</param>
+ public R GtSome<U>(QueryOver<U> detachedCriteria)
+ {
+ AddSubquery(Subqueries.PropertyGtSome, Subqueries.GtSome, detachedCriteria);
+ return root;
+ }
+
+ /// <summary>
/// Create a property in subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
@@ -118,6 +168,26 @@
}
/// <summary>
+ /// Create a property less than or equal all subquery criterion
+ /// </summary>
+ /// <param name="detachedCriteria">detached subquery</param>
+ public R LeAll<U>(QueryOver<U> detachedCriteria)
+ {
+ AddSubquery(Subqueries.PropertyLeAll, Subqueries.LeAll, detachedCriteria);
+ return root;
+ }
+
+ /// <summary>
+ /// Create a property less than or equal some subquery criterion
+ /// </summary>
+ /// <param name="detachedCriteria">detached subquery</param>
+ public R LeSome<U>(QueryOver<U> detachedCriteria)
+ {
+ AddSubquery(Subqueries.PropertyLeSome, Subqueries.LeSome, detachedCriteria);
+ return root;
+ }
+
+ /// <summary>
/// Create a property less than subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
@@ -128,6 +198,26 @@
}
/// <summary>
+ /// Create a property less than all subquery criterion
+ /// </summary>
+ /// <param name="detachedCriteria">detached subquery</param>
+ public R LtAll<U>(QueryOver<U> detachedCriteria)
+ {
+ AddSubquery(Subqueries.PropertyLtAll, Subqueries.LtAll, detachedCriteria);
+ return root;
+ }
+
+ /// <summary>
+ /// Create a property less than some subquery criterion
+ /// </summary>
+ /// <param name="detachedCriteria">detached subquery</param>
+ public R LtSome<U>(QueryOver<U> detachedCriteria)
+ {
+ AddSubquery(Subqueries.PropertyLtSome, Subqueries.LtSome, detachedCriteria);
+ return root;
+ }
+
+ /// <summary>
/// Create a property not equal subquery criterion
/// </summary>
/// <param name="detachedCriteria">detached subquery</param>
Modified: trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/SubqueryFixture.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/SubqueryFixture.cs 2009-11-10 14:19:09 UTC (rev 4826)
+++ trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/SubqueryFixture.cs 2009-11-10 18:07:01 UTC (rev 4827)
@@ -103,6 +103,63 @@
}
[Test]
+ public void PropertyAlias()
+ {
+ ICriteria expected =
+ CreateTestCriteria(typeof(Person), "personAlias")
+ .Add(Subqueries.PropertyEq("personAlias.Name", DetachedCriteriaName));
+
+ Person personAlias = null;
+ var actual =
+ CreateTestQueryOver<Person>(() => personAlias)
+ .WithSubquery.WhereProperty(() => personAlias.Name).Eq(DetachedQueryOverName);
+
+ AssertCriteriaAreEqual(expected, actual);
+ }
+
+ [Test]
+ public void PropertyAll()
+ {
+ 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>()
+ .WithSubquery.WhereProperty(p => p.Name).EqAll(DetachedQueryOverName)
+ .WithSubquery.WhereProperty(p => p.Age).GeAll(DetachedQueryOverAge)
+ .WithSubquery.WhereProperty(p => p.Age).GtAll(DetachedQueryOverAge)
+ .WithSubquery.WhereProperty(p => p.Age).LeAll(DetachedQueryOverAge)
+ .WithSubquery.WhereProperty(p => p.Age).LtAll(DetachedQueryOverAge);
+
+ AssertCriteriaAreEqual(expected, actual);
+ }
+
+ [Test]
+ public void PropertySome()
+ {
+ 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>()
+ .WithSubquery.WhereProperty(p => p.Age).GeSome(DetachedQueryOverAge)
+ .WithSubquery.WhereProperty(p => p.Age).GtSome(DetachedQueryOverAge)
+ .WithSubquery.WhereProperty(p => p.Age).LeSome(DetachedQueryOverAge)
+ .WithSubquery.WhereProperty(p => p.Age).LtSome(DetachedQueryOverAge);
+
+ AssertCriteriaAreEqual(expected, actual);
+ }
+
+ [Test]
public void PropertyAsSyntax()
{
ICriteria expected =
@@ -127,6 +184,67 @@
}
[Test]
+ public void PropertyAsSyntaxAlias()
+ {
+ 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)
+ .WithSubquery.Where(() => personAlias.Name == DetachedQueryOverName.As<string>())
+ .WithSubquery.WhereSome(() => personAlias.Age > DetachedQueryOverAge.As<int>())
+ .WithSubquery.WhereAll(() => personAlias.Age < DetachedQueryOverAge.As<int>());
+
+ AssertCriteriaAreEqual(expected, actual);
+ }
+
+ [Test]
+ public void PropertyAsAllSyntax()
+ {
+ 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>()
+ .WithSubquery.WhereAll(p => p.Name == DetachedQueryOverName.As<string>())
+ .WithSubquery.WhereAll(p => p.Age >= DetachedQueryOverAge.As<int>())
+ .WithSubquery.WhereAll(p => p.Age > DetachedQueryOverAge.As<int>())
+ .WithSubquery.WhereAll(p => p.Age <= DetachedQueryOverAge.As<int>())
+ .WithSubquery.WhereAll(p => p.Age < DetachedQueryOverAge.As<int>());
+
+ AssertCriteriaAreEqual(expected, actual);
+ }
+
+ [Test]
+ public void PropertyAsSomeSyntax()
+ {
+ 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>()
+ .WithSubquery.WhereSome(p => p.Age >= DetachedQueryOverAge.As<int>())
+ .WithSubquery.WhereSome(p => p.Age > DetachedQueryOverAge.As<int>())
+ .WithSubquery.WhereSome(p => p.Age <= DetachedQueryOverAge.As<int>())
+ .WithSubquery.WhereSome(p => p.Age < DetachedQueryOverAge.As<int>());
+
+ AssertCriteriaAreEqual(expected, actual);
+ }
+
+ [Test]
public void Value()
{
ICriteria expected =
@@ -154,6 +272,64 @@
AssertCriteriaAreEqual(expected, actual);
}
+ [Test]
+ public void ValueAll()
+ {
+ 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>()
+ .WithSubquery.WhereValue("Name").EqAll(DetachedQueryOverName)
+ .WithSubquery.WhereValue("Age").GeAll(DetachedQueryOverAge)
+ .WithSubquery.WhereValue("Age").GtAll(DetachedQueryOverAge)
+ .WithSubquery.WhereValue("Age").LeAll(DetachedQueryOverAge)
+ .WithSubquery.WhereValue("Age").LtAll(DetachedQueryOverAge);
+
+ AssertCriteriaAreEqual(expected, actual);
+ }
+
+ [Test]
+ public void ValueSome()
+ {
+ 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>()
+ .WithSubquery.WhereValue("Age").GeSome(DetachedQueryOverAge)
+ .WithSubquery.WhereValue("Age").GtSome(DetachedQueryOverAge)
+ .WithSubquery.WhereValue("Age").LeSome(DetachedQueryOverAge)
+ .WithSubquery.WhereValue("Age").LtSome(DetachedQueryOverAge);
+
+ AssertCriteriaAreEqual(expected, actual);
+ }
+
+ [Test]
+ public void UntypedSubqueries()
+ {
+ ICriteria expected =
+ CreateTestCriteria(typeof(Person))
+ .Add(Subqueries.Exists(DetachedCriteriaChild))
+ .Add(Subqueries.NotExists(DetachedCriteriaChild));
+
+ var actual =
+ CreateTestQueryOver<Person>()
+ .WithSubquery.WhereExists(DetachedQueryOverChild)
+ .WithSubquery.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.
|
