private void TranslateOrderBy(OrderByExpression node) { Translate(node.Source); BsonDocument sort = new BsonDocument(); foreach (var clause in node.Clauses) { var field = FieldExpressionFlattener.FlattenFields(clause.Expression) as IFieldExpression; if (field == null) { throw new NotSupportedException("Only fields are allowed in a $sort."); } var direction = clause.Direction == SortDirection.Ascending ? 1 : -1; if (sort.Contains(field.FieldName)) { var message = string.Format("Redundant ordering fields are not supported: {0}.", field.FieldName); throw new NotSupportedException(message); } sort.Add(field.FieldName, direction); } _stages.Add(new BsonDocument("$sort", sort)); }
/// <summary> /// Returns an entities response based on custom filtering function applied to the query, as well as /// optional select and expand arguments, checking the user permissions along the way /// </summary> /// <param name="filterFunc">Allows you to apply any filteration you like to the query,</param> /// <param name="expand">Optional expand argument</param> /// <param name="select">Optional select argument</param> protected async Task <EntitiesResponse <TEntity> > GetByCustomQuery(Func <Query <TEntity>, Query <TEntity> > filterFunc, ExpandExpression expand, SelectExpression select, OrderByExpression orderby = null) { // Prepare a query of the result, and clone it var repo = GetRepository(); var query = repo.Query <TEntity>(); // Apply custom filter function query = filterFunc(query); // Expand the result as specified in the OData agruments and load into memory var expandedQuery = query.Expand(expand); expandedQuery = expandedQuery.Select(select); expandedQuery = expandedQuery.OrderBy(orderby ?? OrderByExpression.Parse("Id")); // Required var result = await expandedQuery.ToListAsync(); // this is potentially unordered, should that be a concern? // Apply the permissions on the result var permissions = await UserPermissions(Constants.Read); var defaultMask = GetDefaultMask(); await ApplyReadPermissionsMask(result, query, permissions, defaultMask); // Flatten and Trim var relatedEntities = FlattenAndTrim(result, expand); // Prepare the result in a response object return(new EntitiesResponse <TEntity> { Result = result, RelatedEntities = relatedEntities, CollectionName = GetCollectionName(typeof(TEntity)) }); }
/// <summary> /// Visits the order by. /// </summary> /// <param name="orderByExpression">The order by expression.</param> /// <returns> /// Expression /// </returns> public virtual Expression VisitOrderBy(OrderByExpression orderByExpression) { SqlBuilder.Append(" "); SqlBuilder.Append(CreateOrderByString(orderByExpression)); return(orderByExpression); }
/// <summary> /// The SetOrderBy. /// </summary> /// <param name="outputQuery"> The outputQuery <see cref="IQueryable{ClassType}"/>.</param> /// <param name="specification">The specification <see cref="ISpecification{ClassType}"/>.</param> /// <returns>The <see cref="IQueryable{ClassType}"/>.</returns> private static IQueryable <TEntity> SetOrderBy(IQueryable <TEntity> outputQuery, ISpecification <TEntity> specification) { if (specification.OrderByExpressions == null || !specification.OrderByExpressions.Any()) { return(outputQuery); } OrderByExpression <TEntity> firstOrderByExpression = specification.OrderByExpressions.First(); IOrderedQueryable <TEntity> orderedQuery = firstOrderByExpression.OrderByDirection.Equals(OrderByDirection.Ascending) ? outputQuery.OrderBy(firstOrderByExpression.Expression) : outputQuery.OrderByDescending(firstOrderByExpression.Expression); foreach (OrderByExpression <TEntity> orderByExpression in specification.OrderByExpressions) { if (orderByExpression.Equals(firstOrderByExpression)) { continue; } orderedQuery = orderByExpression.OrderByDirection.Equals(OrderByDirection.Ascending) ? orderedQuery.ThenBy(orderByExpression.Expression) : orderedQuery.ThenByDescending(orderByExpression.Expression); } return(orderedQuery); }
public ActionResult Groups_Select(GridCommand command) { var groupManager = new GroupManager(); try { var groups = new List <GroupGridRowModel>(); int count = groupManager.Groups.Count(); if (command != null)// filter subjects based on grid filter settings { FilterExpression filter = TelerikGridHelper.Convert(command.FilterDescriptors.ToList()); OrderByExpression orderBy = TelerikGridHelper.Convert(command.SortDescriptors.ToList()); groups = groupManager.GetGroups(filter, orderBy, command.Page, command.PageSize, out count).Select(GroupGridRowModel.Convert).ToList(); } else { groups = groupManager.Groups.Select(GroupGridRowModel.Convert).ToList(); count = groupManager.Groups.Count(); } return(View(new GridModel <GroupGridRowModel> { Data = groups, Total = count })); } finally { groupManager.Dispose(); } }
private void VisitOrderBy(OrderByExpression node) { Visit(node.Source); BsonDocument sort = new BsonDocument(); foreach (var clause in node.Clauses) { var serializationExpression = (SerializationExpression)clause.Expression; var info = serializationExpression.SerializationInfo; var name = info.ElementName; var direction = clause.Direction == SortDirection.Ascending ? 1 : -1; if (!sort.Contains(name)) { sort.Add(name, direction); } else if (sort[name] != direction) { sort.Remove(name); sort.Add(name, direction); } } _stages.Add(new BsonDocument("$sort", sort)); }
/// <summary> /// Format Order By expressions within the top ordering context /// </summary> /// <param name="node">order by expression</param> /// <returns>the same expression</returns> protected override Expression VisitOrderBy(OrderByExpression node) { if (node.OrderColumn is MeasureExpression) { this.Builder.Append(node.OrderColumn.Name); } else { this.Builder.Append(node.OrderColumn.DbName); } this.Builder.Append(","); switch (node.OrderType) { case OrderType.Asc: this.Builder.Append("1"); break; case OrderType.Desc: this.Builder.Append("0"); break; } return(node); }
private string Base(Expression exp) { var cached = (CachedExpression)exp; if (cached.Sql != null) { return(cached.Sql); } cached.Sql = exp switch { UnionExpression e => Union(e), SelectExpression e => Select(e), WhereExpression e => Where(e), MaxExpression e => Max(e), MinExpression e => Min(e), SumExpression e => Sum(e), CountExpression e => Count(e), TakeExpression e => Take(e), SkipExpression e => Skip(e), FirstExpression e => First(e), DistinctExpression e => Distinct(e), OrderByExpression e => OrderBy(e), OrderByDescendingExpression e => OrderByDescending(e), _ => throw new InvalidEnumArgumentException() }; return(cached.Sql); }
private IQueryable <TQuery> AddOrderByToQuery(IQueryable <TQuery> query, OrderByExpression orderBy, string columnName, bool inReverseOrder) { if (orderBy == null) { throw new ArgumentNullException("orderBy"); } var stack = new Stack <OrderByExpression>(); // create the global parameter reference all expressions need to use var itemParam = Expression.Parameter(typeof(TQuery), "x"); for (var item = orderBy; item != null; item = item.Parent) { LambdaExpression lambda = item.KeySelector; // if no expression was specified in the filter, create a convention-based property access expression using the column name if (lambda == null) { lambda = ExpressionBuilder.CreateLambdaToProperty(typeof(TQuery), columnName); } // verify the lambda has exactly one parameter if (lambda.Parameters.Count != 1) { throw new ArgumentException("Expected lambda expression to have exactly one parameter, not " + lambda.Parameters.Count + "."); } // verify the lambda's parameter is the correct type if (lambda.Parameters[0].Type != typeof(TQuery)) { throw new ArgumentException("Expected lambda expression parameter to be of type '" + typeof(TQuery) + "', not '" + lambda.Parameters[0].Type + "'."); } // pull out the body replace all parameter references with our instance, and put back into lambda Expression newBody = ExpressionBuilder.ReplaceParameter(lambda.Body, lambda.Parameters[0], itemParam); lambda = Expression.Lambda(newBody, itemParam); // push this lambda on the stack stack.Push(new OrderByExpression(lambda, item.InDescendingOrder)); } // build the query sort expression: query.OrderBy().ThenBy().ThenByDescending()... bool isFirstColumn = true; foreach (OrderByExpression order in stack) { Type keyType = order.KeySelector.Body.Type; var methodDelegate = s_orderByDelegateByType.GetOrAdd(keyType, (key) => BuildOrderByDelegate(key)); var useDecendingMethod = (order.InDescendingOrder ^ inReverseOrder); query = methodDelegate(query, order.KeySelector, isFirstColumn, useDecendingMethod); isFirstColumn = false; } return(query); }
private static void ParseOrderBy(TranslatorContext context, OrderByExpression orderBy) { if (orderBy != null) { var sortOption = context.DirectorySearcher.Sort; sortOption.Direction = (SortDirection)orderBy.Direction; sortOption.PropertyName = GetName(orderBy.OrderByProperty.Member); } }
public DataTable Retrieve(long datasetId, FilterExpression filter, OrderByExpression orderBy, ProjectionExpression projection, int pageNumber = 0, int pageSize = 0) { // Would be better to additionally have a ToHQL() method. var projectionClause = projection?.ToSQL(); var orderbyClause = orderBy?.ToSQL(); var whereClause = filter?.ToSQL(); return(Retrieve(datasetId, whereClause, orderbyClause, projectionClause, pageNumber, pageSize)); }
public IQueryable<Board> Get() { var orderBy = new OrderByExpression<Board, DateTime>(p => p.CreateDate, OrderMode.DESC); var data = Query.Message.GetAll(Int32.MaxValue, orderBy); if (!WebMasterCookie.IsLogin) { data = data.Where(p => !p.IsDeleted); } return data; }
public override SqlFragment BuildOrderByMember(OrderByExpression obExpr) { var baseFr = base.BuildOrderByMember(obExpr); if (obExpr.ColumnExpression.Type == typeof(string)) { return(new CompositeSqlFragment(baseFr, _dialect.SqlCollateNoCase)); } return(baseFr); }
public ActionResult Subjects_Select(GridCommand command, long entityId, long instanceId) { var subjectManager = new SubjectManager(); var entityPermissionManager = new EntityPermissionManager(); try { var subjectsDb = new List <Subject>(); var count = 0; if (command != null)// filter subjects based on grid filter settings { FilterExpression filter = TelerikGridHelper.Convert(command.FilterDescriptors.ToList()); OrderByExpression orderBy = TelerikGridHelper.Convert(command.SortDescriptors.ToList()); subjectsDb = subjectManager.GetSubjects(filter, orderBy, command.Page, command.PageSize, out count); } else { subjectsDb = subjectManager.Subjects.ToList(); count = subjectsDb.Count(); } var subjects = new List <EntityPermissionGridRowModel>(); //using (PartyManager partyManager = new PartyManager()) //foreach (var subject in subjectsDb) //{ // var rights = entityPermissionManager.GetRights(subject.Id, entityId, instanceId); // var effectiveRights = entityPermissionManager.GetEffectiveRights(subject.Id, entityId, instanceId); // subjects.Add(EntityPermissionGridRowModel.Convert(subject, rights, effectiveRights)); //} var rightsDic = entityPermissionManager.GetRights(subjectsDb, entityId, instanceId); var effectiveRightsDic = entityPermissionManager.GetEffectiveRights(subjectsDb, entityId, instanceId); foreach (var item in rightsDic) { var subject = subjectsDb.Where(s => s.Id.Equals(item.Key)).FirstOrDefault(); var rights = item.Value; var effectiveRights = effectiveRightsDic[item.Key]; subjects.Add(EntityPermissionGridRowModel.Convert(subject, rights, effectiveRights)); } return(View(new GridModel <EntityPermissionGridRowModel> { Data = subjects, Total = count })); } finally { subjectManager.Dispose(); entityPermissionManager.Dispose(); } }
public void SetOrderByExpression() { var tableInfo = new DatabaseMapper(new ConventionModelMapper()).GetTableInfo <Person>(); var selectExpression = new SelectExpression(tableInfo); var expression = new OrderByExpression("FirstName"); selectExpression.SetOrderByExpression(expression); selectExpression.OrderByExpression.Should().Be(expression); }
/// <summary> /// Returns a single entity as per the ID and specifications in the get request /// </summary> protected virtual async Task <EntitiesResponse <TEntity> > GetChildrenOfAsync(GetChildrenArguments <TKey> args) { // Parse the parameters var expand = ExpandExpression.Parse(args.Expand); var select = SelectExpression.Parse(args.Select); var filter = FilterExpression.Parse(args.Filter); var orderby = OrderByExpression.Parse("Node"); var ids = args.I ?? new List <TKey>(); return(await GetByCustomQuery(q => q.FilterByParentIds(ids, args.Roots).Filter(filter), expand, select, orderby)); }
/// <inheritdoc/> public override Expression VisitOrderBy(OrderByExpression orderByExpression) { if (Skip == 0) { _orderByString = string.Empty; return(base.VisitOrderBy(orderByExpression)); } else { _orderByString = CreateOrderByString(orderByExpression); return(orderByExpression); } }
private MaskTree UpdateUserMaskAsPerOrderBy(OrderByExpression orderby, MaskTree userMask) { if (orderby != null) { var orderbyPaths = orderby.Select(e => string.Join("/", e.Path.Union(new string[] { e.Property }))); var orderbyMask = MaskTree.GetMaskTree(orderbyPaths); var orderbyAccess = Normalize(orderbyMask); userMask = userMask.UnionWith(orderbyAccess); } return(userMask); }
private void AppendOrdering(Func <ExpressionBuilder, SparqlExpression> orderExpression, bool descending) { _buildOrderings.Add(prefixes => { var expressionBuilder = new ExpressionBuilder(prefixes); var sparqlExpression = orderExpression.Invoke(expressionBuilder).Expression; var orderBy = new OrderByExpression(sparqlExpression) { Descending = descending }; return(orderBy); }); }
}//method public virtual SqlFragment BuildOrderByMember(OrderByExpression obExpr) { var colPart = BuildLinqExpressionSql(obExpr.ColumnExpression); if (obExpr.Descending) { return(new CompositeSqlFragment(colPart, SqlTerms.Desc)); } else { return(colPart); } }
public override IJqlClause VisitOrderBy(OrderByExpression clause) { var result = base.VisitOrderBy(clause); foreach (var field in clause.Fields) { var fieldName = ExtractFieldName(field.Field); var fieldType = metadataProvider.GetFieldType(fieldName); var direction = field.Order == JqlOrderType.Asc ? JqlOrderingDirection.Asc : JqlOrderingDirection.Desc; ordering.Add(new JqlOrdering(fieldName, fieldType, direction)); } return(result); }
public List <T> FindAll(OrderByExpression orderBy, LimitExpression limit) { List <T> ret = new List <T> (this.recordList); if (null != orderBy) { ret = this.OrderBy(orderBy.orderFieldName, ret, orderBy.orderType); } if (null != limit) { ret = this.Limit(ret, limit.limit); } return(ret); }
public Criteria(string path, IQueryCollection query) { Path = path; Paginate = PaginateExpression.Extract(query); Slice = SliceExpression.Extract(query); FullTextSearch = FullTextSearchExpression <TIn> .Extract(query); Sort = OrderByExpression <TIn> .Extract(query); Filters = FilterCollectionExpression <TIn> .Extract(query); Operators = OperatorCollectionExpression <TIn> .Extract(query); Embeds = EmbedCollectionExpression <TIn> .Extract(query); }
public override void EnterOrderByExpression(MySqlParser.OrderByExpressionContext context) { if (_isOtherListener == 1) { if (context.ChildCount > 1) { Rules.Remove(Rules[Rules.Count - 1]); } OrderByExpression OrderByExpression = new OrderByExpression(context.SourceInterval, context, context.GetText()); Rules.Add(OrderByExpression); } _isOtherListener++; }
internal Expression VisitOrderBy(OrderByExpression node) { string translatedFieldName = null; if (!this.fieldNameTranslator.TryGetValue(node.FieldName, out translatedFieldName)) { throw new NotSupportedException($"{node.FieldName} is not a supported field."); } this.Model.OrderByTerms.Add(new OrderByTerm() { FieldName = translatedFieldName, Direction = node.Direction }); return(node); }
private string Translate() { var sb = new StringBuilder(); string selectString; #if NETSTANDARD2_1 if (QueryType == QueryTypeEnum.AnyAsync || QueryType == QueryTypeEnum.CountAsync) { selectString = "COUNT()"; } #else if (QueryType == QueryTypeEnum.Any || QueryType == QueryTypeEnum.Count) { selectString = "COUNT()"; } #endif else { TranslateSelect(); selectString = string.Join(",", SelectByExpression.ToArray()); } sb.AppendFormat("SELECT {0} FROM {1}", selectString, ObjectTypeName); if (WhereExpression.Any()) { sb.AppendFormat(" WHERE {0}", string.Join(" AND ", WhereExpression.ToArray())); } if (OrderByExpression.Any()) { sb.AppendFormat(" ORDER BY {0}", string.Join(",", OrderByExpression.ToArray())); } if (Take != null) { sb.AppendFormat(" LIMIT {0}", Take.Value.ToString(CultureInfo.InvariantCulture)); } if (Skip != null) { sb.AppendFormat(" SKIP {0}", Skip.Value.ToString(CultureInfo.InvariantCulture)); } return(sb.ToString()); }
protected override OrderByExpression DefaultOrderBy() { // By default: Order currencies by name var tenantInfo = _repo.GetTenantInfo(); string nameProperty = nameof(Currency.Name); if (tenantInfo.SecondaryLanguageId == CultureInfo.CurrentUICulture.Name) { nameProperty = $"{nameof(Currency.Name2)},{nameof(Currency.Name)}"; } else if (tenantInfo.TernaryLanguageId == CultureInfo.CurrentUICulture.Name) { nameProperty = $"{nameof(Currency.Name3)},{nameof(Currency.Name)}"; } return(OrderByExpression.Parse(nameProperty)); }
/// <summary> /// returns subset of users based on the parameters /// and also count of filtered list /// </summary> /// <param name="filter"></param> /// <param name="orderBy"></param> /// <param name="pageNumber"></param> /// <param name="pageSize"></param> /// <param name="count"></param> /// <returns></returns> public List <User> GetUsers(FilterExpression filter, OrderByExpression orderBy, int pageNumber, int pageSize, out int count) { var orderbyClause = orderBy?.ToLINQ(); var whereClause = filter?.ToLINQ(); count = 0; try { using (IUnitOfWork uow = this.GetUnitOfWork()) { if (whereClause != null && orderBy != null) { var l = Users.Where(whereClause); var x = l.OrderBy(orderbyClause); var y = x.Skip((pageNumber - 1) * pageSize); var z = y.Take(pageSize); count = l.Count(); return(z.ToList()); } else if (whereClause != null) { var filtered = Users.Where(whereClause); count = filtered.Count(); return(filtered.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList()); } if (orderBy != null) { count = Users.Count(); return(Users.OrderBy(orderbyClause).Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList()); } count = Users.Count(); return(Users.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList()); } } catch (Exception ex) { throw new Exception(string.Format("Could not retrieve filtered users."), ex); } }
protected override OrderByExpression DefaultOrderBy() { // By default: Order report definitions by name var tenantInfo = _repo.GetTenantInfo(); string orderby = $"{nameof(ReportDefinition.Title)},{nameof(ReportDefinition.Id)}"; if (tenantInfo.SecondaryLanguageId == CultureInfo.CurrentUICulture.Name) { orderby = $"{nameof(ReportDefinition.Title2)},{nameof(ReportDefinition.Title)},{nameof(ReportDefinition.Id)}"; } else if (tenantInfo.TernaryLanguageId == CultureInfo.CurrentUICulture.Name) { orderby = $"{nameof(ReportDefinition.Title3)},{nameof(ReportDefinition.Title)},{nameof(ReportDefinition.Id)}"; } return(OrderByExpression.Parse(orderby)); }
public static IQueryable <T> ApplySorting <T>(this IQueryable <T> query, OrderByExpression orderBy) { if (orderBy == null || orderBy.FieldNames.Length == 0) { return(query); } var condition = new List <string>(); for (int i = 0; i < orderBy.FieldNames.Length; i++) { var field = orderBy.FieldNames[i]; var direction = orderBy.OrderAsc[i] ? "ASC" : "DESC"; condition.Add(field + " " + direction); } return(query.OrderBy(condition.Join(","))); }
public List <T> FindAll(BaseExpression expression) { if (null == expression) { return(this.recordList); } List <T> ret = new List <T> (this.recordList); if (expression is OrderByExpression) { OrderByExpression orderByExpression = expression as OrderByExpression; return(this.OrderBy(orderByExpression.orderFieldName, ret, orderByExpression.orderType)); } else if (expression is LimitExpression) { LimitExpression limitExpression = expression as LimitExpression; return(this.Limit(ret, limitExpression.limit)); } return(ret); }
public IList<Board> GetRecent() { var orderBy = new OrderByExpression<Board, DateTime>(p => p.CreateDate, OrderMode.DESC); return _boardRepository.GetAll(10, p => !p.IsDeleted, orderBy).ToList(); }
public IList<Board> FindAll(int count) { var orderBy = new OrderByExpression<Board, DateTime>(p => p.CreateDate, OrderMode.DESC); return _boardRepository.GetAll(count, orderBy).ToList(); }