public void Visit(EqualsExpression expression)
{
var columnName = expression.PropertyExpression.PropertyName;
var value = expression.ValueExpression.Value;
MatchValue(columnName, value);
}
public void SerializeEqualsExpression()
{
var num = new LiteralExpression(1);
var a = new EqualsExpression(num, num);
var b = Reserialize(a);
Assert.AreEqual(a, b);
}
private void AssertParsingOfEqualsExpressionWithMethodParameter(string username)
{
var expression = _parser.Parse <User>(x => x.Username == username);
var expectedExpression = new EqualsExpression(new PropertyExpression("Username", typeof(string)),
new ValueExpression("a username"));
Assert.AreEqual(expectedExpression, expression);
}
public void Single_equality_comparison_with_new_object_is_parsed_into_property_name_and_value()
{
var expression = _parser.Parse <Comment>(x => x.PublishDate == new DateTime(2012, 1, 2));
var expectedExpression = new EqualsExpression(new PropertyExpression("PublishDate", typeof(DateTime)),
new ValueExpression(new DateTime(2012, 1, 2)));
Assert.AreEqual(expectedExpression, expression);
}
public void Single_equality_comparison_with_method_invocation_is_parsed_into_property_name_and_value()
{
var expression = _parser.Parse <User>(x => x.Username == GetUsername());
var expectedExpression = new EqualsExpression(new PropertyExpression("Username", typeof(string)),
new ValueExpression("a username"));
Assert.AreEqual(expectedExpression, expression);
}
public string GetExpression(EqualsExpression expression, ref List <OleDbParameter> parameters)
{
if ((expression.Children[1] is LiteralExpression) && ((expression.Children[1] as LiteralExpression).Value == null))
{
return(" ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " is null ) ");
}
return(" ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " = " +
GetExpressionDispatch(expression.Children[1], ref parameters) + " ) ");
}
public void Single_equality_comparison_with_lambda_parameter_is_parsed_into_property_name_and_value()
{
Func <string, QueryExpression> func = s => _parser.Parse <User>(x => x.Username == s);
var expression = func("a username");
var expectedExpression = new EqualsExpression(new PropertyExpression("Username", typeof(string)),
new ValueExpression("a username"));
Assert.AreEqual(expectedExpression, expression);
}
public void Visit(EqualsExpression expression)
{
if (expression.ValueExpression.Value == null)
{
var columnName = expression.PropertyExpression.PropertyName;
var columnReference = new ColumnReference(columnName, Escape);
ConstraintCommandText = string.Format("{0} IS NULL", columnReference);
}
else
{
VisitBinaryComparisonExpression(expression, "=");
}
}
private object Equal(object l, object r)
{
var scope = new Scope();
scope.SetVar("l", l);
scope.SetVar("r", r);
var exp = new EqualsExpression(
new VariableExpression("l"),
new VariableExpression("r")
);
return(exp.Evaluate(scope, new Bindings()).AsObject());
}
public void Single_equality_comparison_with_property_acces_on_lambda_parameter_is_parsed_into_property_name_and_value()
{
var user = new User {
Username = "******"
};
Func <User, QueryExpression> func = u => _parser.Parse <User>(x => x.Username == u.Username);
var expression = func(user);
var expectedExpression = new EqualsExpression(new PropertyExpression("Username", typeof(string)),
new ValueExpression("a username"));
Assert.AreEqual(expectedExpression, expression);
}
public void Equals_expression_with_constant_and_property_access_on_related_entity_yields_equals_expression_with_value_and_entity_reference_expression()
{
var expression = _parser.Parse <BlogPost>(x => x.Blog.Id == 1);
var blogProperty = Reflector <BlogPost> .GetProperty(x => x.Blog);
var blogIdProperty = Reflector <Blog> .GetProperty(x => x.Id);
var expectedExpression = new EqualsExpression(
new EntityReferenceExpression(blogProperty, blogIdProperty),
new ValueExpression(1));
Assert.AreEqual(expectedExpression, expression);
}
public void GetAndEvaluateEqualsExpression()
{
EqualsExpression expression = EqualsExpression.Instance;
Assert.IsNotNull(expression);
Machine machine = new Machine();
machine.Push(1);
machine.Push(2);
expression.Evaluate(machine);
Assert.AreEqual(1, machine.StackCount);
Assert.IsFalse((bool)machine.Pop());
Assert.AreEqual(0, machine.StackCount);
machine.Push(2);
machine.Push(2);
expression.Evaluate(machine);
Assert.AreEqual(1, machine.StackCount);
Assert.IsTrue((bool)machine.Pop());
Assert.AreEqual(0, machine.StackCount);
machine.Push("foo");
machine.Push("bar");
expression.Evaluate(machine);
Assert.AreEqual(1, machine.StackCount);
Assert.IsFalse((bool)machine.Pop());
Assert.AreEqual(0, machine.StackCount);
machine.Push("foo");
machine.Push("foo");
expression.Evaluate(machine);
Assert.AreEqual(1, machine.StackCount);
Assert.IsTrue((bool)machine.Pop());
Assert.AreEqual(0, machine.StackCount);
}
public void Equals_(dynamic value)
{
var expression = new EqualsExpression(
new FieldExpression(0, "value"),
new ValueExpression(value)
);
if (value is string)
{
value = $"\"{value}\"";
}
var json = $"{{ \"value\": {value.ToString().ToLower()} }}";
var bytes = Encoding.UTF8.GetBytes(json);
var matcher = new SlowMatcher(new[] { expression });
Assert.True(matcher.Match(bytes));
}
public void Visit(EqualsExpression expression)
{
var leftArg = new QueryPhaseArgs()
{
BoolQueryArg = new EqualQueryArg()
};
VisitChild(expression.Left, leftArg);
var rightArg = new QueryPhaseArgs()
{
BoolQueryArg = new EqualQueryArg()
};
VisitChild(expression.Right, rightArg);
var parentArgs = _visitStack.Peek();
parentArgs.RowResult = ValidateTypes(leftArg.BoolQueryArg, rightArg.BoolQueryArg, (l, r) => l == r);
}
/// <summary>
/// Determines whether an expression is an Implicit Join Expression
/// </summary>
/// <param name="expr">Expression</param>
/// <param name="lhsVar">LHS Variable</param>
/// <param name="rhsVar">RHS Variable</param>
/// <param name="equals">Whether the expression is an equals (true) or a same term (false)</param>
/// <returns></returns>
private bool IsImplicitJoinExpression(ISparqlExpression expr, out String lhsVar, out String rhsVar, out bool equals)
{
lhsVar = null;
rhsVar = null;
equals = false;
ISparqlExpression lhs, rhs;
if (expr is EqualsExpression)
{
EqualsExpression eq = (EqualsExpression)expr;
lhs = eq.Arguments.First();
rhs = eq.Arguments.Last();
equals = true;
}
else if (expr is SameTermFunction)
{
SameTermFunction st = (SameTermFunction)expr;
lhs = st.Arguments.First();
rhs = st.Arguments.Last();
}
else
{
return(false);
}
if (lhs is VariableTerm && rhs is VariableTerm)
{
lhsVar = lhs.Variables.First();
rhsVar = rhs.Variables.First();
return(!lhsVar.Equals(rhsVar));
}
else
{
return(false);
}
}
public void Single_equality_comparison_with_variable_is_parsed_into_property_name_and_value()
{
var localVariable = "a username";
var expression = _parser.Parse<User>(x => x.Username == localVariable);
var expectedExpression = new EqualsExpression(new PropertyExpression("Username", typeof(string)),
new ValueExpression("a username"));
Assert.AreEqual(expectedExpression, expression);
}
public void Single_equality_comparison_with_property_acces_on_lambda_parameter_is_parsed_into_property_name_and_value()
{
var user = new User { Username = "******" };
Func<User, QueryExpression> func = u => _parser.Parse<User>(x => x.Username == u.Username);
var expression = func(user);
var expectedExpression = new EqualsExpression(new PropertyExpression("Username", typeof(string)),
new ValueExpression("a username"));
Assert.AreEqual(expectedExpression, expression);
}
public void Single_equality_comparison_with_new_object_is_parsed_into_property_name_and_value()
{
var expression = _parser.Parse<Comment>(x => x.PublishDate == new DateTime(2012, 1, 2));
var expectedExpression = new EqualsExpression(new PropertyExpression("PublishDate", typeof(DateTime)),
new ValueExpression(new DateTime(2012, 1, 2)));
Assert.AreEqual(expectedExpression, expression);
}
public void Single_equality_comparison_with_lambda_parameter_is_parsed_into_property_name_and_value()
{
Func<string, QueryExpression> func = s => _parser.Parse<User>(x => x.Username == s);
var expression = func("a username");
var expectedExpression = new EqualsExpression(new PropertyExpression("Username", typeof(string)),
new ValueExpression("a username"));
Assert.AreEqual(expectedExpression, expression);
}
public void Equals_expression_with_constant_and_property_access_on_related_entity_yields_equals_expression_with_value_and_entity_reference_expression()
{
var expression = _parser.Parse<BlogPost>(x => x.Blog.Id == 1);
var blogProperty = Reflector<BlogPost>.GetProperty(x => x.Blog);
var blogIdProperty = Reflector<Blog>.GetProperty(x => x.Id);
var expectedExpression = new EqualsExpression(
new EntityReferenceExpression(blogProperty, blogIdProperty),
new ValueExpression(1));
Assert.AreEqual(expectedExpression, expression);
}
public string GetExpression(EqualsExpression expression, ref List<OleDbParameter> parameters)
{
if ((expression.Children[1] is LiteralExpression) && ((expression.Children[1] as LiteralExpression).Value == null))
return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " is null ) ";
return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " = " +
GetExpressionDispatch(expression.Children[1], ref parameters) + " ) ";
}
public virtual IExpression Visit(EqualsExpression expression)
{
return(expression);
}
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);
}
public void Visit(EqualsExpression expression)
{
var columnName = expression.PropertyExpression.PropertyName;
var value = expression.ValueExpression.Value;
MatchValue(columnName, value);
}
private bool MatchEqualsExpression(EqualsExpression expression)
{
return(CompareExpressions(expression.LeftHandSide, expression.RightHandSide) == 0);
}
/// <summary>
/// Takes <see cref="EqualsExpression" /> and replaces the two parameters with the given expressions,
/// returning the transformed body.
/// </summary>
/// <param name="leftExpression"> The new left expression. </param>
/// <param name="rightExpression"> The new right expression. </param>
/// <returns> The body of the lambda with left and right parameters replaced.</returns>
public virtual Expression ExtractEqualsBody(
Expression leftExpression,
Expression rightExpression)
{
return EqualsExpression.GetBody(leftExpression, rightExpression);
}
public void Visit(EqualsExpression expression)
{
DoBoolean(expression, CodeBinaryOperatorType.IdentityEquality);
}
private void AssertParsingOfEqualsExpressionWithMethodParameter(string username)
{
var expression = _parser.Parse<User>(x => x.Username == username);
var expectedExpression = new EqualsExpression(new PropertyExpression("Username", typeof(string)),
new ValueExpression("a username"));
Assert.AreEqual(expectedExpression, expression);
}
public override void Visit(EqualsExpression expression)
{
_expressionString.Append(" (");
Visit(expression.Left);
_expressionString.Append(" == ");
Visit(expression.Right);
_expressionString.Append(") ");
}
/// <summary>
/// Determines whether an expression is an Identity Expression
/// </summary>
/// <param name="expr">Expression</param>
/// <param name="var">Variable</param>
/// <param name="term">Term</param>
/// <param name="equals">Whether it is an equals expression (true) or a same term expression (false)</param>
/// <returns></returns>
private bool IsIdentityExpression(ISparqlExpression expr, out String var, out INode term, out bool equals)
{
var = null;
term = null;
equals = false;
ISparqlExpression lhs, rhs;
if (expr is EqualsExpression)
{
equals = true;
EqualsExpression eq = (EqualsExpression)expr;
lhs = eq.Arguments.First();
rhs = eq.Arguments.Last();
}
else if (expr is SameTermFunction)
{
SameTermFunction st = (SameTermFunction)expr;
lhs = st.Arguments.First();
rhs = st.Arguments.Last();
}
else
{
return(false);
}
if (lhs is VariableTerm)
{
if (rhs.GetType().Equals(_exprType))
{
var = lhs.Variables.First();
term = rhs.Evaluate(null, 0);
if (term.NodeType == NodeType.Uri)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
else if (lhs.GetType().Equals(_exprType))
{
if (rhs is VariableTerm)
{
var = rhs.Variables.First();
term = lhs.Evaluate(null, 0);
if (term.NodeType == NodeType.Uri)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public virtual void PostVisit(EqualsExpression data)
{
}
public void Visit(EqualsExpression expression, CommonTree tree)
{
SetLine(expression, tree);
Parent(tree).Children.Add(expression);
VisitChildren(tree);
}
public virtual void Visit(EqualsExpression expression)
{
}
