/// <summary> /// Add a field into the sorting of result /// </summary> /// <returns>FindRequest with new sorting option</returns> /// <param name="field">The sort field</param> /// <param name="ascending">True if direction of sort is Asceding use false for Descending(Default is True)</param> public FindRequest <T> Sort(Expression <Func <T, object> > field, bool ascending = true) { var fieldName = Metadata.GetMemberInfo(field).Member.Name; SortFields.Add(new Sorting(fieldName, ascending)); return(this); }
public void AddSortField(SortField sortField) { if (string.IsNullOrWhiteSpace(sortField.Label)) { sortField.Label = TextService.Title(sortField.Name); } SortFields.Add(sortField); }
SortEdgeTable ( ListObject oEdgeTable, Range oRangeToSortOn ) { Debug.Assert(oEdgeTable != null); Debug.Assert(oRangeToSortOn != null); AssertValid(); Sort oSort = oEdgeTable.Sort; SortFields oSortFields = oSort.SortFields; oSortFields.Clear(); oSortFields.Add(oRangeToSortOn, XlSortOn.xlSortOnValues, XlSortOrder.xlAscending, Missing.Value, XlSortDataOption.xlSortNormal); oSort.Apply(); oSortFields.Clear(); }
/// <summary> /// Add sort field. Use + prefix for asc sorting, or use - prefix for desc sorting. /// </summary> public IndexQuery AddOrderBy(string field) { var reverse = false; if (field[0] == '+' || field[0] == '-') { reverse = field[0] == '-'; field = field.Substring(1); } var sortType = Lucene.Net.Search.SortField.STRING; var property = ModelType.GetProperty(field, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance); if (property != null) { sortType = LuceneUtility.GetSortType(property.PropertyType); } SortFields.Add(new SortField(field, sortType, reverse)); return(this); }
/// <summary> /// Internal operation for adding the ordered results /// </summary> /// <param name="descending">if set to <c>true</c> [descending].</param> /// <param name="fields">The field names.</param> /// <returns>A new <see cref="IBooleanOperation"/> with the clause appended</returns> private LuceneBooleanOperation OrderByInternal(bool descending, params SortableField[] fields) { if (fields == null) { throw new ArgumentNullException(nameof(fields)); } foreach (var f in fields) { var fieldName = f.FieldName; var defaultSort = SortField.STRING; switch (f.SortType) { case SortType.Score: defaultSort = SortField.SCORE; break; case SortType.DocumentOrder: defaultSort = SortField.DOC; break; case SortType.String: defaultSort = SortField.STRING; break; case SortType.Int: defaultSort = SortField.INT; break; case SortType.Float: defaultSort = SortField.FLOAT; break; case SortType.Long: defaultSort = SortField.LONG; break; case SortType.Double: defaultSort = SortField.DOUBLE; break; case SortType.Short: defaultSort = SortField.SHORT; break; case SortType.Byte: defaultSort = SortField.BYTE; break; default: throw new ArgumentOutOfRangeException(); } //get the sortable field name if this field type has one var valType = _searchContext.GetFieldValueType(fieldName); if (valType?.SortableFieldName != null) { fieldName = valType.SortableFieldName; } SortFields.Add(new SortField(fieldName, defaultSort, descending)); } return(new LuceneBooleanOperation(this)); }
public FindRequest <T> Sort(string fieldName, bool ascending = true) { SortFields.Add(new Sorting(fieldName, ascending)); return(this); }
public void AddField(SortField <T> field) { SortFields.Add(field); }
protected override Expression VisitMethodCall(MethodCallExpression node) { Trace(MethodInfo.GetCurrentMethod(), node); var visited = base.VisitMethodCall(node); var methodCallExpr = visited as MethodCallExpression; if (methodCallExpr == null) { throw new NotSupportedException("#VisitMethodCall if visited is not null"); } switch (methodCallExpr.Method.Name) { case "OfType": // Do nothing. Type of expression has been changed so a TypeIs query will be created. case "Where": // do nothing break; case "Take": var topExpr = GetArgumentAsConstant(methodCallExpr, 1); this.Top = (int)topExpr.Value; break; case "Skip": var skipExpr = GetArgumentAsConstant(methodCallExpr, 1); this.Skip = (int)skipExpr.Value; break; case "Count": if (node.Arguments.Count == 2) { if (_queries.Count > 1) // There is Where in the main expression { CombineTwoQueriesOnStack(); } } this.CountOnly = true; break; case "ThenBy": case "OrderBy": SortFields.Add(CreateSortFieldFromExpr(node, false)); break; case "ThenByDescending": case "OrderByDescending": SortFields.Add(CreateSortFieldFromExpr(node, true)); break; case "StartsWith": var startsWithExpr = GetArgumentAsConstant(methodCallExpr, 0); var startsWithArg = (string)startsWithExpr.Value; BuildWildcardQuery(GetPropertyName(methodCallExpr.Object), WildcardPosition.AtEnd, startsWithArg); break; case "EndsWith": var endsWithExpr = GetArgumentAsConstant(methodCallExpr, 0); var endsWithArg = (string)endsWithExpr.Value; BuildWildcardQuery(GetPropertyName(methodCallExpr.Object), WildcardPosition.AtStart, endsWithArg); break; case "Contains": var arg0 = methodCallExpr.Arguments[0]; var constantExpr = arg0 as ConstantExpression; if (constantExpr != null) { if (constantExpr.Type == typeof(string)) { var containsArg = (string)constantExpr.Value; BuildWildcardQuery(GetPropertyName(methodCallExpr.Object), WildcardPosition.AtStartAndEnd, containsArg); break; } throw new NotSupportedException(String.Format("Calling Contains on an instance of type {0} is not supported. Allowed types: string, IEnumerable<Node>.", constantExpr.Type)); } var memberExpr = arg0 as MemberExpression; if (memberExpr != null) { if (memberExpr.Type == typeof(IEnumerable <Node>)) { var rightConstant = methodCallExpr.Arguments[1] as ConstantExpression; if (rightConstant != null) { var nodeValue = (Node)rightConstant.Value; BuildTermQuery(memberExpr.Member.Name, nodeValue); break; } throw NotSupportedException(node, "#1"); } throw NotSupportedException(node, "#2"); } throw NotSupportedException(node, "#3"); case "First": this.Top = 1; this.ThrowIfEmpty = true; if (methodCallExpr.Arguments.Count == 2) { if (_queries.Count > 1) { CombineTwoQueriesOnStack(); } } break; case "FirstOrDefault": this.ThrowIfEmpty = false; this.Top = 1; if (methodCallExpr.Arguments.Count == 2) { if (_queries.Count > 1) // There is Where in the main expression { CombineTwoQueriesOnStack(); } } break; case "Any": this.CountOnly = true; this.ExistenceOnly = true; this.Top = 1; if (methodCallExpr.Arguments.Count == 2) { if (_queries.Count > 1) { CombineTwoQueriesOnStack(); } } break; case "Type": var typeExpr = GetArgumentAsConstant(methodCallExpr, 0); BuildTermQuery("Type", (string)typeExpr.Value); break; case "TypeIs": var typeIsExpr = GetArgumentAsConstant(methodCallExpr, 0); BuildTermQuery("TypeIs", (string)(typeIsExpr).Value); break; case "get_Item": var typedParamExpr = methodCallExpr.Object as ParameterExpression; if (typedParamExpr == null) { throw new NotSupportedException("#get_Item"); } break; case "startswith": { var fieldName = GetPropertyName(methodCallExpr.Arguments[0]); var startswithExpr = GetArgumentAsConstant(methodCallExpr, 1); var arg = (string)startswithExpr.Value; BuildWildcardQuery(fieldName, WildcardPosition.AtEnd, arg); break; } case "endswith": { var fieldName = GetPropertyName(methodCallExpr.Arguments[0]); var endswithExpr = GetArgumentAsConstant(methodCallExpr, 1); var arg = (string)endswithExpr.Value; BuildWildcardQuery(fieldName, WildcardPosition.AtStart, arg); break; } case "substringof": { var fieldName = GetPropertyName(methodCallExpr.Arguments[1]); var substringofExpr = GetArgumentAsConstant(methodCallExpr, 0); var arg = (string)substringofExpr.Value; BuildWildcardQuery(fieldName, WildcardPosition.AtStartAndEnd, arg); break; } case "isof": { var isofExpr = GetArgumentAsConstant(methodCallExpr, 1); BuildTermQuery("TypeIs", (string)(isofExpr).Value); break; } case "InFolder": { var infolderexpr = GetArgumentAsConstant(methodCallExpr, 0); var folder = infolderexpr.Value; BuildTermQuery("InFolder", GetPath(folder, "InFolder")); break; } case "InTree": { var intreeexpr = GetArgumentAsConstant(methodCallExpr, 0); var folder = intreeexpr.Value; BuildTermQuery("InTree", GetPath(folder, "InTree")); break; } case "GetType": { var member = methodCallExpr.Object as MemberExpression; if (member != null && member.Member == typeof(Content).GetProperty("ContentHandler")) { _queries.Push(new ContentHandlerGetTypeQuery()); } else { throw new NotSupportedException("GetType method is not supported: " + node); } break; } case "IsAssignableFrom": { var member = methodCallExpr.Object as ConstantExpression; if (member == null) { throw new NotSupportedException("IsAssignableFrom method is not supported: " + node); } var type = member.Value as Type; if (type == null) { throw new NotSupportedException("IsAssignableFrom method is not supported" + node); } if (_queries.Count == 0) { throw new NotSupportedException("IsAssignableFrom method is not supported" + node); } var q = _queries.Pop() as ContentHandlerGetTypeQuery; if (q == null) { throw new NotSupportedException("IsAssignableFrom method is not supported" + node); } _queries.Push(CreateTypeIsQuery(type)); break; } default: throw new SnNotSupportedException("Unknown method: " + methodCallExpr.Method.Name); } return(visited); }
DeleteDuplicateRows ( ListObject oEdgeTable, ListColumn oEdgeWeightColumn, Range oEdgeWeightData, Object [,] aoEdgeWeightValues ) { Debug.Assert(oEdgeTable != null); Debug.Assert(oEdgeWeightColumn != null); Debug.Assert(oEdgeWeightData != null); Debug.Assert(aoEdgeWeightValues != null); AssertValid(); Range oDuplicateRows = null; // Find the rows with null edge weights, which are the duplicates. To // avoid multiple areas, which can slow things down signficantly, sort // the table on the edge weight column. That forces the duplicates // to be contiguous. // // But first, add a temporary column and set its values to the // worksheet row numbers. This will be used later to restore the // original sort order. ListColumn oTemporaryColumn; if (!ExcelUtil.TryAddTableColumnWithRowNumbers(oEdgeTable, "Temporary for Sort", 5F, null, out oTemporaryColumn)) { return; } Sort oSort = oEdgeTable.Sort; SortFields oSortFields = oSort.SortFields; oSortFields.Clear(); oSortFields.Add(oEdgeWeightColumn.Range, XlSortOn.xlSortOnValues, XlSortOrder.xlAscending, Missing.Value, XlSortDataOption.xlSortNormal); oSort.Apply(); if (oEdgeWeightData.Rows.Count != 1) { try { oDuplicateRows = oEdgeWeightData.SpecialCells( XlCellType.xlCellTypeBlanks, Missing.Value); } catch (COMException) { // There are no such rows. oDuplicateRows = null; } } else { // Range.SpecialCells() can't be used in the one-cell case, for // which it behaves in a bizarre manner. See this posting: // // http://ewbi.blogs.com/develops/2006/03/determine_if_a_.html // // ...of which this is an excerpt: // // "SpecialCells ignores any source Range consisting of only one // cell. When executing SpecialCells on a Range having only one // cell, it will instead consider all of the cells falling within // the boundary marked by the bottom right cell of the source Range // sheet's UsedRange." // // Instead, just check the single row. if (aoEdgeWeightValues[1, 1] == null) { oDuplicateRows = oEdgeWeightData.EntireRow; } } if (oDuplicateRows != null) { // Delete the duplicate rows, which are contiguous. Debug.Assert(oDuplicateRows.Areas.Count == 1); oDuplicateRows.EntireRow.Delete(XlDeleteShiftDirection.xlShiftUp); } // Restore the original sort order by sorting on the temporary column // that contains the original worksheet row numbers. Debug.Assert(oTemporaryColumn != null); oSortFields.Clear(); oSortFields.Add(oTemporaryColumn.Range, XlSortOn.xlSortOnValues, XlSortOrder.xlAscending, Missing.Value, XlSortDataOption.xlSortNormal); oSort.Apply(); oSortFields.Clear(); oTemporaryColumn.Delete(); oSort.Apply(); }