Menu
▾
▴
[Nhibernate-commit] SF.net SVN: nhibernate:[5050] trunk/nhibernate/src/NHibernate
|
From: <ric...@us...> - 2010-07-22 20:59:48
|
Revision: 5050
http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5050&view=rev
Author: ricbrown
Date: 2010-07-22 20:59:41 +0000 (Thu, 22 Jul 2010)
Log Message:
-----------
Added missing .Not to stand alone lambda restriction.
Modified Paths:
--------------
trunk/nhibernate/src/NHibernate/Criterion/Lambda/LambdaRestrictionBuilder.cs
trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/RestrictionsFixture.cs
Modified: trunk/nhibernate/src/NHibernate/Criterion/Lambda/LambdaRestrictionBuilder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Criterion/Lambda/LambdaRestrictionBuilder.cs 2010-07-22 16:54:35 UTC (rev 5049)
+++ trunk/nhibernate/src/NHibernate/Criterion/Lambda/LambdaRestrictionBuilder.cs 2010-07-22 20:59:41 UTC (rev 5050)
@@ -16,21 +16,35 @@
{
private string propertyName;
private object lo;
+ private bool isNot;
- public LambdaBetweenBuilder(string propertyName, object lo)
+ public LambdaBetweenBuilder(string propertyName, object lo, bool isNot)
{
this.propertyName = propertyName;
this.lo = lo;
+ this.isNot = isNot;
}
public AbstractCriterion And(object hi)
{
+ if (isNot)
+ return Restrictions.Not(Restrictions.Between(propertyName, lo, hi));
+
return Restrictions.Between(propertyName, lo, hi);
}
}
private string propertyName;
+ private bool isNot;
+ private ICriterion Process(ICriterion criterion)
+ {
+ if (isNot)
+ return Restrictions.Not(criterion);
+
+ return criterion;
+ }
+
/// <summary>
/// Constructed with property name
/// </summary>
@@ -44,103 +58,112 @@
/// </summary>
public LambdaBetweenBuilder IsBetween(object lo)
{
- return new LambdaBetweenBuilder(propertyName, lo);
+ return new LambdaBetweenBuilder(propertyName, lo, isNot);
}
+ public LambdaRestrictionBuilder Not
+ {
+ get
+ {
+ isNot = !isNot;
+ return this;
+ }
+ }
+
/// <summary>
/// Apply an "in" constraint to the named property
/// </summary>
- public AbstractCriterion IsIn(ICollection values)
+ public ICriterion IsIn(ICollection values)
{
- return Restrictions.In(propertyName, values);
+ return Process(Restrictions.In(propertyName, values));
}
/// <summary>
/// Apply an "in" constraint to the named property
/// </summary>
- public AbstractCriterion IsIn(object[] values)
+ public ICriterion IsIn(object[] values)
{
- return Restrictions.In(propertyName, values);
+ return Process(Restrictions.In(propertyName, values));
}
/// <summary>
/// Apply an "in" constraint to the named property
/// </summary>
- public AbstractCriterion IsInG<T>(ICollection<T> values)
+ public ICriterion IsInG<T>(ICollection<T> values)
{
- return Restrictions.InG(propertyName, values);
+ return Process(Restrictions.InG(propertyName, values));
}
/// <summary>
/// A case-insensitive "like", similar to Postgres "ilike" operator
/// </summary>
- public AbstractCriterion IsInsensitiveLike(object value)
+ public ICriterion IsInsensitiveLike(object value)
{
- return Restrictions.InsensitiveLike(propertyName, value);
+ return Process(Restrictions.InsensitiveLike(propertyName, value));
}
/// <summary>
/// A case-insensitive "like", similar to Postgres "ilike" operator
/// </summary>
- public AbstractCriterion IsInsensitiveLike(string value, MatchMode matchMode)
+ public ICriterion IsInsensitiveLike(string value, MatchMode matchMode)
{
- return Restrictions.InsensitiveLike(propertyName, value, matchMode);
+ return Process(Restrictions.InsensitiveLike(propertyName, value, matchMode));
}
/// <summary>
/// Apply an "is empty" constraint to the named property
/// </summary>
- public AbstractEmptinessExpression IsEmpty
+ public ICriterion IsEmpty
{
- get { return Restrictions.IsEmpty(propertyName); }
+ get { return Process(Restrictions.IsEmpty(propertyName)); }
}
/// <summary>
/// Apply a "not is empty" constraint to the named property
/// </summary>
- public AbstractEmptinessExpression IsNotEmpty
+ public ICriterion IsNotEmpty
{
- get { return Restrictions.IsNotEmpty(propertyName); }
+ get { return Process(Restrictions.IsNotEmpty(propertyName)); }
}
/// <summary>
/// Apply an "is null" constraint to the named property
/// </summary>
- public AbstractCriterion IsNull
+ public ICriterion IsNull
{
- get { return Restrictions.IsNull(propertyName); }
+ get { return Process(Restrictions.IsNull(propertyName)); }
}
/// <summary>
/// Apply an "not is null" constraint to the named property
/// </summary>
- public AbstractCriterion IsNotNull
+ public ICriterion IsNotNull
{
- get { return Restrictions.IsNotNull(propertyName); }
+ get { return Process(Restrictions.IsNotNull(propertyName)); }
}
/// <summary>
/// Apply a "like" constraint to the named property
/// </summary>
- public SimpleExpression IsLike(object value)
+ public ICriterion IsLike(object value)
{
- return Restrictions.Like(propertyName, value);
+ return Process(Restrictions.Like(propertyName, value));
}
/// <summary>
/// Apply a "like" constraint to the named property
/// </summary>
- public SimpleExpression IsLike(string value, MatchMode matchMode)
+ public ICriterion IsLike(string value, MatchMode matchMode)
{
- return Restrictions.Like(propertyName, value, matchMode);
+ return Process(Restrictions.Like(propertyName, value, matchMode));
}
/// <summary>
/// Apply a "like" constraint to the named property
/// </summary>
- public AbstractCriterion IsLike(string value, MatchMode matchMode, char? escapeChar)
+ public ICriterion IsLike(string value, MatchMode matchMode, char? escapeChar)
{
- return Restrictions.Like(propertyName, value, matchMode, escapeChar);
+ return Process(Restrictions.Like(propertyName, value, matchMode, escapeChar));
}
}
Modified: trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/RestrictionsFixture.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/RestrictionsFixture.cs 2010-07-22 16:54:35 UTC (rev 5049)
+++ trunk/nhibernate/src/NHibernate.Test/Criteria/Lambda/RestrictionsFixture.cs 2010-07-22 20:59:41 UTC (rev 5050)
@@ -40,12 +40,14 @@
CreateTestCriteria(typeof(Person), "personAlias")
.Add(Restrictions.Between("Age", 18, 65))
.Add(Restrictions.Between("personAlias.Age", 18, 65))
+ .Add(Restrictions.Not(Restrictions.Between("personAlias.Age", 10, 20)))
.Add(Restrictions.In("Name", new string[] { "name1", "name2", "name3" }))
.Add(Restrictions.In("Name", new ArrayList() { "name1", "name2", "name3" }))
.Add(Restrictions.InG<int>("Age", new int[] { 1, 2, 3 }))
.Add(Restrictions.InsensitiveLike("Name", "test"))
.Add(Restrictions.InsensitiveLike("Name", "tEsT", MatchMode.Anywhere))
.Add(Restrictions.IsEmpty("Children"))
+ .Add(Restrictions.Not(Restrictions.IsEmpty("Children")))
.Add(Restrictions.IsNotEmpty("Children"))
.Add(Restrictions.IsNotNull("Name"))
.Add(Restrictions.IsNull("Name"))
@@ -61,12 +63,14 @@
CreateTestQueryOver<Person>(() => personAlias)
.Where(Restrictions.On<Person>(p => p.Age).IsBetween(18).And(65))
.And(Restrictions.On(() => personAlias.Age).IsBetween(18).And(65))
+ .And(Restrictions.On(() => personAlias.Age).Not.IsBetween(10).And(20))
.And(Restrictions.On<Person>(p => p.Name).IsIn(new string[] { "name1", "name2", "name3" }))
.And(Restrictions.On<Person>(p => p.Name).IsIn(new ArrayList() { "name1", "name2", "name3" }))
.And(Restrictions.On<Person>(p => p.Age).IsInG<int>(new int[] { 1, 2, 3 }))
.And(Restrictions.On<Person>(p => p.Name).IsInsensitiveLike("test"))
.And(Restrictions.On<Person>(p => p.Name).IsInsensitiveLike("tEsT", MatchMode.Anywhere))
.And(Restrictions.On<Person>(p => p.Children).IsEmpty)
+ .And(Restrictions.On<Person>(p => p.Children).Not.IsEmpty)
.And(Restrictions.On<Person>(p => p.Children).IsNotEmpty)
.And(Restrictions.On<Person>(p => p.Name).IsNotNull)
.And(Restrictions.On<Person>(p => p.Name).IsNull)
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
