@Override public String toString() { StringBuilder sb = new StringBuilder(); String space = ""; for (FieldOrder spec : fieldOrders) { sb.append(space); if (spec.getSortOrder() == Order.DESCENDING) { sb.append("-"); } else { sb.append("+"); } sb.append(spec.getFieldName()); space = " "; } return sb.toString(); }
if (f.getSortOrder() == Order.DESCENDING) { yql.append(" desc");
public int encode(ByteBuffer buffer) { int usedBytes = 0; byte[] nameBuffer; buffer.position(); byte space = '.'; for (FieldOrder fieldOrder : fieldOrders) { if (space == ' ') { buffer.put(space); usedBytes++; } if (fieldOrder.getSortOrder() == Order.ASCENDING) { buffer.put((byte) '+'); } else { buffer.put((byte) '-'); } usedBytes++; nameBuffer = Utf8.toBytes(fieldOrder.getSorter().toString()); buffer.put(nameBuffer); usedBytes += nameBuffer.length; // If this isn't the last element, append a separating space //if (i + 1 < sortSpec.size()) { space = ' '; } return usedBytes; }
AttributesConfig.Attribute attrConfig = names.get(name); if (attrConfig != null) { if (f.getSortOrder() == Sorting.Order.UNDEFINED) { f.setAscending(attrConfig.sortascending());
/** * 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); }
/** * 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; }
/** * 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; }
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)); }