private bool CompareComputeExpression(ComputeExpression expression1, ComputeExpression expression2)
{
if (expression1.Alias != expression2.Alias)
{
return(false);
}
return(expression1.TypeReference.IsEqual(expression2.TypeReference) &&
_queryNodeComparer.Compare(expression1.Expression, expression2.Expression));
}
public void BindApplyWithComputeShouldReturnApplyClause()
{
var tokens = _parser.ParseApply("compute(UnitPrice mul 5 as BigPrice)");
var binder = new ApplyBinder(FakeBindMethods.BindSingleComplexProperty, _bindingState);
var actual = binder.BindApply(tokens);
Assert.NotNull(actual);
ComputeTransformationNode compute = Assert.IsType <ComputeTransformationNode>(Assert.Single(actual.Transformations));
Assert.Equal(TransformationNodeKind.Compute, compute.Kind);
Assert.NotNull(compute.Expressions);
ComputeExpression statement = Assert.Single(compute.Expressions);
VerifyIsFakeSingleValueNode(statement.Expression);
Assert.Equal("BigPrice", statement.Alias);
}
public void BindApplyWithComputeAfterGroupByShouldReturnApplyClause()
{
var tokens = _parser.ParseApply("groupby((ID, SSN), aggregate(LifeTime with sum as TotalLife))/compute(TotalLife as TotalLife2)");
BindingState state = new BindingState(_configuration);
MetadataBinder metadataBiner = new MetadataBinder(_bindingState);
ApplyBinder binder = new ApplyBinder(metadataBiner.Bind, _bindingState);
var actual = binder.BindApply(tokens);
Assert.NotNull(actual);
Assert.Equal(2, actual.Transformations.Count());
ComputeTransformationNode compute = Assert.IsType <ComputeTransformationNode>(actual.Transformations.Last());
Assert.Equal(TransformationNodeKind.Compute, compute.Kind);
ComputeExpression statement = Assert.Single(compute.Expressions);
Assert.Equal("TotalLife2", statement.Alias);
}
public void NestedComputeWithValidExpression()
{
// Arrange
SelectToken select = ParseSelectToken("PreviousAddresses($compute=tolower(Street) as lowStreet;$select=lowStreet)");
// Act
SelectExpandClause clause = BinderForPerson.Bind(expandToken: null, selectToken: select);
// Assert
Assert.NotNull(clause);
Assert.NotNull(clause.SelectedItems);
// FavoriteColors
var selectItem = Assert.Single(clause.SelectedItems);
PathSelectItem subPathSelect = Assert.IsType <PathSelectItem>(selectItem);
Assert.NotNull(subPathSelect.ComputeOption);
ComputeExpression computeExpr = Assert.Single(subPathSelect.ComputeOption.ComputedItems);
Assert.Equal("lowStreet", computeExpr.Alias);
var functionCall = Assert.IsType <SingleValueFunctionCallNode>(computeExpr.Expression);
Assert.Equal("tolower", functionCall.Name);
Assert.Empty(functionCall.Functions);
Assert.NotNull(subPathSelect.SelectAndExpand);
selectItem = Assert.Single(subPathSelect.SelectAndExpand.SelectedItems);
// it should be "lowStreet
PathSelectItem pathSelect = Assert.IsType <PathSelectItem>(selectItem);
ODataPathSegment segment = Assert.Single(pathSelect.SelectedPath);
DynamicPathSegment dynamic = Assert.IsType <DynamicPathSegment>(segment);
Assert.Equal("lowStreet", dynamic.Identifier);
}
public void ParseComputeAsQueryOption()
{
// Create model
EdmModel model = new EdmModel();
EdmEntityType elementType = model.AddEntityType("DevHarness", "Entity");
EdmTypeReference typeReference = new EdmStringTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String), false);
elementType.AddProperty(new EdmStructuralProperty(elementType, "Prop1", typeReference));
EdmEntityContainer container = model.AddEntityContainer("Default", "Container");
container.AddEntitySet("Entities", elementType);
// Define queries and new up parser.
Uri root = new Uri("http://host");
Uri url = new Uri("http://host/Entities?$compute=cast(Prop1, 'Edm.String') as Property1AsString, tolower(Prop1) as Property1Lower");
ODataUriParser parser = new ODataUriParser(model, root, url);
// parse and validate
ComputeClause clause = parser.ParseCompute();
List <ComputeExpression> items = clause.ComputedItems.ToList();
items.Count().Should().Be(2);
items[0].Alias.ShouldBeEquivalentTo("Property1AsString");
items[0].Expression.ShouldBeSingleValueFunctionCallQueryNode();
items[0].Expression.TypeReference.ShouldBeEquivalentTo(typeReference);
items[1].Alias.ShouldBeEquivalentTo("Property1Lower");
items[1].Expression.ShouldBeSingleValueFunctionCallQueryNode();
items[1].Expression.TypeReference.FullName().ShouldBeEquivalentTo("Edm.String");
items[1].Expression.TypeReference.IsNullable.ShouldBeEquivalentTo(true); // tolower is built in function that allows nulls.
ComputeExpression copy = new ComputeExpression(items[0].Expression, items[0].Alias, null);
copy.Expression.Should().NotBeNull();
copy.TypeReference.Should().BeNull();
ComputeClause varied = new ComputeClause(null);
}
private Expression CreateComputeExpression(ComputeExpression expression)
{
Expression body = BindAccessor(expression.Expression);
return(WrapConvert(body));
}
