[Nhibernate-commit] SF.net SVN: nhibernate:[4827] trunk/nhibernate/src/NHibernate

[<ric...@us...>]

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 =&gt; t.Property [==, !=, >, etc.] detachedQueryOver.As&lt;propertyType&gt;())
 		/// </summary>
@@ -48,12 +66,73 @@
 			return root;
 		}
 
+		/// <summary>
+		/// Subquery expression in the format
+		/// .Where(() =&gt; alias.Property [==, !=, >, etc.] detachedQueryOver.As&lt;propertyType&gt;())
+		/// </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 =&gt; t.Property [==, !=, >, etc.] detachedQueryOver.As&lt;propertyType&gt;())
+		/// </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(() =&gt; alias.Property [==, !=, >, etc.] detachedQueryOver.As&lt;propertyType&gt;())
+		/// </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 =&gt; t.Property [==, !=, >, etc.] detachedQueryOver.As&lt;propertyType&gt;())
+		/// </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(() =&gt; alias.Property [==, !=, >, etc.] detachedQueryOver.As&lt;propertyType&gt;())
+		/// </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.