Ejemplo n.º 1
0
        private AggregateExpressionBase BindAggregateExpressionToken(AggregateTokenBase aggregateToken)
        {
            switch (aggregateToken.Kind)
            {
            case QueryTokenKind.AggregateExpression:
            {
                AggregateExpressionToken token         = aggregateToken as AggregateExpressionToken;
                SingleValueNode          expression    = this.bindMethod(token.Expression) as SingleValueNode;
                IEdmTypeReference        typeReference = CreateAggregateExpressionTypeReference(expression, token.MethodDefinition);

                // TODO: Determine source
                return(new AggregateExpression(expression, token.MethodDefinition, token.Alias, typeReference));
            }

            case QueryTokenKind.EntitySetAggregateExpression:
            {
                EntitySetAggregateToken token = aggregateToken as EntitySetAggregateToken;
                QueryNode boundPath           = this.bindMethod(token.EntitySet);

                state.InEntitySetAggregation = true;
                IEnumerable <AggregateExpressionBase> children = token.Expressions.Select(x => BindAggregateExpressionToken(x)).ToList();
                state.InEntitySetAggregation = false;
                return(new EntitySetAggregateExpression((CollectionNavigationNode)boundPath, children));
            }

            default:
                throw new ODataException(ODataErrorStrings.ApplyBinder_UnsupportedAggregateKind(aggregateToken.Kind));
            }
        }
Ejemplo n.º 2
0
        private static IEnumerable <AggregateTokenBase> MergeEntitySetAggregates(IEnumerable <AggregateTokenBase> tokens)
        {
            List <AggregateTokenBase> mergedTokens = new List <AggregateTokenBase>();
            Dictionary <string, AggregateTokenBase> entitySetTokens = new Dictionary <string, AggregateTokenBase>();

            foreach (AggregateTokenBase token in tokens)
            {
                switch (token.Kind)
                {
                case QueryTokenKind.EntitySetAggregateExpression:
                {
                    AggregateTokenBase      currentValue;
                    EntitySetAggregateToken entitySetToken = token as EntitySetAggregateToken;
                    string key = entitySetToken.Path();

                    if (entitySetTokens.TryGetValue(key, out currentValue))
                    {
                        entitySetTokens.Remove(key);
                    }

                    entitySetTokens.Add(key, EntitySetAggregateToken.Merge(entitySetToken, currentValue as EntitySetAggregateToken));
                    break;
                }

                case QueryTokenKind.AggregateExpression:
                {
                    mergedTokens.Add(token);
                    break;
                }
                }
            }

            return(mergedTokens.Concat(entitySetTokens.Values).ToList());
        }