示例#1
0
        /// <summary>
        /// Implement the Count-Distinct aggregation method
        /// </summary>
        /// <param name="elementType">The type of entities</param>
        /// <param name="query">The collection</param>
        /// <param name="transformation">The transformation clause created by the parser</param>
        /// <param name="propertyToAggregateExpression">Projection Expression that defines access to the property to aggregate</param>
        /// <param name="parameters">A list of string parameters sent to the aggregation method</param>
        /// <returns>The Sum result</returns>
        public override object DoAggregatinon(Type elementType, IQueryable collection, ApplyAggregateClause transformation, LambdaExpression propertyToAggregateExpression, params string[] parameters)
        {
            var propertyType   = GetAggregatedPropertyType(elementType, transformation.AggregatableProperty);
            var selectedValues = GetSelectedValues(elementType, collection, transformation, propertyToAggregateExpression);

            //call: (selected.AsQueryable() as IQueryable<double>).Ditinct();
            var distinct = ExpressionHelpers.Distinct(propertyType, selectedValues);

            try
            {
                //call: (distinct.AsQueryable() as IQueryable<double>).Count();
                return(ExpressionHelpers.Count(propertyType, distinct));
            }
            catch (TargetInvocationException)
            {
                //salve a problem in mongo that throw the error "No further operators may follow Distinct in a LINQ query." when trying to construct the expression tree.
                distinct = ExpressionHelpers.Cast(propertyType, distinct.AllElements().AsQueryable());
                return(ExpressionHelpers.Count(propertyType, distinct));
            }
        }
示例#2
0
        /// <summary>
        /// Execute group-by without aggregation on the results.
        /// </summary>
        /// <param name="query">The collection to group.</param>
        /// <param name="maxResults">The max number of elements in a result set.</param>
        /// <param name="transformation">The group-by transformation as <see cref="ApplyGroupbyClause"/>.</param>
        /// <param name="keyType">The key type to group by.</param>
        /// <param name="propertiesToGroupByExpressions">Lambda expression that represents access to the properties to group by.</param>
        /// <returns>The results of the group by transformation as <see cref="IQueryable"/>.</returns>
        public IQueryable DoGroupBy(IQueryable query, int maxResults, ApplyGroupbyClause transformation, Type keyType, IEnumerable <LambdaExpression> propertiesToGroupByExpressions)
        {
            var propToGroupBy = (propertiesToGroupByExpressions != null)
                ? propertiesToGroupByExpressions.ToArray()
                : null;
            var    keySelector = this.GetGroupByProjectionLambda(transformation.SelectedStatements.ToArray(), keyType, propToGroupBy);
            object comparer    = keyType.GetProperty("ComparerInstance").GetValue(null);
            var    results     = ExpressionHelpers.GroupBy(query, keySelector, this.Context.ElementClrType, keyType, comparer);

            var keys = this.GetGroupingKeys(results, keyType, this.Context.ElementClrType);

            // if group by is not supported in this IQueriable provider convert the grouping into memory implementation
            object convertedResult = null;
            int    numberOfTempResults;

            if (QueriableProviderAdapter.ConvertionIsRequiredAsExpressionIfNotSupported(keys, maxResults, out convertedResult, out numberOfTempResults))
            {
                keys = convertedResult as IQueryable;
            }

            var keysToReturn = ExpressionHelpers.Distinct(keyType, keys);

            return(keysToReturn);
        }