|
public static NotEqual ( |
||
| left | An |
|
| right | An |
|
| return | ||
public Expression AttemptToConvert(Expression exp)
{
var converted = base.Visit(exp);
if (converted.Type == typeof(bool))
return converted;
if (exp.Type == typeof(int))
return exp.NotEqual(Expression.Constant(0));
if (!exp.Type.IsValueType)
return exp.NotEqual(Expression.Constant(null));
return exp;
}
/// <summary>
/// Transform as expression (value is read).
/// </summary>
protected internal override MAst Transform()
{
if (_innerExpression.Type == typeof(string))
{
Expression <Func <string, bool> > result = str => !string.IsNullOrEmpty(str);
MAst arg = _innerExpression.Transform();
UnaryExpression converted = arg.Convert <string>();
return(result.eInvoke(converted));
}
else if (_innerExpression.Type.IsValueType)
{
var zero = (ValueType)(Activator.CreateInstance(_innerExpression.Type));
return(MAst.NotEqual(_innerExpression.Transform(), MAst.Constant(zero, _innerExpression.Type)));
}
else if (_innerExpression.Type == typeof(Null))
{
return(MAst.Constant(false, typeof(bool)));
}
else
{
Expression <Func <object, bool> > result = o => (o != null);
MAst arg = _innerExpression.Transform();
UnaryExpression converted = arg.Convert <object>();
return(result.eInvoke(converted));
}
}
public void TestWhereComparison()
{
// Partial LINQ expression (x => x.Number1)
var parameter = LinqExpression.Parameter(typeof(NumbersModel), "x");
var n1 = LinqExpression.Property(parameter, "Number1");
var l3 = new Func <int, bool>(n => n < 3);
var le3 = new Func <int, bool>(n => n <= 3);
var g6 = new Func <int, bool>(n => n > 6);
var ge6 = new Func <int, bool>(n => n >= 6);
var e7 = new Func <int, bool>(n => n == 7);
var ne7 = new Func <int, bool>(n => n != 7);
var cases = new[] {
Tuple.Create((LinqExpression)LinqExpression.LessThan(n1, LinqExpression.Constant(3)),
(Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)l3, parameter),
Tuple.Create((LinqExpression)LinqExpression.LessThanOrEqual(n1, LinqExpression.Constant(3)),
(Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)le3, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(n1, LinqExpression.Constant(6)),
(Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)g6, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThanOrEqual(n1, LinqExpression.Constant(6)),
(Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)ge6, parameter),
Tuple.Create((LinqExpression)LinqExpression.Equal(n1, LinqExpression.Constant(7)),
(Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)e7, parameter),
Tuple.Create((LinqExpression)LinqExpression.NotEqual(n1, LinqExpression.Constant(7)),
(Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)ne7, parameter)
};
LoadModelNumbers(10);
Db.Count.Should().Be(10);
RunTestWithNumbers(new[] { 2, 3, 4, 5, 1, 9 }, cases);
}
static Expression ToBool(DynamicMetaObject target)
{
if (target.LimitType == typeof(bool))
{
return(Expr.Convert(target.Expression, typeof(bool)));
}
return(Expr.NotEqual(target.Expression, Expr.Constant(null)));
}
/// <summary>
/// 操作
/// </summary>
/// <param name="left">左操作数</param>
/// <param name="operator">运算符</param>
/// <param name="value">值</param>
public static MicrosoftExpression Operation(this MicrosoftExpression left, Operator @operator, object value)
{
return(@operator switch
{
Operator.Equal => left.Equal(value),
Operator.NotEqual => left.NotEqual(value),
Operator.Greater => left.Greater(value),
Operator.GreaterEqual => left.GreaterEqual(value),
Operator.Less => left.Less(value),
Operator.LessEqual => left.LessEqual(value),
Operator.Starts => left.StartsWith(value),
Operator.Ends => left.EndsWith(value),
Operator.Contains => left.Contains(value),
_ => throw new NotImplementedException()
});
private Exp ToBoolean(Exp expression)
{
if (expression.Type == typeof(bool))
{
return(expression);
}
if (expression.Type == typeof(int))
{
return(Exp.NotEqual(expression, Exp.Constant(0)));
}
if (expression.Type == typeof(float))
{
return(Exp.NotEqual(expression, Exp.Constant(0.0f)));
}
throw new Exception("Cannot convert expression to boolean");
}
private BinaryExpression BinaryExpression(
ExpressionType nodeType, System.Type type, JObject obj)
{
var left = this.Prop(obj, "left", this.Expression);
var right = this.Prop(obj, "right", this.Expression);
var method = this.Prop(obj, "method", this.Method);
var conversion = this.Prop(obj, "conversion", this.LambdaExpression);
var liftToNull = this.Prop(obj, "liftToNull").Value <bool>();
switch (nodeType)
{
case ExpressionType.Add: return(Expr.Add(left, right, method));
case ExpressionType.AddAssign: return(Expr.AddAssign(left, right, method, conversion));
case ExpressionType.AddAssignChecked: return(Expr.AddAssignChecked(left, right, method, conversion));
case ExpressionType.AddChecked: return(Expr.AddChecked(left, right, method));
case ExpressionType.And: return(Expr.And(left, right, method));
case ExpressionType.AndAlso: return(Expr.AndAlso(left, right, method));
case ExpressionType.AndAssign: return(Expr.AndAssign(left, right, method, conversion));
case ExpressionType.ArrayIndex: return(Expr.ArrayIndex(left, right));
case ExpressionType.Assign: return(Expr.Assign(left, right));
case ExpressionType.Coalesce: return(Expr.Coalesce(left, right, conversion));
case ExpressionType.Divide: return(Expr.Divide(left, right, method));
case ExpressionType.DivideAssign: return(Expr.DivideAssign(left, right, method, conversion));
case ExpressionType.Equal: return(Expr.Equal(left, right, liftToNull, method));
case ExpressionType.ExclusiveOr: return(Expr.ExclusiveOr(left, right, method));
case ExpressionType.ExclusiveOrAssign: return(Expr.ExclusiveOrAssign(left, right, method, conversion));
case ExpressionType.GreaterThan: return(Expr.GreaterThan(left, right, liftToNull, method));
case ExpressionType.GreaterThanOrEqual: return(Expr.GreaterThanOrEqual(left, right, liftToNull, method));
case ExpressionType.LeftShift: return(Expr.LeftShift(left, right, method));
case ExpressionType.LeftShiftAssign: return(Expr.LeftShiftAssign(left, right, method, conversion));
case ExpressionType.LessThan: return(Expr.LessThan(left, right, liftToNull, method));
case ExpressionType.LessThanOrEqual: return(Expr.LessThanOrEqual(left, right, liftToNull, method));
case ExpressionType.Modulo: return(Expr.Modulo(left, right, method));
case ExpressionType.ModuloAssign: return(Expr.ModuloAssign(left, right, method, conversion));
case ExpressionType.Multiply: return(Expr.Multiply(left, right, method));
case ExpressionType.MultiplyAssign: return(Expr.MultiplyAssign(left, right, method, conversion));
case ExpressionType.MultiplyAssignChecked: return(Expr.MultiplyAssignChecked(left, right, method, conversion));
case ExpressionType.MultiplyChecked: return(Expr.MultiplyChecked(left, right, method));
case ExpressionType.NotEqual: return(Expr.NotEqual(left, right, liftToNull, method));
case ExpressionType.Or: return(Expr.Or(left, right, method));
case ExpressionType.OrAssign: return(Expr.OrAssign(left, right, method, conversion));
case ExpressionType.OrElse: return(Expr.OrElse(left, right, method));
case ExpressionType.Power: return(Expr.Power(left, right, method));
case ExpressionType.PowerAssign: return(Expr.PowerAssign(left, right, method, conversion));
case ExpressionType.RightShift: return(Expr.RightShift(left, right, method));
case ExpressionType.RightShiftAssign: return(Expr.RightShiftAssign(left, right, method, conversion));
case ExpressionType.Subtract: return(Expr.Subtract(left, right, method));
case ExpressionType.SubtractAssign: return(Expr.SubtractAssign(left, right, method, conversion));
case ExpressionType.SubtractAssignChecked: return(Expr.SubtractAssignChecked(left, right, method, conversion));
case ExpressionType.SubtractChecked: return(Expr.SubtractChecked(left, right, method));
default: throw new NotSupportedException();
}
}
public static Expression CreateLambdaExpression <T, TModel>(IEnumerable <FilterElement> filterElements, Type querytype, ParameterExpression arg)
{
Expression expression = Expression.Constant(true);
foreach (var filterElement in filterElements)
{
string[] props = filterElement.FilterSpecs.DataElement.Split('.');
Expression propertyExpression = arg;
var type = typeof(T);
Expression notNullExpression = Expression.Constant(true);
foreach (var property in props)
{
PropertyInfo pi = type.GetProperty(property);
propertyExpression = Expression.Property(propertyExpression, pi);
var nullExpression = Expression.Constant(GetNullExpressionForType(pi.PropertyType), pi.PropertyType);
notNullExpression = Expression.AndAlso(notNullExpression, Expression.NotEqual(propertyExpression, nullExpression));
type = pi.PropertyType;
}
var isLiteralType = type.IsEquivalentTo(typeof(string));
var valueExpression = Expression.Constant(filterElement.FieldValue, filterElement.Property.PropertyType);
Expression inputExpression, variableExpression;
if (filterElement.FilterSpecs.CaseSensitive && isLiteralType)
{
variableExpression = Expression.Call(propertyExpression,
typeof(String).GetMethod("ToUpper", new Type[] { }));
inputExpression = Expression.Call(valueExpression,
typeof(String).GetMethod("ToUpper", new Type[] { }));
}
else
{
// special case to handle nullable values
if (valueExpression.Type.IsNullable())
{
valueExpression = Expression.Constant(valueExpression.Value, filterElement.Property.PropertyType.NullableOf());
}
inputExpression = valueExpression;
variableExpression = propertyExpression;
}
BinaryExpression conditionExpression = Expression.Equal(variableExpression, valueExpression);
switch (filterElement.FilterSpecs.OperatorOption)
{
case Operator.Equal:
conditionExpression = Expression.Equal(variableExpression, inputExpression);
break;
case Operator.GreaterThan:
conditionExpression = Expression.GreaterThan(variableExpression, inputExpression);
break;
case Operator.GreaterThanOrEqualTo:
conditionExpression = Expression.GreaterThanOrEqual(variableExpression, inputExpression);
break;
case Operator.LessThan:
conditionExpression = Expression.LessThan(variableExpression, inputExpression);
break;
case Operator.LessThanOrEqualTo:
conditionExpression = Expression.LessThanOrEqual(variableExpression, inputExpression);
break;
case Operator.Unequal:
conditionExpression = Expression.NotEqual(variableExpression, inputExpression);
break;
case Operator.Like:
MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
var containsMethodCall = Expression.Call(variableExpression, method, inputExpression);
conditionExpression = Expression.Equal(containsMethodCall, Expression.Constant(true));
break;
}
var clausePart = Expression.AndAlso(notNullExpression, conditionExpression);
if (!filterElement.FieldValue.Equals(GetNullExpressionForType(filterElement.Property.PropertyType)))
{
expression = Expression.AndAlso(expression, clausePart);
}
}
return(expression);
}
/// <summary>
/// 创建不等于运算表达式
/// </summary>
/// <param name="left">左操作数</param>
/// <param name="value">值</param>
public static MicrosoftExpression NotEqual(this MicrosoftExpression left, object value)
{
return(left.NotEqual(Lambda.Constant(value, left)));
}
/// <summary>
/// 创建不等于运算表达式
/// </summary>
/// <param name="left">左操作数</param>
/// <param name="right">右操作数</param>
public static MicrosoftExpression NotEqual(this MicrosoftExpression left, MicrosoftExpression right)
{
return(MicrosoftExpression.NotEqual(left, right));
}
public static Expression[] /*!*/ MakeActualArgs(MetaObjectBuilder /*!*/ metaBuilder, CallArguments /*!*/ args,
bool includeSelf, bool selfIsInstance, bool calleeHasBlockParam, bool injectMissingBlockParam)
{
var actualArgs = new List <Expression>(args.ExplicitArgumentCount);
// self (instance):
if (includeSelf && selfIsInstance)
{
// test already added by method resolver
Debug.Assert(args.TargetExpression != null);
AddArgument(actualArgs, args.Target, args.TargetExpression);
}
Proc block = null;
Expression blockExpression = null;
// block test - we need to test for a block regardless of whether it is actually passed to the method or not
// since the information that the block is not null is used for overload resolution.
if (args.Signature.HasBlock)
{
block = args.GetBlock();
blockExpression = args.GetBlockExpression();
if (block == null)
{
metaBuilder.AddRestriction(Ast.Equal(blockExpression, Ast.Constant(null)));
}
else
{
// don't need to test the exact type of the Proc since the code is subclass agnostic:
metaBuilder.AddRestriction(Ast.NotEqual(blockExpression, Ast.Constant(null)));
}
}
// block:
if (calleeHasBlockParam)
{
if (args.Signature.HasBlock)
{
if (block == null)
{
// the user explicitly passed nil as a block arg:
actualArgs.Add(Ast.Constant(null));
}
else
{
// pass BlockParam:
Debug.Assert(metaBuilder.BfcVariable != null);
actualArgs.Add(metaBuilder.BfcVariable);
}
}
else
{
// no block passed into a method with a BlockParam:
actualArgs.Add(Ast.Constant(null));
}
}
else if (injectMissingBlockParam)
{
// no block passed into a method w/o a BlockParam (we still need to fill the missing block argument):
actualArgs.Add(Ast.Constant(null));
}
// self (non-instance):
if (includeSelf && !selfIsInstance)
{
// test already added by method resolver
AddArgument(actualArgs, args.Target, args.TargetExpression);
}
// simple arguments:
for (int i = 0; i < args.SimpleArgumentCount; i++)
{
var value = args.GetSimpleArgument(i);
var expr = args.GetSimpleArgumentExpression(i);
metaBuilder.AddObjectTypeRestriction(value, expr);
AddArgument(actualArgs, value, expr);
}
// splat argument:
int listLength;
ParameterExpression listVariable;
if (args.Signature.HasSplattedArgument)
{
object splattedArg = args.GetSplattedArgument();
Expression splattedArgExpression = args.GetSplattedArgumentExpression();
if (metaBuilder.AddSplattedArgumentTest(splattedArg, splattedArgExpression, out listLength, out listVariable))
{
// AddTestForListArg only returns 'true' if the argument is a List<object>
var list = (List <object>)splattedArg;
// get arguments, add tests
for (int j = 0; j < listLength; j++)
{
var value = list[j];
var expr = Ast.Call(listVariable, typeof(List <object>).GetMethod("get_Item"), Ast.Constant(j));
metaBuilder.AddObjectTypeCondition(value, expr);
AddArgument(actualArgs, value, expr);
}
}
else
{
// argument is not an array => add the argument itself:
AddArgument(actualArgs, splattedArg, splattedArgExpression);
}
}
// rhs argument:
if (args.Signature.HasRhsArgument)
{
var value = args.GetRhsArgument();
var expr = args.GetRhsArgumentExpression();
metaBuilder.AddObjectTypeRestriction(value, expr);
AddArgument(actualArgs, value, expr);
}
return(actualArgs.ToArray());
}
private static Exp CreateSubExpression(Exp pe, Type type, string text, FullTextSearchOptions options, bool isQueriable = false)
{
var texts = text.Split(new string[] { "||" }, StringSplitOptions.RemoveEmptyEntries)
.Select(t => t.Trim().ToLower())
.Where(t => t.Length > 0)
.ToList();
var properties = type.GetProperties().AsEnumerable();
if (isQueriable)
{
properties = properties.GetMappedProperties();
}
Exp predicateBody = null;
foreach (var prop in properties)
{
//Check if we can use this property in Search
if (options == null || options.Filter == null || options.Filter.Invoke(prop))
{
var paramExp = Exp.Property(pe, prop);
if (prop.PropertyType == typeof(string) || prop.PropertyType == typeof(int) ||
prop.PropertyType == typeof(int?))
{
Exp notNullExp = null;
if (prop.PropertyType == typeof(string))
{
Exp nullConst = Exp.Constant(null, typeof(string));
notNullExp = Exp.NotEqual(paramExp, nullConst);
}
Exp toStringExp = paramExp;
//Check if property has int type
if (prop.PropertyType == typeof(int?) || prop.PropertyType == typeof(int))
{
if (!isQueriable)
{
Exp toNullableIntExp = null;
//property should be nullable
if (prop.PropertyType == typeof(int))
{
toNullableIntExp = Exp.TypeAs(paramExp, typeof(int?));
}
Exp valueExp = null;
if (toNullableIntExp != null)
{
notNullExp = Exp.Property(toNullableIntExp, "HasValue");
valueExp = Exp.Property(toNullableIntExp, "Value");
}
else
{
notNullExp = Exp.Property(paramExp, "HasValue");
valueExp = Exp.Property(paramExp, "Value");
}
notNullExp = Exp.Equal(notNullExp, Exp.Constant(true, typeof(bool)));
var convertToString = typeof(Convert).GetMethod("ToString", new[] { typeof(int) });
toStringExp = Exp.Call(convertToString, valueExp);
}
else
{
var convertToString = typeof(Convert).GetMethod("ToString", new[] { typeof(int) });
toStringExp = Exp.Call(convertToString, Exp.Convert(paramExp, typeof(int)));
}
}
Exp peLower = Exp.Call(toStringExp, typeof(string).GetMethod("ToLower", System.Type.EmptyTypes));
Exp conditionExp = null;
foreach (var txt in texts)
{
var constant = Exp.Constant(txt, typeof(string));
Exp containsExp = Exp.Call(peLower, typeof(string).GetMethod("Contains", new[] { typeof(string) }), constant);
if (conditionExp != null)
{
conditionExp = Exp.OrElse(conditionExp, containsExp);
}
else
{
conditionExp = containsExp;
}
}
Exp andExp = (notNullExp != null) ? Exp.AndAlso(notNullExp, conditionExp) : conditionExp;
if (predicateBody != null)
{
predicateBody = Exp.OrElse(predicateBody, andExp);
}
else
{
predicateBody = andExp;
}
}
//If this property is't simple and the depth > 0
if (options != null && options.Depth != 0 &&
!prop.PropertyType.IsSimpleType() && !prop.PropertyType.IsEnumerable())
{
options.Depth -= 1;
var subExp = CreateSubExpression(paramExp, prop.PropertyType, text, options, isQueriable);
options.Depth += 1;
if (subExp != null)
{
Exp notNullExp = Exp.NotEqual(paramExp, Exp.Constant(null, typeof(object)));
subExp = Exp.AndAlso(notNullExp, subExp);
predicateBody = (predicateBody != null) ? Exp.OrElse(predicateBody, subExp) : subExp;
}
}
}
}
return(predicateBody);
}
// Generate code to perform row reduction.
private static void RowReduce(CodeGen code, LinqExpr Ab, int M, int N)
{
// For each variable in the system...
for (int j = 0; j + 1 < N; ++j)
{
LinqExpr _j = LinqExpr.Constant(j);
LinqExpr Abj = code.ReDeclInit <double[]>("Abj", LinqExpr.ArrayAccess(Ab, _j));
// int pi = j
LinqExpr pi = code.ReDeclInit <int>("pi", _j);
// double max = |Ab[j][j]|
LinqExpr max = code.ReDeclInit <double>("max", Abs(LinqExpr.ArrayAccess(Abj, _j)));
// Find a pivot row for this variable.
//code.For(j + 1, M, _i =>
//{
for (int i = j + 1; i < M; ++i)
{
LinqExpr _i = LinqExpr.Constant(i);
// if(|Ab[i][j]| > max) { pi = i, max = |Ab[i][j]| }
LinqExpr maxj = code.ReDeclInit <double>("maxj", Abs(LinqExpr.ArrayAccess(LinqExpr.ArrayAccess(Ab, _i), _j)));
code.Add(LinqExpr.IfThen(
LinqExpr.GreaterThan(maxj, max),
LinqExpr.Block(
LinqExpr.Assign(pi, _i),
LinqExpr.Assign(max, maxj))));
}
// (Maybe) swap the pivot row with the current row.
LinqExpr Abpi = code.ReDecl <double[]>("Abpi");
code.Add(LinqExpr.IfThen(
LinqExpr.NotEqual(_j, pi), LinqExpr.Block(
new[] { LinqExpr.Assign(Abpi, LinqExpr.ArrayAccess(Ab, pi)) }.Concat(
Enumerable.Range(j, N + 1 - j).Select(x => Swap(
LinqExpr.ArrayAccess(Abj, LinqExpr.Constant(x)),
LinqExpr.ArrayAccess(Abpi, LinqExpr.Constant(x)),
code.ReDecl <double>("swap")))))));
//// It's hard to believe this swap isn't faster than the above...
//code.Add(LinqExpr.IfThen(LinqExpr.NotEqual(_j, pi), LinqExpr.Block(
// Swap(LinqExpr.ArrayAccess(Ab, _j), LinqExpr.ArrayAccess(Ab, pi), Redeclare<double[]>(code, "temp")),
// LinqExpr.Assign(Abj, LinqExpr.ArrayAccess(Ab, _j)))));
// Eliminate the rows after the pivot.
LinqExpr p = code.ReDeclInit <double>("p", LinqExpr.ArrayAccess(Abj, _j));
//code.For(j + 1, M, _i =>
//{
for (int i = j + 1; i < M; ++i)
{
LinqExpr _i = LinqExpr.Constant(i);
LinqExpr Abi = code.ReDeclInit <double[]>("Abi", LinqExpr.ArrayAccess(Ab, _i));
// s = Ab[i][j] / p
LinqExpr s = code.ReDeclInit <double>("scale", LinqExpr.Divide(LinqExpr.ArrayAccess(Abi, _j), p));
// Ab[i] -= Ab[j] * s
for (int ji = j + 1; ji < N + 1; ++ji)
{
code.Add(LinqExpr.SubtractAssign(
LinqExpr.ArrayAccess(Abi, LinqExpr.Constant(ji)),
LinqExpr.Multiply(LinqExpr.ArrayAccess(Abj, LinqExpr.Constant(ji)), s)));
}
}
}
}
private static BinaryExpression NotEqualExpression(ParameterExpression parameter, string propertyName, object value)
{
var(bodyLeft, bodyRight) = GetBodyExpressions(parameter, propertyName, value);
return(SystemExpression.NotEqual(bodyLeft, bodyRight));
}
public static Expression NotEqual(Expression arg0, Expression arg1)
{
return(new Expression(LinqExpression.NotEqual(arg0, arg1)));
}
