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