public void ParseSubstringFunctionExpressionWithTwoArguments()
{
var queryNode = FilterExpressionParser.Parse("substring(CompanyName,1,2) eq 'lf'", EntityDataModel.Current.EntitySets["Customers"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("substring", nodeLeft.Name);
Assert.Equal(3, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
Assert.Equal("CompanyName", ((PropertyAccessNode)nodeLeft.Parameters[0]).Property.Name);
Assert.IsType <ConstantNode>(nodeLeft.Parameters[1]);
Assert.Equal("1", ((ConstantNode)nodeLeft.Parameters[1]).LiteralText);
Assert.IsType <int>(((ConstantNode)nodeLeft.Parameters[1]).Value);
Assert.Equal(1, ((ConstantNode)nodeLeft.Parameters[1]).Value);
Assert.IsType <ConstantNode>(nodeLeft.Parameters[2]);
Assert.Equal("2", ((ConstantNode)nodeLeft.Parameters[2]).LiteralText);
Assert.IsType <int>(((ConstantNode)nodeLeft.Parameters[2]).Value);
Assert.Equal(2, ((ConstantNode)nodeLeft.Parameters[2]).Value);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode>(node.Right);
Assert.Equal("'lf'", ((ConstantNode)node.Right).LiteralText);
Assert.IsType <string>(((ConstantNode)node.Right).Value);
Assert.Equal("lf", ((ConstantNode)node.Right).Value);
}
public void ParseReplaceFunctionExpression()
{
var queryNode = FilterExpressionParser.Parse("replace(CompanyName, ' ', '') eq 'AlfredsFutterkiste'", EntityDataModel.Current.EntitySets["Customers"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("replace", nodeLeft.Name);
Assert.Equal(3, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
Assert.Equal("CompanyName", ((PropertyAccessNode)nodeLeft.Parameters[0]).Property.Name);
Assert.IsType <ConstantNode>(nodeLeft.Parameters[1]);
Assert.Equal("' '", ((ConstantNode)nodeLeft.Parameters[1]).LiteralText);
Assert.IsType <string>(((ConstantNode)nodeLeft.Parameters[1]).Value);
Assert.Equal(" ", ((ConstantNode)nodeLeft.Parameters[1]).Value);
Assert.IsType <ConstantNode>(nodeLeft.Parameters[2]);
Assert.Equal("''", ((ConstantNode)nodeLeft.Parameters[2]).LiteralText);
Assert.IsType <string>(((ConstantNode)nodeLeft.Parameters[2]).Value);
Assert.Equal("", ((ConstantNode)nodeLeft.Parameters[2]).Value);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode>(node.Right);
Assert.Equal("'AlfredsFutterkiste'", ((ConstantNode)node.Right).LiteralText);
Assert.IsType <string>(((ConstantNode)node.Right).Value);
Assert.Equal("AlfredsFutterkiste", ((ConstantNode)node.Right).Value);
}
public void ParseConcatFunctionExpression()
{
var queryNode = FilterExpressionParser.Parse("concat(concat(City, ', '), Country) eq 'Berlin, Germany'", EntityDataModel.Current.EntitySets["Customers"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("concat", nodeLeft.Name);
Assert.Equal(2, nodeLeft.Parameters.Count);
Assert.IsType <FunctionCallNode>(nodeLeft.Parameters[0]);
var nodeLeftArg0 = (FunctionCallNode)nodeLeft.Parameters[0];
Assert.Equal("concat", nodeLeftArg0.Name);
Assert.Equal(2, nodeLeftArg0.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeftArg0.Parameters[0]);
Assert.Equal("City", ((PropertyAccessNode)nodeLeftArg0.Parameters[0]).Property.Name);
Assert.IsType <ConstantNode>(nodeLeftArg0.Parameters[1]);
Assert.Equal(", ", ((ConstantNode)nodeLeftArg0.Parameters[1]).Value);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[1]);
var nodeLeftArg1 = (PropertyAccessNode)nodeLeft.Parameters[1];
Assert.Equal("Country", nodeLeftArg1.Property.Name);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode>(node.Right);
var nodeRight = (ConstantNode)node.Right;
Assert.Equal("'Berlin, Germany'", nodeRight.LiteralText);
}
public void ParseEndswithFunctionEqTrueExpression()
{
var queryNode = FilterExpressionParser.Parse("endswith(CompanyName, 'Futterkiste') eq true", EntityDataModel.Current.EntitySets["Customers"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("endswith", nodeLeft.Name);
Assert.Equal(2, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
Assert.Equal("CompanyName", ((PropertyAccessNode)nodeLeft.Parameters[0]).Property.Name);
Assert.IsType <ConstantNode>(nodeLeft.Parameters[1]);
Assert.Equal("'Futterkiste'", ((ConstantNode)nodeLeft.Parameters[1]).LiteralText);
Assert.IsType <string>(((ConstantNode)nodeLeft.Parameters[1]).Value);
Assert.Equal("Futterkiste", ((ConstantNode)nodeLeft.Parameters[1]).Value);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode>(node.Right);
Assert.Same(ConstantNode.True, node.Right);
}
public void ParseSubstringFunctionExpressionWithOneArgument()
{
QueryNode queryNode = FilterExpressionParser.Parse("substring(CompanyName, 1) eq 'lfreds Futterkiste'", EntityDataModel.Current.EntitySets["Customers"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("substring", nodeLeft.Name);
Assert.Equal(2, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
var nodeLeftParam0 = (PropertyAccessNode)nodeLeft.Parameters[0];
Assert.Equal("CompanyName", nodeLeftParam0.PropertyPath.Property.Name);
Assert.IsType <ConstantNode <int> >(nodeLeft.Parameters[1]);
var nodeLeftParam1 = (ConstantNode <int>)nodeLeft.Parameters[1];
Assert.Equal("1", nodeLeftParam1.LiteralText);
Assert.Equal(1, nodeLeftParam1.Value);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode <string> >(node.Right);
var nodeRight = (ConstantNode <string>)node.Right;
Assert.Equal("'lfreds Futterkiste'", nodeRight.LiteralText);
Assert.Equal("lfreds Futterkiste", nodeRight.Value);
}
public void ParseContainsFunctionEqTrueExpression()
{
var queryNode = FilterExpressionParser.Parse("contains(CompanyName,'Alfreds') eq true", EntityDataModel.Current.EntitySets["Customers"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("contains", nodeLeft.Name);
Assert.Equal(2, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
Assert.Equal("CompanyName", ((PropertyAccessNode)nodeLeft.Parameters[0]).Property.Name);
Assert.IsType <ConstantNode>(nodeLeft.Parameters[1]);
Assert.Equal("'Alfreds'", ((ConstantNode)nodeLeft.Parameters[1]).LiteralText);
Assert.IsType <string>(((ConstantNode)nodeLeft.Parameters[1]).Value);
Assert.Equal("Alfreds", ((ConstantNode)nodeLeft.Parameters[1]).Value);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode>(node.Right);
Assert.Equal("true", ((ConstantNode)node.Right).LiteralText);
Assert.IsType <bool>(((ConstantNode)node.Right).Value);
Assert.True((bool)((ConstantNode)node.Right).Value);
}
public void ParseTotalOffsetMinutesFunctionExpression()
{
QueryNode queryNode = FilterExpressionParser.Parse("totaloffsetminutes(Date) eq 321541354", EntityDataModel.Current.EntitySets["Orders"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("totaloffsetminutes", nodeLeft.Name);
Assert.Equal(1, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
var nodeLeftParam0 = (PropertyAccessNode)nodeLeft.Parameters[0];
Assert.Equal("Date", nodeLeftParam0.PropertyPath.Property.Name);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode <int> >(node.Right);
var nodeRight = (ConstantNode <int>)node.Right;
Assert.Equal("321541354", nodeRight.LiteralText);
Assert.Equal(321541354, nodeRight.Value);
}
public void ParseTimeFunctionExpression()
{
QueryNode queryNode = FilterExpressionParser.Parse("time(Date) eq 12:00:00", EntityDataModel.Current.EntitySets["Orders"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("time", nodeLeft.Name);
Assert.Equal(1, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
var nodeLeftParam0 = (PropertyAccessNode)nodeLeft.Parameters[0];
Assert.Equal("Date", nodeLeftParam0.PropertyPath.Property.Name);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode <TimeSpan> >(node.Right);
var nodeRight = (ConstantNode <TimeSpan>)node.Right;
Assert.Equal("12:00:00", nodeRight.LiteralText);
Assert.Equal(new TimeSpan(12, 0, 0), nodeRight.Value);
}
public void ParseCastFunctionWithExpressionAndTypeExpression()
{
var queryNode = FilterExpressionParser.Parse("cast(Rating, 'Edm.Int64') eq 20", EntityDataModel.Current.EntitySets["Products"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("cast", nodeLeft.Name);
Assert.Equal(2, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
Assert.Equal("Rating", ((PropertyAccessNode)nodeLeft.Parameters[0]).Property.Name);
Assert.IsType <ConstantNode>(nodeLeft.Parameters[1]);
Assert.Equal("'Edm.Int64'", ((ConstantNode)nodeLeft.Parameters[1]).LiteralText);
Assert.IsType <string>(((ConstantNode)nodeLeft.Parameters[1]).Value);
Assert.Equal("Edm.Int64", ((ConstantNode)nodeLeft.Parameters[1]).Value);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode>(node.Right);
Assert.Equal("20", ((ConstantNode)node.Right).LiteralText);
Assert.IsType <int>(((ConstantNode)node.Right).Value);
Assert.Equal(20, ((ConstantNode)node.Right).Value);
}
public void ParseSubstringFunctionExpressionWithOneArgumentWhichIsAlsoAFunction()
{
QueryNode queryNode = FilterExpressionParser.Parse("substring(tolower(CompanyName), 'alfreds futterkiste')", EntityDataModel.Current.EntitySets["Customers"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <FunctionCallNode>(queryNode);
var node = (FunctionCallNode)queryNode;
Assert.Equal("substring", node.Name);
Assert.Equal(2, node.Parameters.Count);
Assert.IsType <FunctionCallNode>(node.Parameters[0]);
var nodeParam0 = (FunctionCallNode)node.Parameters[0];
Assert.Equal("tolower", nodeParam0.Name);
Assert.Equal(1, nodeParam0.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeParam0.Parameters[0]);
var nodeParam0Param0 = (PropertyAccessNode)nodeParam0.Parameters[0];
Assert.Equal("CompanyName", nodeParam0Param0.PropertyPath.Property.Name);
Assert.IsType <ConstantNode <string> >(node.Parameters[1]);
var nodeParam1 = (ConstantNode <string>)node.Parameters[1];
Assert.Equal("'alfreds futterkiste'", nodeParam1.LiteralText);
Assert.Equal("alfreds futterkiste", nodeParam1.Value);
}
public void ParseSecondFunctionExpression()
{
QueryNode queryNode = FilterExpressionParser.Parse("second(BirthDate) eq 40", EntityDataModel.Current.EntitySets["Employees"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("second", nodeLeft.Name);
Assert.Equal(1, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
var nodeLeftParam0 = (PropertyAccessNode)nodeLeft.Parameters[0];
Assert.Equal("BirthDate", nodeLeftParam0.PropertyPath.Property.Name);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode <int> >(node.Right);
var nodeRight = (ConstantNode <int>)node.Right;
Assert.Equal("40", nodeRight.LiteralText);
Assert.Equal(40, nodeRight.Value);
}
public void ParseStartswithFunctionEqTrueExpression()
{
QueryNode queryNode = FilterExpressionParser.Parse("startswith(CompanyName, 'Alfr') eq true", EntityDataModel.Current.EntitySets["Customers"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("startswith", nodeLeft.Name);
Assert.Equal(2, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
var nodeLeftParam0 = (PropertyAccessNode)nodeLeft.Parameters[0];
Assert.Equal("CompanyName", nodeLeftParam0.PropertyPath.Property.Name);
Assert.IsType <ConstantNode <string> >(nodeLeft.Parameters[1]);
var nodeLeftParam1 = (ConstantNode <string>)nodeLeft.Parameters[1];
Assert.Equal("'Alfr'", nodeLeftParam1.LiteralText);
Assert.Equal("Alfr", nodeLeftParam1.Value);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode <bool> >(node.Right);
Assert.Same(ConstantNode.True, node.Right);
}
public void ParseLengthFunctionExpression()
{
QueryNode queryNode = FilterExpressionParser.Parse("length(CompanyName) eq 19", EntityDataModel.Current.EntitySets["Customers"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("length", nodeLeft.Name);
Assert.Equal(1, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
var nodeLeftParam0 = (PropertyAccessNode)nodeLeft.Parameters[0];
Assert.Equal("CompanyName", nodeLeftParam0.PropertyPath.Property.Name);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode <int> >(node.Right);
var nodeRight = (ConstantNode <int>)node.Right;
Assert.Equal("19", nodeRight.LiteralText);
Assert.Equal(19, nodeRight.Value);
}
public void ParseNotEndsWithFunctionExpression()
{
QueryNode queryNode = FilterExpressionParser.Parse("not endswith(Description, 'ilk')", EntityDataModel.Current.EntitySets["Products"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <UnaryOperatorNode>(queryNode);
var node = (UnaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Operand);
var nodeOperand = (FunctionCallNode)node.Operand;
Assert.Equal("endswith", nodeOperand.Name);
Assert.Equal(2, nodeOperand.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeOperand.Parameters[0]);
var nodeOperandParam0 = (PropertyAccessNode)nodeOperand.Parameters[0];
Assert.Equal("Description", nodeOperandParam0.PropertyPath.Property.Name);
Assert.IsType <ConstantNode <string> >(nodeOperand.Parameters[1]);
var nodeOperandParam1 = (ConstantNode <string>)nodeOperand.Parameters[1];
Assert.Equal("'ilk'", nodeOperandParam1.LiteralText);
Assert.Equal("ilk", nodeOperandParam1.Value);
Assert.Equal(UnaryOperatorKind.Not, node.OperatorKind);
}
public void ParseFractionalSecondsFunctionExpression()
{
QueryNode queryNode = FilterExpressionParser.Parse("fractionalseconds(BirthDate) lt 0.1m", EntityDataModel.Current.EntitySets["Employees"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("fractionalseconds", nodeLeft.Name);
Assert.Equal(1, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
var nodeLeftParam0 = (PropertyAccessNode)nodeLeft.Parameters[0];
Assert.Equal("BirthDate", nodeLeftParam0.PropertyPath.Property.Name);
Assert.Equal(BinaryOperatorKind.LessThan, node.OperatorKind);
Assert.IsType <ConstantNode <decimal> >(node.Right);
var nodeRight = (ConstantNode <decimal>)node.Right;
Assert.Equal("0.1m", nodeRight.LiteralText);
Assert.Equal(0.1m, nodeRight.Value);
}
public void ParseCastFunctionWithExpressionAndTypeExpression()
{
QueryNode queryNode = FilterExpressionParser.Parse("cast(Rating, Edm.Int64) eq 20", EntityDataModel.Current.EntitySets["Products"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("cast", nodeLeft.Name);
Assert.Equal(2, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
var nodeLeftParam0 = (PropertyAccessNode)nodeLeft.Parameters[0];
Assert.Equal("Rating", nodeLeftParam0.PropertyPath.Property.Name);
Assert.IsType <ConstantNode <EdmType> >(nodeLeft.Parameters[1]);
var constantNode = (ConstantNode <EdmType>)nodeLeft.Parameters[1];
Assert.Equal("Edm.Int64", constantNode.LiteralText);
Assert.Same(EdmPrimitiveType.Int64, constantNode.Value);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode <int> >(node.Right);
var nodeRight = (ConstantNode <int>)node.Right;
Assert.Equal("20", nodeRight.LiteralText);
Assert.Equal(20, nodeRight.Value);
}
public void ParseToUpperFunctionExpression()
{
QueryNode queryNode = FilterExpressionParser.Parse("toupper(CompanyName) eq 'ALFREDS FUTTERKISTE'", EntityDataModel.Current.EntitySets["Customers"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("toupper", nodeLeft.Name);
Assert.Equal(1, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
var nodeLeftParam0 = (PropertyAccessNode)nodeLeft.Parameters[0];
Assert.Equal("CompanyName", nodeLeftParam0.PropertyPath.Property.Name);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode <string> >(node.Right);
var nodeRight = (ConstantNode <string>)node.Right;
Assert.Equal("'ALFREDS FUTTERKISTE'", nodeRight.LiteralText);
Assert.Equal("ALFREDS FUTTERKISTE", nodeRight.Value);
}
public void ParseTotalSecondsFunctionExpression()
{
QueryNode queryNode = FilterExpressionParser.Parse("totalseconds(ReleaseDate) eq 23487645.224", EntityDataModel.Current.EntitySets["Products"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("totalseconds", nodeLeft.Name);
Assert.Equal(1, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
var nodeLeftParam0 = (PropertyAccessNode)nodeLeft.Parameters[0];
Assert.Equal("ReleaseDate", nodeLeftParam0.PropertyPath.Property.Name);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode <decimal> >(node.Right);
var nodeRight = (ConstantNode <decimal>)node.Right;
Assert.Equal("23487645.224", nodeRight.LiteralText);
Assert.Equal(23487645.224M, nodeRight.Value);
}
public void ParseToLowerFunctionPropertyPathExpression()
{
QueryNode queryNode = FilterExpressionParser.Parse("tolower(Category/Name) eq 'dairy'", EntityDataModel.Current.EntitySets["Products"].EdmType);
Assert.NotNull(queryNode);
Assert.IsType <BinaryOperatorNode>(queryNode);
var node = (BinaryOperatorNode)queryNode;
Assert.IsType <FunctionCallNode>(node.Left);
var nodeLeft = (FunctionCallNode)node.Left;
Assert.Equal("tolower", nodeLeft.Name);
Assert.Equal(1, nodeLeft.Parameters.Count);
Assert.IsType <PropertyAccessNode>(nodeLeft.Parameters[0]);
var nodeLeftParam0 = (PropertyAccessNode)nodeLeft.Parameters[0];
Assert.Equal("Category", nodeLeftParam0.PropertyPath.Property.Name);
Assert.Equal("Name", nodeLeftParam0.PropertyPath.Next.Property.Name);
Assert.Equal(BinaryOperatorKind.Equal, node.OperatorKind);
Assert.IsType <ConstantNode <string> >(node.Right);
var nodeRight = (ConstantNode <string>)node.Right;
Assert.Equal("'dairy'", nodeRight.LiteralText);
Assert.Equal("dairy", nodeRight.Value);
}
public static ITypeSearch <TSource> OrFilter <TSource, TListItem>(this ITypeSearch <TSource> search, Expression <Func <TSource, IEnumerable <TListItem> > > nestedExpression,
Expression <Func <TListItem, Filter> > filterExpression)
{
var filter = new FilterExpressionParser(search.Client.Conventions)
.GetFilter(new NestedFilterExpression <TSource, TListItem>(nestedExpression, filterExpression, search.Client.Conventions).Expression);
return(search.OrFilter(filter));
}
public void ParsePropertyEqValueOrMissingExpression()
{
var exception = Assert.Throws <ODataException>(
() => FilterExpressionParser.Parse("Deleted eq true or", EntityDataModel.Current.EntitySets["Products"].EdmType));;
Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode);
Assert.Equal(Messages.UnableToParseFilter, exception.Message);
}
public void ParseFunctionMissingParenthesisEqExpression()
{
var exception = Assert.Throws <ODataException>(
() => FilterExpressionParser.Parse("ceiling(Freight eq 32", EntityDataModel.Current.EntitySets["Orders"].EdmType));;
Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode);
Assert.Equal(Messages.UnableToParseFilter, exception.Message);
}
public static ExpressionSyntax ParseExpression(string text)
{
var buffer = TextBuffer.FromString(text);
var lexer = new FilterExpressionLexer(buffer);
var parser = new FilterExpressionParser(lexer);
return(parser.ParseExpression());
}
public void ParseFunctionMissingSecondParameterExpression()
{
ODataException odataException = Assert.Throws <ODataException>(
() => FilterExpressionParser.Parse("cast(Colour,) eq 20", EntityDataModel.Current.EntitySets["Products"].EdmType));;
Assert.Equal(ExceptionMessage.UnableToParseFilter("the function cast has a missing parameter or extra comma at position 12"), odataException.Message);
Assert.Equal(HttpStatusCode.BadRequest, odataException.StatusCode);
Assert.Equal("$filter", odataException.Target);
}
public void ParseInvalidPropertyEqualsSyntax()
{
ODataException odataException = Assert.Throws <ODataException>(
() => FilterExpressionParser.Parse("Name eq %", EntityDataModel.Current.EntitySets["Products"].EdmType));;
Assert.Equal(ExceptionMessage.GenericUnableToParseFilter, odataException.Message);
Assert.Equal(HttpStatusCode.BadRequest, odataException.StatusCode);
Assert.Equal("$filter", odataException.Target);
}
public void ParseFunctionMissingParenthesisEqExpression()
{
ODataException odataException = Assert.Throws <ODataException>(
() => FilterExpressionParser.Parse("ceiling(Freight eq 32", EntityDataModel.Current.EntitySets["Orders"].EdmType));;
Assert.Equal(ExceptionMessage.UnableToParseFilter("an extra opening or missing closing parenthesis may be present"), odataException.Message);
Assert.Equal(HttpStatusCode.BadRequest, odataException.StatusCode);
Assert.Equal("$filter", odataException.Target);
}
public void ParseFunctionMissingParameterExpression()
{
ODataException odataException = Assert.Throws <ODataException>(
() => FilterExpressionParser.Parse("ceiling() eq 32", EntityDataModel.Current.EntitySets["Orders"].EdmType));;
Assert.Equal(ExceptionMessage.UnableToParseFilter("the function ceiling has no parameters specified at position 8"), odataException.Message);
Assert.Equal(HttpStatusCode.BadRequest, odataException.StatusCode);
Assert.Equal("$filter", odataException.Target);
}
public void ParseFunctionInvalidSyntax()
{
ODataException odataException = Assert.Throws <ODataException>(
() => FilterExpressionParser.Parse("cast(Colour, not", EntityDataModel.Current.EntitySets["Products"].EdmType));;
Assert.Equal(ExceptionMessage.UnableToParseFilter("unexpected not at position 14"), odataException.Message);
Assert.Equal(HttpStatusCode.BadRequest, odataException.StatusCode);
Assert.Equal("$filter", odataException.Target);
}
public void ParseFunctionExtraEndParenthesisEqExpression()
{
ODataException odataException = Assert.Throws <ODataException>(
() => FilterExpressionParser.Parse("ceiling(Freight) eq 32)", EntityDataModel.Current.EntitySets["Orders"].EdmType));;
Assert.Equal(ExceptionMessage.UnableToParseFilter("the closing parenthesis not expected at position 23"), odataException.Message);
Assert.Equal(HttpStatusCode.BadRequest, odataException.StatusCode);
Assert.Equal("$filter", odataException.Target);
}
public void ParseFunctionEqMissingExpression()
{
ODataException odataException = Assert.Throws <ODataException>(
() => FilterExpressionParser.Parse("ceiling(Freight) eq", EntityDataModel.Current.EntitySets["Orders"].EdmType));
Assert.Equal(ExceptionMessage.UnableToParseFilter("the binary operator Equal has no right node"), odataException.Message);
Assert.Equal(HttpStatusCode.BadRequest, odataException.StatusCode);
Assert.Equal("$filter", odataException.Target);
}
