public DynamicFormulaMeasure(string formula, IPivotData pvtData)
{
Parser = new LambdaParser();
Formula = formula;
var formulaExpr = Parser.Parse(formula);
var formulaParams = LambdaParser.GetExpressionParameters(formulaExpr);
var paramMeasureIndexes = new List <int>();
var paramMeasureNames = new List <string>();
foreach (var fParam in formulaParams)
{
if (paramMeasureNames.Contains(fParam.Name))
{
continue; // avoid duplicates
}
var paramMsrIdx = ResolveAggregatorIndex(fParam.Name, pvtData);
if (paramMsrIdx >= 0)
{
paramMeasureIndexes.Add(paramMsrIdx);
paramMeasureNames.Add(fParam.Name);
}
}
ArgMeasureIndexes = paramMeasureIndexes.ToArray();
ParamNameToArgIdx = new Dictionary <string, int>();
for (int i = 0; i < paramMeasureNames.Count; i++)
{
ParamNameToArgIdx[paramMeasureNames[i]] = i;
}
}
/// <summary>
/// 值转换
/// </summary>
/// <param name="value"></param>
/// <param name="dataType"></param>
/// <param name="converter"></param>
/// <returns></returns>
private string ParseValue(string value, string dataType, string converter)
{
string type = dataType.Trim().ToLower();
if (type == "number")
{
if (!string.IsNullOrEmpty(converter))
{
var exp = LambdaParser.Parse <Func <double, double> >(converter);
var func = exp.Compile();
double v = Convert.ToDouble(value);
return(func(v).ToString());
}
}
else if (type == "date")
{
string[] arr = value.Split(',');
DateTime dt = ByteArray2DateTime(arr.Select(s => Convert.ToByte(s)).ToArray());
if (!string.IsNullOrEmpty(converter))
{
var exp = LambdaParser.Parse <Func <DateTime, DateTime> >(converter);
var func = exp.Compile();
return(func(dt).ToString());
}
return(dt.ToString());
}
return(value);
}
public void ParsePerfNReco()
{
var paramList = new List <string>();
var lambdaParser = new LambdaParser();
var exp = "(a*2 + 100)/b + suka + testObj.Dupel((d + s)*(x + y))";
var parseResult = lambdaParser.Parse(exp);
this.ParamFind(parseResult, ref paramList);
paramList.ForEach(Console.WriteLine);
var varContext = new Dictionary <string, object> {
["testObj"] = new TestClass()
};
foreach (var prm in paramList)
{
if (prm.Contains("testObj"))
{
continue;
}
varContext.Add(prm, 10);
}
var result = (decimal)lambdaParser.Eval(exp, varContext);
Console.WriteLine(result);
}
public void NewTest()
{
TryAction(() =>
{
Expression <Func <object> > targetExp = LambdaParser.Parse <Func <object> >("() => new object(){}");
Assert.IsTrue(targetExp.Compile().Invoke() != null);
});
}
public void StrongConvertTest()
{
TryAction(() =>
{
Expression <Func <int> > srcExp = () => (int)3.2;
Expression <Func <int> > targetExp = LambdaParser.Parse <Func <int> >("() => (int)3.2");
IsTrue(srcExp, targetExp);
});
}
public void IsTest()
{
TryAction(() =>
{
object obj = new object();
Expression <Func <object, bool> > targetExp = LambdaParser.Parse <Func <object, bool> >("(t) => t != null && t is object == true");
Assert.IsTrue(targetExp.Compile().Invoke(obj));
});
}
public void MathTest()
{
TryAction(() =>
{
Expression <Func <int> > srcExp = () => (int)(Math.Pow(2, 3) + Math.Sqrt(4) + Math.PI);
Expression <Func <int> > targetExp = LambdaParser.Parse <Func <int> >("() => (int)(Math.Pow(2, 3) + Math.Sqrt(4)+ Math.PI)", "System");
IsTrue(srcExp, targetExp);
});
}
public void SizeofTest()
{
TryAction(() =>
{
Expression <Func <int> > srcExp = () => sizeof(double);
Expression <Func <int> > targetExp = LambdaParser.Parse <Func <int> >("() => sizeof(double)");
IsTrue(srcExp, targetExp);
});
}
public void ExponenTest()
{
TryAction(() =>
{
Expression <Func <double> > srcExp = () => 2 * 3.40E+30F;
Expression <Func <double> > targetExp = LambdaParser.Parse <Func <double> >("() => 2 * 3.40E+30F");
IsTrue(srcExp, targetExp);
});
}
public void ImplicitConvertTest()
{
TryAction(() =>
{
Expression <Func <double> > srcExp = () => 1.2f + 3.2;
Expression <Func <double> > targetExp = LambdaParser.Parse <Func <double> >("() => 1.2f + 3.2");
IsTrue(srcExp, targetExp);
});
}
public void ShiftTest()
{
TryAction(() =>
{
Expression <Func <int> > srcExp = () => 6 << 2 + 5 >> 1;
Expression <Func <int> > targetExp = LambdaParser.Parse <Func <int> >("() => 6 << 2 + 5 >> 1");
IsTrue(srcExp, targetExp);
});
}
public void UnitaryTest()
{
TryAction(() =>
{
Expression <Func <int> > srcExp = () => - 1 + ~(5 + 1);
Expression <Func <int> > targetExp = LambdaParser.Parse <Func <int> >("() => -1 + ~(5 + 1)");
IsTrue(srcExp, targetExp);
});
}
public void Parse_WhenOnlyMemberIsPassed_ThrowsException()
{
var parser = new LambdaParser();
var ex = Assert.Throws<SisoDbException>(
() => parser.Parse<MyClass>(i => i.Bool1));
Assert.AreEqual(ExceptionMessages.LambdaParser_NoMemberExpressions, ex.Message);
}
public void Parse_WhenByteArray_NotSupportedException()
{
var parser = new LambdaParser();
var ex = Assert.Throws<NotSupportedException>(
() => parser.Parse<MyClass>(i => i.Bytes1 == new byte[] { 1, 2 }));
Assert.AreEqual(ExceptionMessages.LambdaParser_MemberIsBytes.Inject("Bytes1"), ex.Message);
}
public void ArithmeticTest()
{
TryAction(() =>
{
Expression <Func <int> > srcExp = () => 3 + 2 * 5 + ((5 - 1) + 10) / 4;
Expression <Func <int> > targetExp = LambdaParser.Parse <Func <int> >("() => 3 + 2 * 5 + ((5 - 1) + 10) / 4");
IsTrue(srcExp, targetExp);
});
}
public void ConditionTest()
{
TryAction(() =>
{
Expression <Func <int, int, int> > srcExp = (x, y) => x > y ? x : y;
Expression <Func <int, int, int> > targetExp = LambdaParser.Parse <Func <int, int, int> >("(x, y) => x > y ? x : y");
IsTrue(srcExp, targetExp, 1, 2);
IsTrue(srcExp, targetExp, 2, 1);
});
}
public void Parse_WhenUnsupportedMethodInvocation_NotSupportedException()
{
var parser = new LambdaParser();
var ex = Assert.Throws<NotSupportedException>(
() => parser.Parse<MyClass>(i => i.String1 == Convert.ToString(i.Int1)));
Assert.AreEqual(
ExceptionMessages.LambdaParser_UnsupportedMethodCall.Inject("ToString(i.Int1)"),
ex.Message);
}
public void IndexTest()
{
TryAction(() =>
{
List <int> list = new List <int> {
1, 2, 3, 4
};
Expression <Func <List <int>, int> > srcExp = (l) => l[1] + l[2];
Expression <Func <List <int>, int> > targetExp = LambdaParser.Parse <Func <List <int>, int> >("(l) => l[1] + l[2]");
Assert.IsTrue(srcExp.Compile().Invoke(list) == targetExp.Compile().Invoke(list));
});
}
public void GenericTest()
{
TryAction(() =>
{
Expression <Func <TestObj, string> > srcExp = (t) => t.Func <int, string>(4);
Expression <Func <TestObj, string> > targetExp = LambdaParser.Parse <Func <TestObj, string> >("(t) => t.Func<int, string>(4)");
var test = new TestObj {
Count = 15
};
Assert.IsTrue(srcExp.Compile().Invoke(test) == targetExp.Compile().Invoke(test));
});
}
public void CompareTest()
{
TryAction(() =>
{
Expression <Func <TestObj, bool> > srcExp = (t) => !(t.Count > 5) || (t.Count < 100 && t.Count > 10);
Expression <Func <TestObj, bool> > targetExp = LambdaParser.Parse <Func <TestObj, bool> >("(t) => !(t.Count > 5) || (t.Count < 100 && t.Count > 10)");
var test = new TestObj {
Count = 15
};
Assert.IsTrue(srcExp.Compile().Invoke(test) == targetExp.Compile().Invoke(test));
});
}
public void CustomObjTest()
{
TryAction(() =>
{
Expression <Func <TestObj, long> > srcExp = (t) => t.Count + 8L;
Expression <Func <TestObj, long> > targetExp = LambdaParser.Parse <Func <TestObj, long> >("(t) => t.Count + 8L");
var test = new TestObj {
Count = 15
};
Assert.IsTrue(srcExp.Compile().Invoke(test) == targetExp.Compile().Invoke(test));
});
}
public void NullComparison()
{
var varContext = getContext();
var lambdaParser = new LambdaParser();
Assert.True((bool)lambdaParser.Eval("null == nullVar", varContext));
Assert.True((bool)lambdaParser.Eval("5>nullVar", varContext));
Assert.True((bool)lambdaParser.Eval("testObj!=null", varContext));
Assert.Equal(0, LambdaParser.GetExpressionParameters(lambdaParser.Parse("20 == null")).Length);
lambdaParser = new LambdaParser(new ValueComparer()
{
NullComparison = ValueComparer.NullComparisonMode.Sql
});
Assert.False((bool)lambdaParser.Eval("null == nullVar", varContext));
Assert.False((bool)lambdaParser.Eval("nullVar<5", varContext));
Assert.False((bool)lambdaParser.Eval("nullVar>5", varContext));
}
public void Eval()
{
var lambdaParser = new LambdaParser();
var varContext = new Dictionary <string, object>();
varContext["pi"] = 3.14M;
varContext["one"] = 1M;
varContext["two"] = 2M;
varContext["test"] = "test";
varContext["now"] = DateTime.Now;
varContext["testObj"] = new TestClass();
varContext["arr1"] = new double[] { 1.5, 2.5 };
varContext["NOT"] = (Func <bool, bool>)((t) => !t);
varContext["Yes"] = true;
varContext["nullVar"] = null;
varContext["name_with_underscore"] = "a_b";
varContext["_name_with_underscore"] = "_a_b";
Assert.AreEqual("st", lambdaParser.Eval("test.Substring(2)", varContext));
Assert.AreEqual(3, lambdaParser.Eval("1+2", varContext));
Assert.AreEqual(6, lambdaParser.Eval("1+2+3", varContext));
Assert.AreEqual("b{0}_", lambdaParser.Eval("\"b{0}_\"", varContext));
Assert.AreEqual(3, lambdaParser.Eval("(1+(3-1)*4)/3", varContext));
Assert.AreEqual(1, lambdaParser.Eval("one*5*one-(-1+5*5%10)", varContext));
Assert.AreEqual("ab", lambdaParser.Eval("\"a\"+\"b\"", varContext));
Assert.AreEqual(4.14, lambdaParser.Eval("pi + 1", varContext));
Assert.AreEqual(5.14, lambdaParser.Eval("2 +pi", varContext));
Assert.AreEqual(2.14, lambdaParser.Eval("pi + -one", varContext));
Assert.AreEqual("test1", lambdaParser.Eval("test + \"1\"", varContext));
Assert.AreEqual("a_b_a_b", lambdaParser.Eval(" name_with_underscore + _name_with_underscore ", varContext));
Assert.AreEqual(1, lambdaParser.Eval("true or false ? 1 : 0", varContext));
Assert.AreEqual(true, lambdaParser.Eval("5<=3 ? false : true", varContext));
Assert.AreEqual(5, lambdaParser.Eval("pi>one && 0<one ? (1+8)/3+1*two : 0", varContext));
Assert.AreEqual(4, lambdaParser.Eval("pi>0 ? one+two+one : 0", varContext));
Assert.AreEqual(DateTime.Now.Year, lambdaParser.Eval("now.Year", varContext));
Assert.AreEqual(true, lambdaParser.Eval(" (1+testObj.IntProp)==2 ? testObj.FldTrue : false ", varContext));
Assert.AreEqual("ab2_3", lambdaParser.Eval(" \"a\"+testObj.Format(\"b{0}_{1}\", 2, \"3\".ToString() ).ToString() ", varContext));
Assert.AreEqual(true, lambdaParser.Eval(" testObj.Hash[\"a\"] == \"1\"", varContext));
Assert.AreEqual(true, lambdaParser.Eval(" (testObj.Hash[\"a\"]-1)==testObj.Hash[\"b\"].Length ", varContext));
Assert.AreEqual(4.0, lambdaParser.Eval(" arr1[0]+arr1[1] ", varContext));
Assert.AreEqual(2, lambdaParser.Eval(" (new[]{1,2})[1] ", varContext));
Assert.AreEqual(true, lambdaParser.Eval(" new[]{ one } == new[] { 1 } ", varContext));
Assert.AreEqual(3, lambdaParser.Eval(" new dictionary{ {\"a\", 1}, {\"b\", 2}, {\"c\", 3} }.Count ", varContext));
Assert.AreEqual(2, lambdaParser.Eval(" new dictionary{ {\"a\", 1}, {\"b\", 2}, {\"c\", 3} }[\"b\"] ", varContext));
var arr = ((Array)lambdaParser.Eval(" new []{ new dictionary{{\"test\",2}}, new[] { one } }", varContext));
Assert.AreEqual(2, ((IDictionary)arr.GetValue(0))["test"]);
Assert.AreEqual(1, ((Array)arr.GetValue(1)).GetValue(0));
Assert.AreEqual("str", lambdaParser.Eval(" testObj.GetDelegNoParam()() ", varContext));
Assert.AreEqual("zzz", lambdaParser.Eval(" testObj.GetDelegOneParam()(\"zzz\") ", varContext));
Assert.AreEqual(false, lambdaParser.Eval("(testObj.FldTrue and false) || (testObj.FldTrue && false)", varContext));
Assert.AreEqual(true, lambdaParser.Eval("false or testObj.FldTrue", varContext));
Assert.AreEqual("True", lambdaParser.Eval("testObj.BoolParam(true)", varContext));
Assert.IsTrue((bool)lambdaParser.Eval("true && NOT( false )", varContext));
Assert.IsTrue((bool)lambdaParser.Eval("true && !( false )", varContext));
Assert.IsFalse((bool)lambdaParser.Eval("!Yes", varContext));
Assert.IsTrue((bool)lambdaParser.Eval("null == nullVar", varContext));
Assert.IsTrue((bool)lambdaParser.Eval("5>nullVar", varContext));
Assert.IsTrue((bool)lambdaParser.Eval("testObj!=null", varContext));
Assert.AreEqual(0, LambdaParser.GetExpressionParameters(lambdaParser.Parse("20 == null")).Length);
lambdaParser = new LambdaParser(new ValueComparer()
{
NullComparison = ValueComparer.NullComparisonMode.Sql
});
Assert.IsFalse((bool)lambdaParser.Eval("null == nullVar", varContext));
Assert.IsFalse((bool)lambdaParser.Eval("nullVar<5", varContext));
Assert.IsFalse((bool)lambdaParser.Eval("nullVar>5", varContext));
}
private void Run(string name)
{
string outDir = "ExprParser";
string text = GetResText(InResName(name));
string inName = name + "Input.txt";
string outName = name + "Output.txt";
string outNameAssem = name + "Output.Assem.txt";
string outPath = DeleteOutputPath(outDir, outName);
string outPathAssem = DeleteOutputPath(outDir, outNameAssem);
using (var wr = OpenWriter(outPath))
{
var wrt = new IndentedTextWriter(wr, " ");
// Individual scripts are separated by $.
// Inputs start after #.
int count = 0;
int ichLim = 0;
int lineLim = 1;
for (; ichLim < text.Length; ichLim++)
{
int ichMin = ichLim;
int lineMin = lineLim;
while (ichLim < text.Length && text[ichLim] != '$')
{
if (text[ichLim] == '\n')
{
lineLim++;
}
ichLim++;
}
while (ichMin < ichLim && char.IsWhiteSpace(text[ichMin]))
{
if (text[ichMin] == '\n')
{
lineMin++;
}
ichMin++;
}
if (ichMin >= ichLim)
{
continue;
}
// Process the script.
count++;
string scriptName = string.Format("Script {0}, lines {1} to {2}", count, lineMin, lineLim);
wrt.WriteLine("===== Start {0} =====", scriptName);
var types = ParseTypes(text, ref ichMin, ichLim);
int ichLimChars = text.IndexOf('#', ichMin);
if (ichLimChars < 0 || ichLimChars >= ichLim)
{
ichLimChars = ichLim;
}
else
{
Contracts.Assert(ichMin < ichLimChars && ichLimChars < ichLim);
}
CharCursor chars = new CharCursor(text, ichMin, ichLimChars);
Delegate del = null;
lock (_sync)
{
try
{
LambdaNode node;
List <Error> errors;
List <int> lineMap;
var perm = Utils.GetIdentityPermutation(types.Length);
using (wrt.Nest())
{
node = LambdaParser.Parse(out errors, out lineMap, chars, perm, types);
}
Check(node != null, "Null LambdaNode");
if (Utils.Size(errors) > 0)
{
DumpErrors(wrt, lineMap, lineMin, inName, "Parsing", errors);
goto LDone;
}
LambdaBinder.Run(Env, ref errors, node, msg => wr.WriteLine(msg));
if (Utils.Size(errors) > 0)
{
DumpErrors(wrt, lineMap, lineMin, inName, "Binding", errors);
goto LDone;
}
wrt.WriteLine("Binding succeeded. Output type: {0}", node.ResultType);
del = LambdaCompiler.Compile(out errors, node);
Contracts.Assert(TestFuncs1.Writer == null);
TestFuncs1.Writer = wr;
if (Utils.Size(errors) > 0)
{
DumpErrors(wrt, lineMap, lineMin, inName, "Compiling", errors);
goto LDone;
}
wrt.WriteLine("Compiling succeeded.");
if (ichLimChars < ichLim)
{
Evaluate(wrt, del, node.ResultType, types, text, ichLimChars + 1, ichLim);
}
}
catch (Exception ex)
{
if (!ex.IsMarked())
{
wrt.WriteLine("Unknown Exception: {0}!", del != null ? del.GetMethodInfo().DeclaringType : (object)"<null>");
}
wrt.WriteLine("Exception: {0}", ex.Message);
}
finally
{
TestFuncs1.Writer = null;
}
LDone:
wrt.WriteLine("===== End {0} =====", scriptName);
}
}
}
CheckEquality(outDir, outName, digitsOfPrecision: 6);
Done();
}
