Esempio n. 1
0
        public void BindApplyWitGroupByWithDeepComplexShouldReturnApplyClause()
        {
            IEnumerable <QueryToken> tokens = _parser.ParseApply("groupby((MyAddress/NextHome/City))");

            MetadataBinder metadataBiner = new MetadataBinder(_bindingState);

            ApplyBinder binder = new ApplyBinder(metadataBiner.Bind, _bindingState);
            ApplyClause actual = binder.BindApply(tokens);

            Assert.NotNull(actual);

            var transformation = Assert.Single(actual.Transformations);
            GroupByTransformationNode groupBy = Assert.IsType <GroupByTransformationNode>(transformation);

            Assert.Equal(TransformationNodeKind.GroupBy, groupBy.Kind);
            Assert.NotNull(groupBy.GroupingProperties);
            Assert.Null(groupBy.ChildTransformations);

            GroupByPropertyNode addressNode = Assert.Single(groupBy.GroupingProperties);

            Assert.Equal("MyAddress", addressNode.Name);
            Assert.Null(addressNode.Expression);

            GroupByPropertyNode nextHomeNode = Assert.Single(addressNode.ChildTransformations);

            Assert.Equal("NextHome", nextHomeNode.Name);
            Assert.Null(nextHomeNode.Expression);

            GroupByPropertyNode cityNode = Assert.Single(nextHomeNode.ChildTransformations);

            Assert.Equal("City", cityNode.Name);
            Assert.NotNull(cityNode.Expression);
            Assert.Empty(cityNode.ChildTransformations);
        }
Esempio n. 2
0
        public void BindApplyWitGroupByWithComplexAndNavigationShouldReturnApplyClause()
        {
            IEnumerable <QueryToken> tokens = _parser.ParseApply("groupby((MyAddress/PostBoxPainting/Artist))");

            MetadataBinder metadataBiner = new MetadataBinder(_bindingState);

            ApplyBinder binder = new ApplyBinder(metadataBiner.Bind, _bindingState);
            ApplyClause actual = binder.BindApply(tokens);

            Assert.NotNull(actual);

            var transformation = Assert.Single(actual.Transformations);
            GroupByTransformationNode groupBy = Assert.IsType <GroupByTransformationNode>(transformation);

            Assert.Equal(TransformationNodeKind.GroupBy, groupBy.Kind);
            Assert.Null(groupBy.ChildTransformations);
            Assert.NotNull(groupBy.GroupingProperties);

            GroupByPropertyNode addressNode = Assert.Single(groupBy.GroupingProperties);

            Assert.Equal("MyAddress", addressNode.Name);
            Assert.Null(addressNode.Expression);

            GroupByPropertyNode postBoxPaintingNode = Assert.Single(addressNode.ChildTransformations);

            Assert.Equal("PostBoxPainting", postBoxPaintingNode.Name);
            Assert.Null(postBoxPaintingNode.Expression);

            GroupByPropertyNode artistNode = Assert.Single(postBoxPaintingNode.ChildTransformations);

            Assert.Equal("Artist", artistNode.Name);
            Assert.NotNull(artistNode.Expression);
            Assert.Empty(artistNode.ChildTransformations);
        }
Esempio n. 3
0
        public void BindApplyWitGroupByWithNavigationShouldReturnApplyClause()
        {
            IEnumerable <QueryToken> tokens = _parser.ParseApply("groupby((MyDog/City))");

            ApplyBinder binder = new ApplyBinder(FakeBindMethods.BindMethodReturnsPersonDogColorNavigation, _bindingState);
            ApplyClause actual = binder.BindApply(tokens);

            Assert.NotNull(actual);
            GroupByTransformationNode groupBy = Assert.IsType <GroupByTransformationNode>(Assert.Single(actual.Transformations));

            Assert.Equal(TransformationNodeKind.GroupBy, groupBy.Kind);
            Assert.NotNull(groupBy.GroupingProperties);
            Assert.Null(groupBy.ChildTransformations);

            GroupByPropertyNode dogNode = Assert.Single(groupBy.GroupingProperties);

            Assert.Null(dogNode.Expression);
            Assert.Equal("MyDog", dogNode.Name);
            Assert.NotNull(dogNode.ChildTransformations);

            List <GroupByPropertyNode> groupingProperties = groupBy.GroupingProperties.ToList();

            Assert.Null(groupBy.ChildTransformations);

            GroupByPropertyNode colorNode = Assert.Single(dogNode.ChildTransformations);

            Assert.Equal("Color", colorNode.Name);
            Assert.Same(FakeBindMethods.FakePersonDogColorNode, colorNode.Expression);
            Assert.Empty(colorNode.ChildTransformations);
        }
Esempio n. 4
0
        public void BindApplyWitGroupByWithDeepNavigationShouldReturnApplyClause()
        {
            IEnumerable <QueryToken> tokens = _parser.ParseApply("groupby((MyDog/FastestOwner/FirstName))");

            MetadataBinder metadataBiner = new MetadataBinder(_bindingState);

            ApplyBinder binder = new ApplyBinder(metadataBiner.Bind, _bindingState);
            ApplyClause actual = binder.BindApply(tokens);

            Assert.NotNull(actual);

            TransformationNode        transformation = Assert.Single(actual.Transformations);
            GroupByTransformationNode groupBy        = Assert.IsType <GroupByTransformationNode>(transformation);

            Assert.Equal(TransformationNodeKind.GroupBy, groupBy.Kind);
            Assert.NotNull(groupBy.GroupingProperties);
            Assert.Null(groupBy.ChildTransformations);
            GroupByPropertyNode dogNode = Assert.Single(groupBy.GroupingProperties);

            Assert.Equal("MyDog", dogNode.Name);
            Assert.Null(dogNode.Expression);

            GroupByPropertyNode ownerNode = Assert.Single(dogNode.ChildTransformations);

            Assert.Equal("FastestOwner", ownerNode.Name);
            Assert.Null(ownerNode.Expression);

            GroupByPropertyNode nameNode = Assert.Single(ownerNode.ChildTransformations);

            Assert.Equal("FirstName", nameNode.Name);
            Assert.NotNull(nameNode.Expression);
            Assert.Empty(nameNode.ChildTransformations);
        }
Esempio n. 5
0
        private static void RegisterProperty(IList <GroupByPropertyNode> properties, Stack <SingleValueNode> propertyStack)
        {
            var    property     = propertyStack.Pop();
            string propertyName = GetNodePropertyName(property);

            if (propertyStack.Count != 0)
            {
                // Not at the leaf, let's add to the container.
                var containerProperty = properties.FirstOrDefault(p => p.Name == propertyName);
                if (containerProperty == null)
                {
                    // We do not have container yet. Create it.
                    containerProperty = new GroupByPropertyNode(propertyName, null);
                    properties.Add(containerProperty);
                }

                RegisterProperty(containerProperty.Children, propertyStack);
            }
            else
            {
                // It's the leaf just add.
                var accessNode = property as SingleValuePropertyAccessNode;
                properties.Add(new GroupByPropertyNode(propertyName, property, accessNode.TypeReference));
            }
        }
Esempio n. 6
0
        public void BindApplyWitGroupByWithNavigationShouldReturnApplyClause()
        {
            IEnumerable <QueryToken> tokens = _parser.ParseApply("groupby((MyDog/City))");

            ApplyBinder binder = new ApplyBinder(FakeBindMethods.BindMethodReturnsPersonDogNameNavigation, _bindingState);
            ApplyClause actual = binder.BindApply(tokens);

            actual.Should().NotBeNull();
            actual.Transformations.Should().HaveCount(1);

            List <TransformationNode> transformations = actual.Transformations.ToList();
            GroupByTransformationNode groupBy         = transformations[0] as GroupByTransformationNode;

            groupBy.Should().NotBeNull();
            groupBy.Kind.Should().Be(TransformationNodeKind.GroupBy);
            groupBy.GroupingProperties.Should().NotBeNull();
            groupBy.GroupingProperties.Should().HaveCount(1);

            List <GroupByPropertyNode> groupingProperties = groupBy.GroupingProperties.ToList();
            GroupByPropertyNode        dogNode            = groupingProperties[0];

            dogNode.Expression.Should().BeNull();
            dogNode.Name.Should().Be("MyDog");
            dogNode.ChildTransformations.Should().HaveCount(1);

            GroupByPropertyNode nameNode = dogNode.ChildTransformations[0];

            dogNode.Name.Should().Be("MyDog");

            nameNode.Expression.Should().BeSameAs(FakeBindMethods.FakePersonDogNameNode);

            groupBy.ChildTransformations.Should().BeNull();
        }
Esempio n. 7
0
        public void BindApplyWitGroupByWithComplexShouldReturnApplyClause()
        {
            IEnumerable <QueryToken> tokens = _parser.ParseApply("groupby((MyAddress/City))");

            MetadataBinder metadataBiner = new MetadataBinder(_bindingState);

            ApplyBinder binder = new ApplyBinder(metadataBiner.Bind, _bindingState);
            ApplyClause actual = binder.BindApply(tokens);

            Assert.NotNull(actual);
            actual.Transformations.Should().HaveCount(1);

            List <TransformationNode> transformations = actual.Transformations.ToList();
            GroupByTransformationNode groupBy         = transformations[0] as GroupByTransformationNode;

            groupBy.Should().NotBeNull();
            groupBy.Kind.Should().Be(TransformationNodeKind.GroupBy);
            groupBy.GroupingProperties.Should().NotBeNull();
            groupBy.GroupingProperties.Should().HaveCount(1);
            groupBy.ChildTransformations.Should().BeNull();

            List <GroupByPropertyNode> groupingProperties = groupBy.GroupingProperties.ToList();
            GroupByPropertyNode        addressNode        = groupingProperties[0];

            addressNode.Name.Should().Be("MyAddress");
            addressNode.Expression.Should().BeNull();
            addressNode.ChildTransformations.Should().HaveCount(1);

            GroupByPropertyNode cityNode = addressNode.ChildTransformations[0];

            cityNode.Name.Should().Be("City");
            cityNode.Expression.Should().NotBeNull();
            cityNode.ChildTransformations.Should().BeEmpty();
        }
Esempio n. 8
0
 private void ValidateGroupByPropertyNode(GroupByPropertyNode groupByProperty, ODataUrlValidationContext validationContext)
 {
     ValidateItem(groupByProperty, validationContext);
     validationContext.ExpressionValidator.ValidateNode(groupByProperty.Expression);
     foreach (GroupByPropertyNode childTransformation in groupByProperty.ChildTransformations)
     {
         ValidateGroupByPropertyNode(childTransformation, validationContext);
     }
 }
Esempio n. 9
0
        private MethodCallExpression ApplyGroupBy(Expression source, GroupByTransformationNode transformation)
        {
            Type sourceType = OeExpressionHelper.GetCollectionItemType(source.Type);
            ParameterExpression sourceParameter = Expression.Parameter(sourceType);
            var visitor = CreateVisitor(sourceParameter);

            var expressions = new List <Expression>();

            foreach (GroupByPropertyNode node in transformation.GroupingProperties)
            {
                if (node.ChildTransformations != null && node.ChildTransformations.Count > 0)
                {
                    if (node.ChildTransformations.Count > 1)
                    {
                        throw new NotSupportedException();
                    }

                    GroupByPropertyNode childNode = node.ChildTransformations[0];
                    String propertyName           = node.Name + "_" + childNode.Name;

                    Expression e = visitor.TranslateNode(childNode.Expression);
                    expressions.Add(e);

                    _aggProperties.Add(CreateEdmProperty(_visitor.EdmModel, e.Type, propertyName, true));
                }
                else
                {
                    Expression e = visitor.TranslateNode(node.Expression);
                    expressions.Add(e);

                    _aggProperties.Add(CreateEdmProperty(_visitor.EdmModel, e.Type, node.Name, true));
                }
            }

            NewExpression    newExpression = OeExpressionHelper.CreateTupleExpression(expressions);
            LambdaExpression lambda        = Expression.Lambda(newExpression, sourceParameter);

            MethodInfo           groupByMethodInfo = OeMethodInfoHelper.GetGroupByMethodInfo(sourceType, newExpression.Type);
            MethodCallExpression groupByCall       = Expression.Call(groupByMethodInfo, source, lambda);

            var aggTransformation = (AggregateTransformationNode)transformation.ChildTransformations;

            if (aggTransformation == null)
            {
                expressions.Clear();
                sourceType      = OeExpressionHelper.GetCollectionItemType(groupByCall.Type);
                sourceParameter = Expression.Parameter(sourceType);
                expressions.Add(Expression.Property(sourceParameter, nameof(IGrouping <Object, Object> .Key)));
                newExpression = OeExpressionHelper.CreateTupleExpression(expressions);

                MethodInfo selectMethodInfo = OeMethodInfoHelper.GetSelectMethodInfo(sourceType, newExpression.Type);
                lambda = Expression.Lambda(newExpression, sourceParameter);
                return(Expression.Call(selectMethodInfo, groupByCall, lambda));
            }

            return(ApplyAggregate(groupByCall, aggTransformation));
        }
Esempio n. 10
0
        public void BindApplyWitGroupByWithNavigationAndDeepComplexAndNavigationShouldReturnApplyClause()
        {
            IEnumerable <QueryToken> tokens = _parser.ParseApply("groupby((MyFavoritePainting/ArtistAddress/NextHome/PostBoxPainting/Artist))");

            MetadataBinder metadataBiner = new MetadataBinder(_bindingState);

            ApplyBinder binder = new ApplyBinder(metadataBiner.Bind, _bindingState);
            ApplyClause actual = binder.BindApply(tokens);

            actual.Should().NotBeNull();
            actual.Transformations.Should().HaveCount(1);

            List <TransformationNode> transformations = actual.Transformations.ToList();
            GroupByTransformationNode groupBy         = transformations[0] as GroupByTransformationNode;

            groupBy.Should().NotBeNull();
            groupBy.Kind.Should().Be(TransformationNodeKind.GroupBy);
            groupBy.GroupingProperties.Should().NotBeNull();
            groupBy.GroupingProperties.Should().HaveCount(1);
            groupBy.ChildTransformations.Should().BeNull();

            List <GroupByPropertyNode> groupingProperties   = groupBy.GroupingProperties.ToList();
            GroupByPropertyNode        favoritePaintingNode = groupingProperties[0];

            favoritePaintingNode.Name.Should().Be("MyFavoritePainting");
            favoritePaintingNode.Expression.Should().BeNull();
            favoritePaintingNode.ChildTransformations.Should().HaveCount(1);

            GroupByPropertyNode artistAddressNode = favoritePaintingNode.ChildTransformations[0];

            artistAddressNode.Name.Should().Be("ArtistAddress");
            artistAddressNode.Expression.Should().BeNull();
            artistAddressNode.ChildTransformations.Should().HaveCount(1);

            GroupByPropertyNode nextHomeNode = artistAddressNode.ChildTransformations[0];

            nextHomeNode.Name.Should().Be("NextHome");
            nextHomeNode.Expression.Should().BeNull();
            nextHomeNode.ChildTransformations.Should().HaveCount(1);

            GroupByPropertyNode postBoxPaintingNode = nextHomeNode.ChildTransformations[0];

            postBoxPaintingNode.Name.Should().Be("PostBoxPainting");
            postBoxPaintingNode.Expression.Should().BeNull();
            postBoxPaintingNode.ChildTransformations.Should().HaveCount(1);

            GroupByPropertyNode artistNode = postBoxPaintingNode.ChildTransformations[0];

            artistNode.Name.Should().Be("Artist");
            artistNode.Expression.Should().NotBeNull();
            artistNode.ChildTransformations.Should().BeEmpty();
        }
        private bool CompareGroupByPropertyNode(GroupByPropertyNode node1, GroupByPropertyNode node2)
        {
            if (node1 == node2)
            {
                return(true);
            }
            if (node1 == null || node2 == null)
            {
                return(false);
            }

            return(_queryNodeComparer.Compare(node1.Expression, node2.Expression) &&
                   EnumerableComparer.Compare(node1.ChildTransformations, node2.ChildTransformations, CompareGroupByPropertyNode));
        }
        private void Translate(GroupByPropertyNode node)
        {
            if (node.Expression != null)
            {
                AppendExpression(node.Expression);
            }

            bool appendCommaChild = false;

            foreach (GroupByPropertyNode childNode in node.ChildTransformations)
            {
                appendCommaChild = AppendComma(appendCommaChild);
                Translate(childNode);
            }
        }
Esempio n. 13
0
        public void BindApplyWitGroupByWithDeepNavigationAndComplexShouldReturnApplyClause()
        {
            IEnumerable <QueryToken> tokens = _parser.ParseApply("groupby((MyDog/LionWhoAteMe/LionHeartbeat/Frequency))");

            MetadataBinder metadataBiner = new MetadataBinder(_bindingState);

            ApplyBinder binder = new ApplyBinder(metadataBiner.Bind, _bindingState);
            ApplyClause actual = binder.BindApply(tokens);

            actual.Should().NotBeNull();
            actual.Transformations.Should().HaveCount(1);

            List <TransformationNode> transformations = actual.Transformations.ToList();
            GroupByTransformationNode groupBy         = transformations[0] as GroupByTransformationNode;

            groupBy.Should().NotBeNull();
            groupBy.Kind.Should().Be(TransformationNodeKind.GroupBy);
            groupBy.GroupingProperties.Should().NotBeNull();
            groupBy.GroupingProperties.Should().HaveCount(1);
            groupBy.ChildTransformations.Should().BeNull();

            List <GroupByPropertyNode> groupingProperties = groupBy.GroupingProperties.ToList();
            GroupByPropertyNode        dogNode            = groupingProperties[0];

            dogNode.Name.Should().Be("MyDog");
            dogNode.Expression.Should().BeNull();
            dogNode.ChildTransformations.Should().HaveCount(1);

            GroupByPropertyNode lionNode = dogNode.ChildTransformations[0];

            lionNode.Name.Should().Be("LionWhoAteMe");
            lionNode.Expression.Should().BeNull();
            lionNode.ChildTransformations.Should().HaveCount(1);

            GroupByPropertyNode heartBeatNode = lionNode.ChildTransformations[0];

            heartBeatNode.Name.Should().Be("LionHeartbeat");
            heartBeatNode.Expression.Should().BeNull();
            heartBeatNode.ChildTransformations.Should().HaveCount(1);

            GroupByPropertyNode frequencyNode = heartBeatNode.ChildTransformations[0];

            frequencyNode.Name.Should().Be("Frequency");
            frequencyNode.Expression.Should().NotBeNull();
            frequencyNode.ChildTransformations.Should().BeEmpty();
        }
Esempio n. 14
0
        public void BindApplyWitGroupByWithDeepNavigationShouldReturnApplyClause()
        {
            IEnumerable <QueryToken> tokens = _parser.ParseApply("groupby((MyDog/FastestOwner/FirstName))");

            MetadataBinder metadataBiner = new MetadataBinder(_bindingState);

            ApplyBinder binder = new ApplyBinder(metadataBiner.Bind, _bindingState);
            ApplyClause actual = binder.BindApply(tokens);

            actual.Should().NotBeNull();
            actual.Transformations.Should().HaveCount(1);

            List <TransformationNode> transformations = actual.Transformations.ToList();
            GroupByTransformationNode groupBy         = transformations[0] as GroupByTransformationNode;

            groupBy.Should().NotBeNull();
            groupBy.Kind.Should().Be(TransformationNodeKind.GroupBy);
            groupBy.GroupingProperties.Should().NotBeNull();
            groupBy.GroupingProperties.Should().HaveCount(1);
            groupBy.ChildTransformations.Should().BeNull();

            List <GroupByPropertyNode> groupingProperties = groupBy.GroupingProperties.ToList();
            GroupByPropertyNode        dogNode            = groupingProperties[0];

            dogNode.Name.Should().Be("MyDog");
            dogNode.Expression.Should().BeNull();
            dogNode.ChildTransformations.Should().HaveCount(1);

            GroupByPropertyNode ownerNode = dogNode.ChildTransformations[0];

            ownerNode.Name.Should().Be("FastestOwner");
            ownerNode.Expression.Should().BeNull();
            ownerNode.ChildTransformations.Should().HaveCount(1);

            GroupByPropertyNode nameNode = ownerNode.ChildTransformations[0];

            nameNode.Name.Should().Be("FirstName");
            nameNode.Expression.Should().NotBeNull();
            nameNode.ChildTransformations.Should().BeEmpty();
        }
Esempio n. 15
0
        public void BindApplyWitGroupByWithDeepNavigationAndComplexShouldReturnApplyClause()
        {
            IEnumerable <QueryToken> tokens = _parser.ParseApply("groupby((MyDog/LionWhoAteMe/LionHeartbeat/Frequency))");

            MetadataBinder metadataBiner = new MetadataBinder(_bindingState);

            ApplyBinder binder = new ApplyBinder(metadataBiner.Bind, _bindingState);
            ApplyClause actual = binder.BindApply(tokens);

            Assert.NotNull(actual);

            var transformation = Assert.Single(actual.Transformations);
            GroupByTransformationNode groupBy = Assert.IsType <GroupByTransformationNode>(transformation);

            Assert.Equal(TransformationNodeKind.GroupBy, groupBy.Kind);
            Assert.Null(groupBy.ChildTransformations);
            Assert.NotNull(groupBy.GroupingProperties);

            GroupByPropertyNode dogNode = Assert.Single(groupBy.GroupingProperties);

            Assert.Equal("MyDog", dogNode.Name);
            Assert.Null(dogNode.Expression);

            GroupByPropertyNode lionNode = Assert.Single(dogNode.ChildTransformations);

            Assert.Equal("LionWhoAteMe", lionNode.Name);
            Assert.Null(lionNode.Expression);

            GroupByPropertyNode heartBeatNode = Assert.Single(lionNode.ChildTransformations);

            Assert.Equal("LionHeartbeat", heartBeatNode.Name);
            Assert.Null(heartBeatNode.Expression);

            GroupByPropertyNode frequencyNode = Assert.Single(heartBeatNode.ChildTransformations);

            Assert.Equal("Frequency", frequencyNode.Name);
            Assert.NotNull(frequencyNode.Expression);
            Assert.Empty(frequencyNode.ChildTransformations);
        }