/// <summary>
///
/// </summary>
/// <returns></returns>
internal override WalkedToken Walk(WalkedToken token)
{
if (token == null) throw new ArgumentNullException("token");
if (token.TokenType != TokenType.PropertyPath)
throw new ApplicationException("Cannot apply any to token of type " + token.TokenType);
return WalkedToken.FromCriterion(Expression.IsNotEmpty(token.GetValue<String>()));
}
/// <summary>
/// This is the core function that compose two token.
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
internal override WalkedToken Walk(WalkedToken left, WalkedToken right)
{
//First of all check if left is a sql expression
if (left.TokenType == TokenType.SqlFunction)
return WalkSqlFunction(left, right);
//Then check if is a criteria on two properties
if (left.TokenType == TokenType.PropertyPath && right.TokenType == TokenType.PropertyPath)
return WalkTwoProperties(left, right);
MemberAccessWalker w = (MemberAccessWalker) (left.TokenType == TokenType.PropertyPath ? left : right);
Object value = left.TokenType == TokenType.PropertyPath ? right.GetValue<Object>() : left.GetValue<Object>();
String propertyName = w.MethodName;
///Handle null value because it should be treated differently.
if (value == null)
return WalkedToken.FromCriterion(new NullExpression(propertyName));
if (!w.FinalType.IsAssignableFrom(value.GetType()))
if (w.FinalType == typeof(Int32))
value = ((IConvertible) value).ToInt32(null);
else if (w.FinalType == typeof(Int16))
value = ((IConvertible) value).ToInt16(null);
else if (w.FinalType == typeof(Int64))
value = ((IConvertible)value).ToInt64(null);
else
throw new ApplicationException("Incompatible types");
return WalkedToken.FromCriterion(expCreator(propertyName, value));
}
internal override WalkedToken Walk(WalkedToken left, WalkedToken right)
{
Conjunction crit = new Conjunction();
crit.Add(left.Criterion);
crit.Add(right.Criterion);
return WalkedToken.FromCriterion(crit);
}
/// <summary>
///
/// </summary>
/// <param name="stack"></param>
/// <returns></returns>
internal override WalkedToken Walk(WalkedToken left, WalkedToken right)
{
if (left.TokenType != TokenType.PropertyPath)
throw new ApplicationException("Cannot apply any to token of type " + left.TokenType);
//now create the criterion
DetachedCriteria d = DetachedCriteria.For(rootCriteria.CriteriaClass)
.SetProjection(Projections.Id())
.Add(Expression.IsNotEmpty(left.GetValue<String>()))
.Add(right.Criterion);
return WalkedToken.FromCriterion(Subqueries.Exists(d));
//return WalkedToken.FromCriterion(Expression.IsNotEmpty(token.GetValue<String>()));
}
/// <summary>
/// We can invoke a StartsWith only in a member of a domain class.
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
internal override WalkedToken Walk(WalkedToken left, WalkedToken right)
{
System.Diagnostics.Debug.Assert(left.GetType() == typeof(MemberAccessWalker), "A string function can be invoked only on a member of a domain object");
String searchString;
switch (func) {
case StringFunction.StartsWith:
searchString = right.GetValue<String>() + "%";
break;
case StringFunction.EndsWith:
searchString = "%" + right.GetValue<String>();
break;
case StringFunction.Contains:
searchString = "%" + right.GetValue<String>() + "%";
break;
default:
throw new NotImplementedException(String.Format("String function {0} is not implemented", func));
}
return WalkedToken.FromCriterion(Expression.Like(left.GetValue<String>(), searchString));
}
private IList <ICriterion> Walk()
{
Stack <WalkedToken> opStack = new Stack <WalkedToken>();
Int32 I = 0;
while (I < walkers.Count)
{
Walker w = walkers[I++];
if (w is BinaryWalker)
{
BinaryWalker b = w as BinaryWalker;
WalkedToken right = opStack.Pop();
WalkedToken left = opStack.Pop();
opStack.Push(b.Walk(left, right));
}
else if (w is UnaryWalker)
{
opStack.Push(((UnaryWalker)w).Walk(opStack.Pop()));
}
//else if (w is QueueWalker)
//{
// opStack.Push(((QueueWalker)w).Walk(walkers));
//}
else if (w is StackWalker)
{
opStack.Push(((StackWalker)w).Walk(opStack));
}
else if (w is WalkedToken)
{
opStack.Push((WalkedToken)w);
}
else
{
throw new NotImplementedException("This type of walker is not supported");
}
}
System.Diagnostics.Debug.Assert(opStack.Count == 1, "Expression does not produce a valid result");
List <ICriterion> retvalue = new List <ICriterion>();
retvalue.Add(opStack.Pop().Criterion);
return(retvalue);
}
protected override void PVisitMemberAccess(System.Linq.Expressions.MemberExpression m)
{
WalkedToken KnownMember = null;
KnownMember = GetKnownMemberAccess(m, KnownMember);
if (KnownMember != null)
{
Push(KnownMember);
}
else if (IsInvocationOnDomainObject(m))
{
//IS really an invocation on some domain object?
Push(walkerFactory.FromMemberAccessNode(m));
}
else if (Peek().GetType() == typeof(MemberAccessWalker))
{
//Previous element is a memberinvocation so there is the need to compose property
((MemberAccessWalker)Peek()).Compose(m.Member.Name, m.Type);
}
base.PVisitMemberAccess(m);
}
///// <summary>
///// If a type is nullable of we must
///// </summary>
///// <param name="type"></param>
///// <returns></returns>
//private System.Type GetTypeCheckForNullable(System.Type type) {
//if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)) {…}
//w.FinalType.GetGenericArguments()
//}
/// <summary>
/// Ok we have a sql function, the inner token already created a criterion we
/// only needs to configureIt
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
private WalkedToken WalkSqlFunction(WalkedToken left, WalkedToken right)
{
CustomCriterion.SqlFunctionCriterion crit = (CustomCriterion.SqlFunctionCriterion)left.Criterion;
//configureSqlCustomCriterion(crit);
NHibernate.Criterion.ICriterion outCriterion = expCreator("", null);
crit.StrOperator = outCriterion.GetType().GetProperty(
"Op", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(outCriterion, null) as String;
crit.ValueToCompareTo = right.GetValue<Object>();
return left;
}
/// <summary>
/// Execute a comparison between two properties and not between a properties
/// and a costant.
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
private WalkedToken WalkTwoProperties(WalkedToken left, WalkedToken right)
{
return WalkedToken.FromCriterion(
expPropertyComparisonCreator(left.GetValue<String>(), right.GetValue<String>()));
}
internal abstract WalkedToken Walk(WalkedToken left, WalkedToken right);
internal abstract WalkedToken Walk(WalkedToken token);
internal override WalkedToken Walk(WalkedToken token)
{
return WalkedToken.FromCriterion( NHibernate.Expressions.Expression.Not(token.Criterion));
}
/// <summary>
/// Retrieve standard member access such as DateTime.Now, DateTime.Today, etc
/// </summary>
/// <param name="m"></param>
/// <param name="KnownMember"></param>
/// <returns></returns>
private WalkedToken GetKnownMemberAccess(System.Linq.Expressions.MemberExpression m, WalkedToken KnownMember)
{
if (m.Member.Name == "Today" && m.Member.ReflectedType == typeof(DateTime))
KnownMember = walkerFactory.FromConstant(DateTime.Today);
else if (m.Member.Name == "Today" && m.Member.ReflectedType == typeof(DateTime))
KnownMember = walkerFactory.FromConstant(DateTime.Now);
//else if (m.Member.Name == "Month") && m.Member.ReflectedType == typeof(DateTime))
// KnownMember =
return KnownMember;
}
internal override WalkedToken Walk(WalkedToken token)
{
return token;
}
/// <summary>
/// Retrieve standard member access such as DateTime.Now, DateTime.Today, etc
/// </summary>
/// <param name="m"></param>
/// <param name="KnownMember"></param>
/// <returns></returns>
private WalkedToken GetKnownMemberAccess(System.Linq.Expressions.MemberExpression m, WalkedToken KnownMember)
{
if (m.Member.Name == "Today" && m.Member.ReflectedType == typeof(DateTime))
{
KnownMember = walkerFactory.FromConstant(DateTime.Today);
}
else if (m.Member.Name == "Today" && m.Member.ReflectedType == typeof(DateTime))
{
KnownMember = walkerFactory.FromConstant(DateTime.Now);
}
//else if (m.Member.Name == "Month") && m.Member.ReflectedType == typeof(DateTime))
// KnownMember =
return(KnownMember);
}
