/// <summary> /// 获得排序 /// </summary> /// <returns></returns> public static SortByBuilder GetSort(List <DataFilter.QueryFieldItem> FieldItemLst) { var sort = new SortByBuilder(); List <String> ascendingList = new List <String>(); List <String> descendingList = new List <String>(); //_id将以文字的形式排序,所以不要排序_id!! foreach (var item in FieldItemLst) { switch (item.sortType) { case DataFilter.SortType.NoSort: break; case DataFilter.SortType.Ascending: ascendingList.Add(item.ColName); break; case DataFilter.SortType.Descending: descendingList.Add(item.ColName); break; default: break; } } sort.Ascending(ascendingList.ToArray()); sort.Descending(descendingList.ToArray()); return(sort); }
/// <summary> /// 获得排序 /// </summary> /// <returns></returns> public static SortByBuilder GetSort(List <DataFilter.QueryFieldItem> fieldItemLst) { var sort = new SortByBuilder(); //排序 fieldItemLst.Sort((x, y) => { return(x.SortOrder - y.SortOrder); }); foreach (var item in fieldItemLst) { if (item.SortOrder == 0) { continue; } switch (item.SortType) { case DataFilter.SortType.NoSort: break; case DataFilter.SortType.Ascending: sort.Ascending(item.ColName); break; case DataFilter.SortType.Descending: sort.Descending(item.ColName); break; } } return(sort); }
public static SortByBuilder BuildSortByBuilder(string sortbyExpression) { try { // create sort order builder SortByBuilder builder = new SortByBuilder(); string[] splitSortExpr = sortbyExpression.Split(','); foreach (string s in splitSortExpr) { string[] splitSort = s.Split(':'); if (splitSort[1].Equals("1")) { builder.Ascending(new string[] { splitSort[0].ToString() }); } else { builder.Descending(new string[] { splitSort[0].ToString() }); } } return(builder); } catch (Exception) { throw; } }
/// <summary> /// </summary> /// <returns></returns> public static SortByBuilder GetSort(List <DataFilter.QueryFieldItem> fieldItemLst) { var sort = new SortByBuilder(); var ascendingList = new List <string>(); var descendingList = new List <string>(); foreach (var item in fieldItemLst) { switch (item.SortType) { case DataFilter.SortType.NoSort: break; case DataFilter.SortType.Ascending: ascendingList.Add(item.ColName); break; case DataFilter.SortType.Descending: descendingList.Add(item.ColName); break; } } sort.Ascending(ascendingList.ToArray()); sort.Descending(descendingList.ToArray()); return(sort); }
/// <summary> /// Converts PS objects to a SortBy object. /// </summary> /// <param name="values">Strings or @{Name=Boolean}. Null and empty is allowed.</param> /// <returns>SortBy object, may be empty but not null.</returns> public static IMongoSortBy ObjectsToSortBy(IEnumerable values) { if (values == null) { return(SortBy.Null); } var builder = new SortByBuilder(); foreach (var it in values) { var name = it as string; if (name != null) { builder.Ascending(name); continue; } var hash = it as IDictionary; if (hash == null) { throw new ArgumentException("SortBy: Invalid size object type."); } if (hash.Count != 1) { throw new ArgumentException("SortBy: Expected a dictionary with one entry."); } foreach (DictionaryEntry kv in hash) { name = kv.Key.ToString(); if (LanguagePrimitives.IsTrue(kv.Value)) { builder.Ascending(name); } else { builder.Descending(name); } } } return(builder); }
public MongoSortWarpper Asc(params string[] keys) { if (MongoSortBy == null) { MongoSortBy = SortBy.Ascending(keys); } else { MongoSortBy = MongoSortBy.Ascending(keys); } return(this); }
public IEnumerable <IEnumerable <KeyValuePair <string, object> > > Find(string entityName, QueryObject query, QuerySortObject[] sort, int?skip, int?limit) { var mongoCollection = MongoStaticContext.Context.GetBsonCollection(RECORD_COLLECTION_PREFIX + entityName); var mongoQuery = ConvertQuery(query); var cursor = mongoCollection.Find(mongoQuery); if (sort != null && sort.Length > 0) { SortByBuilder sortBy = null; foreach (var s in sort) { if (s.SortType == QuerySortType.Ascending) { sortBy = sortBy == null?SortBy.Ascending(s.FieldName) : sortBy.Ascending(s.FieldName); } else { sortBy = sortBy == null?SortBy.Descending(s.FieldName) : sortBy.Descending(s.FieldName); } } cursor.SetSortOrder(sortBy); } if (skip.HasValue) { cursor.SetSkip(skip.Value); } if (limit.HasValue) { cursor.SetLimit(limit.Value); } List <List <KeyValuePair <string, object> > > result = new List <List <KeyValuePair <string, object> > >(); foreach (BsonDocument doc in cursor) { List <KeyValuePair <string, object> > record = new List <KeyValuePair <string, object> >(); foreach (var fieldName in doc.Names) { if (fieldName == "_id") { record.Add(new KeyValuePair <string, object>("id", BsonTypeMapper.MapToDotNetValue(doc["_id"]))); } else { record.Add(new KeyValuePair <string, object>(fieldName, ConvertBsonValueToObject(doc[fieldName]))); } } result.Add(record); } return(result); }
private static SortByBuilder AddSorting(SortByBuilder sortBy, string sortDirection, string dbSortField) { //SortByBuilder sortBy; switch (sortDirection) { case "+": { sortBy = sortBy.Ascending(dbSortField); } break; case "-": { sortBy = sortBy.Descending(dbSortField); } break; default: sortBy = sortBy.Ascending(dbSortField); break; } return(sortBy); }
protected virtual IMongoSortBy BuildSortExpression(TFilter filter) { IMongoSortBy sort = SortBy.Null; if (filter.Ordering.Any()) { var builder = new SortByBuilder(); foreach (var order in filter.Ordering) { builder = order.Desc ? builder.Descending(order.Key) : builder.Ascending(order.Key); } sort = builder; } return(sort); }
private static SortByBuilder GetSortOrder(IEnumerable <string> sortBy) { var builder = new SortByBuilder(); foreach (var field in sortBy) { if (field[0] == '-') { builder.Descending(field.Substring(1)); } else { builder.Ascending(field); } } return(builder); }
public static SortByBuilder GetSort(TaskQueue.TQItemSelector selector) { SortByBuilder sb = new SortByBuilder(); foreach (KeyValuePair <string, TaskQueue.TQItemSelectorParam> kv in selector.parameters) { switch (kv.Value.ValueSet) { case TaskQueue.TQItemSelectorSet.Ascending: sb = sb.Ascending(kv.Key); break; case TaskQueue.TQItemSelectorSet.Descending: sb = sb.Descending(kv.Key); break; } } return(sb); }
public List <T> Page <T>(DbQueryParams qParams) where T : class, new() { // First query part consists of search params with specified operator between List <IMongoQuery> queries = new List <IMongoQuery>(); foreach (var item in qParams.QueryParams) { queries.Add(Query.Matches(item.Key, new BsonRegularExpression(String.Format("(?:{0})", item.Value), "is"))); } var query = qParams.Operator == QueryOperator.AND ? Query.And(queries) : Query.Or(queries); MongoCursor <T> cursor = mongoDb.GetCollection <T>(GetTypeName(typeof(T))).Find(query); cursor.SetSkip(qParams.SkipRecords).SetLimit(qParams.Count); // Setting the Sort params if (qParams.SortParams != null && qParams.SortParams.Count > 0) { SortByBuilder sbb = new SortByBuilder(); foreach (KeyValuePair <string, bool> sortItem in qParams.SortParams) { if (sortItem.Value) { sbb.Ascending(sortItem.Key); } else { sbb.Descending(sortItem.Key); } } cursor.SetSortOrder(sbb); } return(cursor.ToList()); }
private void ApplySorting(MongoCursor <BsonDocument> cursor, IEnumerable <SimpleOrderByItem> orderings) { if (orderings == null || !orderings.Any()) { return; } var sortBuilder = new SortByBuilder(); foreach (var ordering in orderings) { var name = ExpressionFormatter.GetFullName(ordering.Reference); if (ordering.Direction == OrderByDirection.Ascending) { sortBuilder.Ascending(name); } else { sortBuilder.Descending(name); } } cursor.SetSortOrder(sortBuilder); }
public virtual object Execute() { var visitor = new MongoDBVisitor(); visitor.Visite(ContentQuery.Expression); var mongoCursor = Query(visitor); if (mongoCursor == null) { return(DefaultValueExecute(visitor.CallType)); } if (visitor.Skip != 0) { mongoCursor.Skip = visitor.Skip; } SortByBuilder sortBuilder = new SortByBuilder(); foreach (var item in visitor.OrderFields) { if (item.Descending) { sortBuilder.Descending(item.FieldName); } else { sortBuilder.Ascending(item.FieldName); } } mongoCursor = mongoCursor.SetSortOrder(sortBuilder); object result = null; switch (visitor.CallType) { case Kooboo.CMS.Content.Query.Expressions.CallType.Count: result = Convert.ToInt32(mongoCursor.Count()); break; case Kooboo.CMS.Content.Query.Expressions.CallType.First: result = mongoCursor.First().ToContent(); break; case Kooboo.CMS.Content.Query.Expressions.CallType.Last: result = mongoCursor.Last().ToContent(); break; case Kooboo.CMS.Content.Query.Expressions.CallType.LastOrDefault: result = mongoCursor.Last().ToContent(); break; case Kooboo.CMS.Content.Query.Expressions.CallType.FirstOrDefault: result = mongoCursor.FirstOrDefault().ToContent(); break; case Kooboo.CMS.Content.Query.Expressions.CallType.Unspecified: default: if (visitor.Take != 0) { result = mongoCursor.Take(visitor.Take).Select(it => it.ToContent()); } else { result = mongoCursor.Select(it => it.ToContent()); } break; } if (mongoCursor.Database.Server.State != MongoServerState.Disconnected) { mongoCursor.Database.Server.Disconnect(); } return(result); }