public Sorting clone() { return new Sorting(this.fieldOrders); }
/** Creates a sort spec from a string */ public Sorting(String sortSpec) { setSpec(sortSpec); }
public String toString() { StringBuilder b = new StringBuilder(); b.append("FieldComparator:"); if (sorting == null) { b.append(" null"); } else { b.append(sorting.toString()); } return b.toString(); }
private void serializeSorting(StringBuilder yql) { yql.append(" order by "); int initLen = yql.length(); for (FieldOrder f : getRanking().getSorting().fieldOrders()) { if (yql.length() > initLen) { yql.append(", ");
int rankIndex=-1; int sourceIndex=-1; for (int i=0; i<sorting.fieldOrders().size(); i++) { Sorting.FieldOrder order=sorting.fieldOrders().get(i); if ("[relevance]".equals(order.getFieldName()) || "[rank]".equals(order.getFieldName())) rankIndex=i; if (sourceIndex>=0) { // replace alphabetical sorting on source by sourceList order sorting if (sourceIndex>0) // sort fields before the source beforeSource=new Sorting(new ArrayList<>(sorting.fieldOrders().subList(0,sourceIndex))); if (sorting.fieldOrders().size()>sourceIndex+1) // sort fields after the source afterSource=new Sorting(new ArrayList<>(sorting.fieldOrders().subList(sourceIndex+1,sorting.fieldOrders().size()+1)));
case 3: if (query.getRanking().getSorting() != null) ed.setReturned(query.getRanking().getSorting().encode(buf)); else ed.setReturned(0);
/** Fills a section with attributes and sub-elements from a "section" or "page" element */ private Section readSection(Element sectionElement,Section section) { section.setLayout(Layout.fromString(sectionElement.getAttribute("layout"))); section.setRegion(sectionElement.getAttribute("region")); section.setOrder(Sorting.fromString(sectionElement.getAttribute("order"))); section.setMax(readOptionalNumber(sectionElement,"max")); section.setMin(readOptionalNumber(sectionElement,"min")); section.elements().addAll(readSourceAttribute(sectionElement)); section.elements().addAll(readPageElements(sectionElement)); return section; }
@Override public Object clone() { try { Ranking clone = (Ranking) super.clone(); if (sorting != null) clone.sorting = this.sorting.clone(); clone.rankProperties = this.rankProperties.clone(); clone.rankFeatures = this.rankFeatures.clone(); clone.matchPhase = this.matchPhase.clone(); clone.matching = this.matching.clone(); clone.softTimeout = this.softTimeout.clone(); return clone; } catch (CloneNotSupportedException e) { throw new RuntimeException("Someone inserted a noncloneable superclass",e); } }
private boolean shouldBeDegraded(Query query, IndexFacts.Session indexFacts) { if (query.getRanking().getSorting() == null) return false; if (query.getRanking().getSorting().fieldOrders().isEmpty()) return false; if ( ! query.getSelect().getGrouping().isEmpty()) return false; if ( ! query.properties().getBoolean(DEGRADING, true)) return false; Index index = indexFacts.getIndex(query.getRanking().getSorting().fieldOrders().get(0).getFieldName()); if (index == null) return false; if ( ! index.isFastSearch()) return false; if ( ! index.isNumerical()) return false; return true; }
int sortSpecLengthPosition=buffer.position(); buffer.putInt(0); int sortSpecLength = query.getRanking().getSorting().encode(buffer); buffer.putInt(sortSpecLengthPosition, sortSpecLength);
if (getRanking().getSorting() != null && getRanking().getSorting().fieldOrders().size() > 0) { serializeSorting(yql);
/** * Creates a new sorting from the given string and returns it, or returns null if the argument does not contain * any sorting criteria (e.g it is null or the empty string) */ public static Sorting fromString(String sortSpec) { if (sortSpec==null) return null; if ("".equals(sortSpec)) return null; return new Sorting(sortSpec); }
/** * Create a hit ordering clause based on the sorting spec. * * @param sortingSpec A (single level!) sorting specification * @return a grouping expression which produces a sortable value */ private static List<GroupingExpression> createHitOrderingClause(Sorting sortingSpec) { List<GroupingExpression> orderingClause = new ArrayList<>(); for (Sorting.FieldOrder fieldOrder : sortingSpec.fieldOrders()) { Sorting.Order sortOrder = fieldOrder.getSortOrder(); switch (sortOrder) { case ASCENDING: case UNDEFINED: // When we want ascending order, the hit with the smallest value should come first (and be surfaced). orderingClause.add(new MinAggregator(new AttributeValue(fieldOrder.getFieldName()))); break; case DESCENDING: // When we sort in descending order, the hit with the largest value should come first (and be surfaced). orderingClause.add(new NegFunction(new MaxAggregator(new AttributeValue(fieldOrder.getFieldName())))); break; default: throw new UnsupportedOperationException("Can not handle sort order " + sortOrder + "."); } } return orderingClause; }
/** Sets sorting from a string. See {@link Sorting} on syntax */ public void setSorting(String sortingString) { if (sortingString==null) setSorting((Sorting)null); else setSorting(new Sorting(sortingString)); }
/** * Create a hit ordering clause based on the sorting spec. * * @param sortingSpec A (single level!) sorting specification * @return a grouping expression which produces a sortable value */ private static GroupingExpression createGroupOrderingClause(Sorting sortingSpec) { GroupingExpression groupingClause = null; for (Sorting.FieldOrder fieldOrder : sortingSpec.fieldOrders()) { Sorting.Order sortOrder = fieldOrder.getSortOrder(); switch (sortOrder) { case ASCENDING: case UNDEFINED: groupingClause = new AttributeValue(fieldOrder.getFieldName()); break; case DESCENDING: // To sort descending, just take the negative. This is the most common case groupingClause = new NegFunction(new AttributeValue(fieldOrder.getFieldName())); break; default: throw new UnsupportedOperationException("Can not handle sort order " + sortOrder + "."); } } return groupingClause; }
sorting = new Sorting(sortingInit); return ast.getArgument(0);
.append(query.getRanking().getSorting().fieldOrders().toString());
@Override public Result search(Query query, Execution execution) { List<FieldOrder> s = (query.getRanking().getSorting() != null) ? query.getRanking().getSorting().fieldOrders() : null; if (s == null) { return execution.search(query); } for (FieldOrder f : s) { if (RANK.equals(f.getFieldName())) { return execution.search(query); } } query.getRanking().setProfile(UNRANKED); return execution.search(query); }
private void setDegradation(Query query) { query.trace("Using sorting degrading for performance - totalHits will be wrong. " + "Turn off with sorting.degrading=false.", 2); Sorting.FieldOrder primarySort = query.getRanking().getSorting().fieldOrders().get(0); // ensured above MatchPhase matchPhase = query.getRanking().getMatchPhase(); matchPhase.setAttribute(primarySort.getFieldName()); matchPhase.setAscending(primarySort.getSortOrder() == Sorting.Order.ASCENDING); if (matchPhase.getMaxHits() == null) matchPhase.setMaxHits(decideDefaultMaxHits(query)); }
/** * Compares hits based on a sorting specification and values * stored in hit fields.0 * <p> * When one of the hits has the requested property and the other * has not, the the hit containing the property precedes the one * that does not. * <p> * There is no locale based sorting here, as the backend does * not do that either. * * @return -1, 0, 1 if first should be sorted before, equal to * or after second */ @Override public int compare(Hit first, Hit second) { for (Sorting.FieldOrder fieldOrder : sorting.fieldOrders() ) { String fieldName = fieldOrder.getFieldName(); Object a = getField(first,fieldName); Object b = getField(second,fieldName); int x = compareValues(a, b, fieldOrder.getSorter()); if (x != 0) { if (fieldOrder.getSortOrder() == Sorting.Order.DESCENDING) x *= -1; return x; } } return super.compare(first,second); }