public void ExtendPack() { dynamic evt = new ExpandoObject(); evt.UnEqualCommandLine = "let's start a crazy process, and break the internet!"; evt.EqualCommandLine = "this one should be equivalent!"; evt.NumericSeed = 1111; List <string> listExtendTestScalarFunctions = new List <string>() { "extend x = pack(\"First\", \"Second\", \"Numeric\", 1234, \"Numeric2\", 4567)", //"extend text = strlen(\"1234567890\")", //"extend text = tostring(123)" }; foreach (string extendedScalarFunction in listExtendTestScalarFunctions) { ExtendOperator extendOperator = new ExtendOperator(extendedScalarFunction); string serializationOfExtend = RxKqlCommonFunctions.ToJson(extendOperator); ExtendOperator hydratedExtendOperator = RxKqlCommonFunctions.ToExtendOperator(serializationOfExtend); Assert.AreEqual(extendedScalarFunction, hydratedExtendOperator.ToString()); } // Positive test... var x = RunAtomicQuery(evt, "extend p = pack(\"First\", \"Second\", \"Numeric\", 1234, \"Numeric2\", 5678, \"FieldValueOfSeed\", NumericSeed)"); Assert.AreEqual(x[0].p.First.ToString(), "Second"); // Should be "Second" Assert.AreEqual(x[0].p.Numeric.ToString(), "1234"); // Should be "1234" Assert.AreEqual(x[0].p.Numeric2.ToString(), "5678"); // Should be "5678" Assert.AreEqual(x[0].p.FieldValueOfSeed, 1111); // Should be "5678" }
public void Aris_PackArrayTest() { dynamic evt = new ExpandoObject(); WhereOperator whereOperatorHigh = new WhereOperator("sum_flow_count_low > 1000"); WhereOperator whereOperatorLow = new WhereOperator("sum_flow_count_low > 1000"); // Dehydrate string jsonWhere = RxKqlCommonFunctions.ToJson(whereOperatorHigh.Expression); // Hydrate var booleanExpression = RxKqlCommonFunctions.ToBooleanExpression(jsonWhere); // Evaluate the current Expression evt = new ExpandoObject(); try { // purposely add a value as a string and compare it to an integer, to throw a specific Exception Type evt.sum_flow_count_high = "101112"; TestWhere(evt, whereOperatorHigh, true); } catch (Exception ex) { Type exceptionType = ex.GetType(); Assert.AreEqual(exceptionType, typeof(EvaluationTypeMismatchException)); } evt.sum_flow_count_low = 999; TestWhere(evt, whereOperatorLow, false); }
public override object GetValue(IDictionary <string, object> evt) { var value = Left.GetValue(evt); var pattern = Right.GetValue(evt); return(RxKqlCommonFunctions.EvaluateMatchesRegex(value, pattern)); }
public override object GetValue(IDictionary <string, object> evt) { var value = Value.GetValue(evt); var low = Low.GetValue(evt); var high = High.GetValue(evt); return(RxKqlCommonFunctions.EvaluateBetween(value, low, high)); }
public override object GetValue(IDictionary <string, object> evt) { var value = Arguments[0].GetValue(evt); var low = Arguments[1].GetValue(evt); var high = Arguments[2].GetValue(evt); return(!RxKqlCommonFunctions.EvaluateBetween(value, low, high)); }
private bool EqualsMaybeCS(object a, object b) { if (CaseInsensitive) { return(string.Compare(a.ToString(), b.ToString(), true, CultureInfo.InvariantCulture) == 0); } return(RxKqlCommonFunctions.TryConvert(b, a.GetType(), out var bConverted) && a.Equals(bConverted)); }
public override object GetValue(IDictionary <string, object> evt) { var v = Value.GetValue(evt); var low = Low.GetValue(evt); var high = High.GetValue(evt); // Negate the return from this Expression, as it's NOT between. return(!RxKqlCommonFunctions.EvaluateBetween(v, low, high)); }
public void ExtendScalarConstAndPropSerializationDoubleQuoteTest() { string originalString = "extend text = AFieldName, intFive = 5, stringThree = \"Three\""; ExtendOperator extendOperator = new ExtendOperator(originalString); string serializationOfExtend = RxKqlCommonFunctions.ToJson(extendOperator); ExtendOperator hydratedExtendOperator = RxKqlCommonFunctions.ToExtendOperator(serializationOfExtend); Assert.AreEqual(originalString, hydratedExtendOperator.ToString()); }
public void ExtendReplaceFunctionSerializationTest() { string originalString = "extend result = replace(\"@ame.gbl\", \"@microsoft.com\", SubscriptionDetailsData.AccountAdminLiveEmailId)"; ExtendOperator extendOperator = new ExtendOperator(originalString); string serializationOfExtend = RxKqlCommonFunctions.ToJson(extendOperator); ExtendOperator hydratedExtendOperator = RxKqlCommonFunctions.ToExtendOperator(serializationOfExtend); Assert.AreEqual(originalString, hydratedExtendOperator.ToString()); }
public override object GetValue(IDictionary <string, object> evt) { var leftValue = RxKqlCommonFunctions.ParseNumericExpressionItem(Left.GetValue(evt).ToString()); var rightValue = RxKqlCommonFunctions.ParseNumericExpressionItem(Right.GetValue(evt).ToString()); if (leftValue is int || leftValue is long || leftValue is double) { var num1 = Convert.ToDouble(leftValue); var num2 = Convert.ToDouble(rightValue); switch (Operator) { case "-": return(num1 - num2); case "+": return(num1 + num2); case "*": return(num1 * num2); case "/": return(num1 / num2); default: throw new InvalidOperationException($"Invalid Operator: {Operator}"); } } else if (leftValue is DateTime) { var date1 = Convert.ToDateTime(leftValue); var date2 = Convert.ToDateTime(rightValue); switch (Operator) { case "-": return(date1 - date2); case "+": return(new DateTime(date1.Ticks + date2.Ticks)); default: throw new InvalidOperationException($"Invalid Operator: {Operator}"); } } else { throw new InvalidOperationException($"Invalid Numeric type: {leftValue.GetType()}"); } }
public override object GetValue(IDictionary <string, object> evt) { var left = Left.GetValue(evt); var right = Right.GetValue(evt); if (!RxKqlCommonFunctions.TryConvert <bool>(left, out var leftBool)) { throw new EvaluationTypeMismatchException($"Cannot convert value {left} to bool"); } if (!RxKqlCommonFunctions.TryConvert <bool>(right, out var rightBool)) { throw new EvaluationTypeMismatchException($"Cannot convert value {right} to bool"); } return(leftBool && rightBool); }
public void ExtendScalarFunctionSerializationTest() { List <string> listExtendTestScalarFunctions = new List <string>() { "extend text = strcat(\"Case \", original.id)", "extend text = strlen(\"1234567890\")", "extend text = tostring(123)" }; foreach (string extendedScalarFunction in listExtendTestScalarFunctions) { ExtendOperator extendOperator = new ExtendOperator(extendedScalarFunction); string serializationOfExtend = RxKqlCommonFunctions.ToJson(extendOperator); ExtendOperator hydratedExtendOperator = RxKqlCommonFunctions.ToExtendOperator(serializationOfExtend); Assert.AreEqual(extendedScalarFunction, hydratedExtendOperator.ToString()); } }
public override object GetValue(IDictionary <string, object> evt) { var value = Element.GetValue(evt); var indexer = Selector.GetValue(evt); if (value.IsGenericList() && RxKqlCommonFunctions.TryConvert <int>(indexer, out var index)) { //TODO negative indexing var list = (IList)value; if (index < 0 || index >= list.Count) { return(string.Empty); } return(list[index]); } //dict[col] is equivalent to dict.col return(new ScalarPath { Element = Element, Selector = Selector }.GetValue(evt)); }
public override object GetValue(IDictionary <string, object> evt) { return(RxKqlCommonFunctions.GetImmediateIfValue(evt, Arguments)); }
public void Aris_BasicExpressionTree() { dynamic evt = new ExpandoObject(); evt.Var1 = 123; evt.Var2 = 456; evt.Var3 = 789; evt.Var4 = 101112; WhereOperator whereOperator = new WhereOperator(); List <ScalarValue> orExpressions = new List <ScalarValue>(); orExpressions.Add(new EqualsExpression { Left = new ScalarProperty("Var1"), Operator = "==", Right = new ScalarConst { Value = 123 } }); orExpressions.Add(new EqualsExpression { Left = new ScalarProperty("Var2"), Operator = "==", Right = new ScalarConst { Value = 456 } }); var compositeExpression = new OrExpression { Left = orExpressions[0], Right = orExpressions[1] }; // Add a conditional AND expression to the embedded OR Expression var basicExpression = new EqualsExpression { Left = new ScalarProperty("Var3"), Operator = "==", Right = new ScalarConst { Value = 789 } }; var aggregateExpression = new AndExpression { Left = compositeExpression, Right = basicExpression }; // Add a conditional AND expression to the embedded Composite Expression var newOuterExpressionExpression = new EqualsExpression { Left = new ScalarProperty("Var4"), Operator = "==", Right = new ScalarConst { Value = 101112 } }; var finalExpression = new AndExpression { Left = aggregateExpression, Right = newOuterExpressionExpression }; // Evaluate the current Expression for TRUE whereOperator.Expression = finalExpression; TestWhere(evt, whereOperator, true); // Evaluate the current Expression for FALSE evt = new ExpandoObject(); evt.Var1 = 123; evt.Var2 = 111; // Evaluate false evt.Var3 = 222; // Evaluate false evt.Var4 = 101112; TestWhere(evt, whereOperator, false); // Evaluate the current Expression for FALSE evt = new ExpandoObject(); evt.Var1 = 123; evt.Var2 = 111; // Evaluate true evt.Var3 = 789; evt.Var4 = 101112; TestWhere(evt, whereOperator, true); // Dehydrate string jsonWhere = RxKqlCommonFunctions.ToJson(whereOperator.Expression); // Hydrate var booleanExpression = RxKqlCommonFunctions.ToBooleanExpression(jsonWhere); // Compare the expected result (e.g. hardcoded in the test) // with the actual value Assert.AreEqual(whereOperator.Expression, finalExpression); }