public void Count_Returns_CorrectCountFunc() { // Arrange & Act Func <long> countFunc = ExpressionHelpers.Count(_querable, typeof(ECustomer)); // Assert Assert.Equal(3, countFunc()); }
/// <summary> /// Gets the number of entities that satify the given query if the response should include an inline count, or <c>null</c> otherwise. /// </summary> /// <param name="query">The query to compute the count for.</param> /// <returns>The number of entities that satisfy the specified query if the response should include an inline count, or <c>null</c> otherwise.</returns> public long?GetEntityCount(IQueryable query) { if (Value == InlineCountValue.AllPages) { return(ExpressionHelpers.Count(query, Context.ElementClrType)); } else { return(null); } }
/// <summary> /// Gets the Func of entities number that satisfy the given query if the response should include a count query option, or <c>null</c> otherwise. /// </summary> /// <param name="query">The query to compute the count for.</param> /// <returns>The the Func of entities number that satisfy the specified query if the response should include a count query option, or <c>null</c> otherwise.</returns> internal Func <long> GetEntityCountFunc(IQueryable query) { if (Context.ElementClrType == null) { throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "GetEntityCount"); } if (Value) { return(ExpressionHelpers.Count(query, Context.ElementClrType)); } else { return(null); } }
/// <summary> /// Gets the number of entities that satify the given query if the response should include an inline count, or <c>null</c> otherwise. /// </summary> /// <param name="query">The query to compute the count for.</param> /// <returns>The number of entities that satisfy the specified query if the response should include an inline count, or <c>null</c> otherwise.</returns> public long?GetEntityCount(IQueryable query) { if (Context.ElementClrType == null) { throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "GetEntityCount"); } if (Value == InlineCountValue.AllPages) { return(ExpressionHelpers.Count(query, Context.ElementClrType)); } else { return(null); } }
/// <summary> /// /// </summary> /// <typeparam name="TElement"></typeparam> /// <param name="context"></param> /// <param name="query"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task <QueryResult> ExecuteQueryAsync <TElement>(QueryContext context, IQueryable <TElement> query, CancellationToken cancellationToken) { var countOption = context.GetApiService <RestierQueryExecutorOptions>(); if (countOption.IncludeTotalCount) { var countQuery = ExpressionHelpers.GetCountableQuery(query); var expression = ExpressionHelpers.Count(countQuery.Expression, countQuery.ElementType); var result = await ExecuteExpressionAsync <long>(context, countQuery.Provider, expression, cancellationToken).ConfigureAwait(false); var totalCount = result.Results.Cast <long>().Single(); countOption.SetTotalCount(totalCount); } return(await Inner.ExecuteQueryAsync(context, query, cancellationToken).ConfigureAwait(false)); }
/// <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)); } }
/// <summary> /// Asynchronously executes the query flow. /// </summary> /// <param name="context"> /// The query context. /// </param> /// <param name="cancellationToken"> /// A cancellation token. /// </param> /// <returns> /// A task that represents the asynchronous /// operation whose result is a query result. /// </returns> public static async Task <QueryResult> QueryAsync( QueryContext context, CancellationToken cancellationToken) { Ensure.NotNull(context, "context"); // process query expression var expression = context.Request.Expression; var visitor = new QueryExpressionVisitor(context); expression = visitor.Visit(expression); // get element type Type elementType = null; var queryType = expression.Type.FindGenericType(typeof(IQueryable <>)); if (queryType != null) { elementType = queryType.GetGenericArguments()[0]; } // append count expression if requested if (elementType != null && context.Request.ShouldReturnCount) { expression = ExpressionHelpers.Count(expression, elementType); elementType = null; // now return type is single int } // execute query QueryResult result; var executor = context.GetApiService <IQueryExecutor>(); if (executor == null) { throw new NotSupportedException(Resources.QueryExecutorMissing); } if (elementType != null) { var query = visitor.BaseQuery.Provider.CreateQuery(expression); var method = typeof(IQueryExecutor) .GetMethod("ExecuteQueryAsync") .MakeGenericMethod(elementType); var parameters = new object[] { context, query, cancellationToken }; var task = method.Invoke(executor, parameters) as Task <QueryResult>; result = await task; await CheckSubExpressionResult( context, cancellationToken, result.Results, visitor, executor, expression); } else { var method = typeof(IQueryExecutor) .GetMethod("ExecuteExpressionAsync") .MakeGenericMethod(expression.Type); var parameters = new object[] { context, visitor.BaseQuery.Provider, expression, cancellationToken }; var task = method.Invoke(executor, parameters) as Task <QueryResult>; result = await task; } if (result != null) { result.ResultsSource = visitor.EntitySet; } return(result); }