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

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

Revision: 4848
          http://nhibernate.svn.sourceforge.net/nhibernate/?rev=4848&view=rev
Author:   ricbrown
Date:     2009-11-20 21:28:47 +0000 (Fri, 20 Nov 2009)

Log Message:
-----------
Added convenience syntax for negation of expressions.

Modified Paths:
--------------
    trunk/nhibernate/src/NHibernate/Criterion/QueryOver.cs
    trunk/nhibernate/src/NHibernate/IQueryOver.cs
    trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/QueryOverFixture.cs

Modified: trunk/nhibernate/src/NHibernate/Criterion/QueryOver.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/QueryOver.cs	2009-11-20 20:13:57 UTC (rev 4847)
+++ trunk/nhibernate/src/NHibernate/Criterion/QueryOver.cs	2009-11-20 21:28:47 UTC (rev 4848)
@@ -89,6 +89,16 @@
 			return Add(expression);
 		}
 
+		public QueryOver<T> AndNot(Expression<Func<T, bool>> expression)
+		{
+			return AddNot(expression);
+		}
+
+		public QueryOver<T> AndNot(Expression<Func<bool>> expression)
+		{
+			return AddNot(expression);
+		}
+
 		public QueryOverRestrictionBuilder<T> AndRestrictionOn(Expression<Func<T, object>> expression)
 		{
 			return new QueryOverRestrictionBuilder<T>(this, ExpressionProcessor.FindMemberExpression(expression.Body));
@@ -114,6 +124,16 @@
 			return Add(expression);
 		}
 
+		public QueryOver<T> WhereNot(Expression<Func<T, bool>> expression)
+		{
+			return AddNot(expression);
+		}
+
+		public QueryOver<T> WhereNot(Expression<Func<bool>> expression)
+		{
+			return AddNot(expression);
+		}
+
 		public QueryOverRestrictionBuilder<T> WhereRestrictionOn(Expression<Func<T, object>> expression)
 		{
 			return new QueryOverRestrictionBuilder<T>(this, ExpressionProcessor.FindMemberExpression(expression.Body));
@@ -464,7 +484,19 @@
 			return this;
 		}
 
+		private QueryOver<T> AddNot(Expression<Func<T, bool>> expression)
+		{
+			_criteria.Add(Restrictions.Not(ExpressionProcessor.ProcessExpression<T>(expression)));
+			return this;
+		}
 
+		private QueryOver<T> AddNot(Expression<Func<bool>> expression)
+		{
+			_criteria.Add(Restrictions.Not(ExpressionProcessor.ProcessExpression(expression)));
+			return this;
+		}
+
+
 		ICriteria IQueryOver<T>.UnderlyingCriteria
 		{ get { return UnderlyingCriteria; } }
 
@@ -477,6 +509,12 @@
 		IQueryOver<T> IQueryOver<T>.And(ICriterion expression)
 		{ return And(expression); }
 
+		IQueryOver<T> IQueryOver<T>.AndNot(Expression<Func<T, bool>> expression)
+		{ return AndNot(expression); }
+
+		IQueryOver<T> IQueryOver<T>.AndNot(Expression<Func<bool>> expression)
+		{ return AndNot(expression); }
+
 		IQueryOverRestrictionBuilder<T> IQueryOver<T>.AndRestrictionOn(Expression<Func<T, object>> expression)
 		{ return new IQueryOverRestrictionBuilder<T>(this, ExpressionProcessor.FindMemberExpression(expression.Body)); }
 
@@ -492,6 +530,12 @@
 		IQueryOver<T> IQueryOver<T>.Where(ICriterion expression)
 		{ return Where(expression); }
 
+		IQueryOver<T> IQueryOver<T>.WhereNot(Expression<Func<T, bool>> expression)
+		{ return WhereNot(expression); }
+
+		IQueryOver<T> IQueryOver<T>.WhereNot(Expression<Func<bool>> expression)
+		{ return WhereNot(expression); }
+
 		IQueryOverRestrictionBuilder<T> IQueryOver<T>.WhereRestrictionOn(Expression<Func<T, object>> expression)
 		{ return new IQueryOverRestrictionBuilder<T>(this, ExpressionProcessor.FindMemberExpression(expression.Body)); }
 

Modified: trunk/nhibernate/src/NHibernate/IQueryOver.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/IQueryOver.cs	2009-11-20 20:13:57 UTC (rev 4847)
+++ trunk/nhibernate/src/NHibernate/IQueryOver.cs	2009-11-20 21:28:47 UTC (rev 4848)
@@ -50,6 +50,20 @@
 		IQueryOver<T> And(ICriterion expression);
 
 		/// <summary>
+		/// Add negation of criterion expressed as a lambda expression
+		/// </summary>
+		/// <param name="expression">Lambda expression</param>
+		/// <returns>criteria instance</returns>
+		IQueryOver<T> AndNot(Expression<Func<T, bool>> expression);
+
+		/// <summary>
+		/// Add negation of criterion expressed as a lambda expression
+		/// </summary>
+		/// <param name="expression">Lambda expression</param>
+		/// <returns>criteria instance</returns>
+		IQueryOver<T> AndNot(Expression<Func<bool>> expression);
+
+		/// <summary>
 		/// Add restriction to a property
 		/// </summary>
 		/// <param name="expression">Lambda expression containing path to property</param>
@@ -64,14 +78,14 @@
 		IQueryOverRestrictionBuilder<T> AndRestrictionOn(Expression<Func<object>> expression);
 
 		/// <summary>
-		/// Identical semantics to Add() to allow more readable queries
+		/// Identical semantics to And() to allow more readable queries
 		/// </summary>
 		/// <param name="expression">Lambda expression</param>
 		/// <returns>criteria instance</returns>
 		IQueryOver<T> Where(Expression<Func<T, bool>> expression);
 
 		/// <summary>
-		/// Identical semantics to Add() to allow more readable queries
+		/// Identical semantics to And() to allow more readable queries
 		/// </summary>
 		/// <param name="expression">Lambda expression</param>
 		/// <returns>criteria instance</returns>
@@ -83,6 +97,20 @@
 		IQueryOver<T> Where(ICriterion expression);
 
 		/// <summary>
+		/// Identical semantics to AndNot() to allow more readable queries
+		/// </summary>
+		/// <param name="expression">Lambda expression</param>
+		/// <returns>criteria instance</returns>
+		IQueryOver<T> WhereNot(Expression<Func<T, bool>> expression);
+
+		/// <summary>
+		/// Identical semantics to AndNot() to allow more readable queries
+		/// </summary>
+		/// <param name="expression">Lambda expression</param>
+		/// <returns>criteria instance</returns>
+		IQueryOver<T> WhereNot(Expression<Func<bool>> expression);
+
+		/// <summary>
 		/// Identical semantics to AndRestrictionOn() to allow more readable queries
 		/// </summary>
 		/// <param name="expression">Lambda expression</param>

Modified: trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/QueryOverFixture.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/QueryOverFixture.cs	2009-11-20 20:13:57 UTC (rev 4847)
+++ trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/QueryOverFixture.cs	2009-11-20 21:28:47 UTC (rev 4848)
@@ -101,18 +101,39 @@
 		}
 
 		[Test]
+		public void Negation()
+		{
+			ICriteria expected =
+				CreateTestCriteria(typeof(Person), "personAlias")
+					.Add(Restrictions.Not(Restrictions.Eq("Name", "test name")))
+					.Add(Restrictions.Not(Restrictions.Eq("personAlias.Name", "test name")));
+
+			Person personAlias = null;
+			IQueryOver<Person> actual =
+				CreateTestQueryOver<Person>(() => personAlias)
+					.AndNot(p => p.Name == "test name")
+					.AndNot(() => personAlias.Name == "test name");
+
+			AssertCriteriaAreEqual(expected, actual);
+		}
+
+		[Test]
 		public void Where_BehavesTheSameAs_And()
 		{
 			Person personAlias = null;
 			QueryOver<Person> expected = (QueryOver<Person>)
 				CreateTestQueryOver<Person>(() => personAlias)
 					.And(() => personAlias.Name == "test name")
-					.And(p => p.Name == "test name");
+					.And(p => p.Name == "test name")
+					.AndNot(() => personAlias.Name == "test name")
+					.AndNot(p => p.Name == "test name");
 
 			IQueryOver<Person> actual =
 				CreateTestQueryOver<Person>(() => personAlias)
 					.Where(() => personAlias.Name == "test name")
-					.Where(p => p.Name == "test name");
+					.Where(p => p.Name == "test name")
+					.WhereNot(() => personAlias.Name == "test name")
+					.WhereNot(p => p.Name == "test name");
 
 			AssertCriteriaAreEqual(expected.UnderlyingCriteria, actual);
 		}


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.