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(); }