fieldOrders.add(new FieldOrder(sorter, order));
yql.append(", "); Class<? extends AttributeSorter> sorterType = f.getSorter().getClass(); if (sorterType == Sorting.RawSorter.class) { yql.append("[{\"") .append("\"}]"); } else if (sorterType == Sorting.UcaSorter.class) { Sorting.UcaSorter uca = (Sorting.UcaSorter) f.getSorter(); String ucaLocale = uca.getLocale(); Sorting.UcaSorter.Strength ucaStrength = uca.getStrength(); yql.append(f.getFieldName()); if (f.getSortOrder() == Order.DESCENDING) { yql.append(" desc");
String name = f.getFieldName(); if ("[rank]".equals(name) || "[docid]".equals(name)) { f.getSorter().setName("[rank]"); } else if (names.containsKey(name)) { AttributesConfig.Attribute attrConfig = names.get(name); if (attrConfig != null) { if (f.getSortOrder() == Sorting.Order.UNDEFINED) { f.setAscending(attrConfig.sortascending()); if (f.getSorter().getClass().equals(Sorting.AttributeSorter.class)) { f.setSorter(new Sorting.UcaSorter(name, locale, Sorting.UcaSorter.Strength.UNDEFINED)); } else { f.setSorter(new Sorting.LowerCaseSorter(name)); f.setSorter(new Sorting.LowerCaseSorter(name)); } else if (attrConfig.sortfunction() == AttributesConfig.Attribute.Sortfunction.RAW) { f.setSorter(new Sorting.RawSorter(name)); } else { f.setSorter(new Sorting.LowerCaseSorter(name)); if (f.getSorter() instanceof Sorting.UcaSorter) { Sorting.UcaSorter sorter = (Sorting.UcaSorter) f.getSorter(); String locale = sorter.getLocale();
sortingInit.add(new FieldOrder(sorter, Order.ASCENDING)); break; case DESC: sortingInit.add(new FieldOrder(sorter, Order.DESCENDING)); break; default:
/** * 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); }
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; else if (order.getFieldName().equals("[source]")) sourceIndex=i;
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; }
/** * 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; }
@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(); }
@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); }
@Override public FieldOrder clone() { return new FieldOrder(fieldSorter.clone(), sortOrder); } }
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)); }
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; }