private static void parseCompoundSortField(XContentParser parser, List<SortBuilder<?>> sortFields) throws IOException { XContentParser.Token token; while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) { if (token == XContentParser.Token.FIELD_NAME) { String fieldName = parser.currentName(); token = parser.nextToken(); if (token == XContentParser.Token.VALUE_STRING) { SortOrder order = SortOrder.fromString(parser.text()); sortFields.add(fieldOrScoreSort(fieldName).order(order)); } else { if (PARSERS.containsKey(fieldName)) { sortFields.add(PARSERS.get(fieldName).fromXContent(parser, fieldName)); } else { sortFields.add(FieldSortBuilder.fromXContent(parser, fieldName)); } } } } }
builder.startArray(SearchSourceBuilder.SORT_FIELD.getPreferredName()); for (SortBuilder<?> sort : sorts) { sort.toXContent(builder, params);
public static Optional<SortAndFormats> buildSort(List<SortBuilder<?>> sortBuilders, QueryShardContext context) throws IOException { List<SortField> sortFields = new ArrayList<>(sortBuilders.size()); List<DocValueFormat> sortFormats = new ArrayList<>(sortBuilders.size()); for (SortBuilder<?> builder : sortBuilders) { SortFieldAndFormat sf = builder.build(context); sortFields.add(sf.field); sortFormats.add(sf.format); } if (!sortFields.isEmpty()) { // optimize if we just sort on score non reversed, we don't really // need sorting boolean sort; if (sortFields.size() > 1) { sort = true; } else { SortField sortField = sortFields.get(0); if (sortField.getType() == SortField.Type.SCORE && !sortField.getReverse()) { sort = false; } else { sort = true; } } if (sort) { return Optional.of(new SortAndFormats( new Sort(sortFields.toArray(new SortField[sortFields.size()])), sortFormats.toArray(new DocValueFormat[sortFormats.size()]))); } } return Optional.empty(); }
public static List<SortBuilder<?>> fromXContent(XContentParser parser) throws IOException { List<SortBuilder<?>> sortFields = new ArrayList<>(2); XContentParser.Token token = parser.currentToken(); if (token == XContentParser.Token.START_ARRAY) { while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) { if (token == XContentParser.Token.START_OBJECT) { parseCompoundSortField(parser, sortFields); } else if (token == XContentParser.Token.VALUE_STRING) { String fieldName = parser.text(); sortFields.add(fieldOrScoreSort(fieldName)); } else { throw new IllegalArgumentException("malformed sort format, " + "within the sort array, an object, or an actual string are allowed"); } } } else if (token == XContentParser.Token.VALUE_STRING) { String fieldName = parser.text(); sortFields.add(fieldOrScoreSort(fieldName)); } else if (token == XContentParser.Token.START_OBJECT) { parseCompoundSortField(parser, sortFields); } else { throw new IllegalArgumentException("malformed sort format, either start with array, object, or an actual string"); } return sortFields; }
private void outputOrder(StringBuilder sb) { if (randomize) { sb.append(" RANDOMIZED"); } else if (!orderBys.isEmpty()) { sb.append(" ORDER BY"); orderBys.forEach(sortBuilder -> { if (sortBuilder instanceof FieldSortBuilder) { sb.append(" ").append(((FieldSortBuilder) sortBuilder).getFieldName()); } else { sb.append(" ").append(sortBuilder.getWriteableName()); } sb.append(" ").append(sortBuilder.order().name()); }); } }
optionalSort = Optional.empty(); } else { optionalSort = SortBuilder.buildSort(sorts, context.getQueryShardContext());
suggestBuilder = SuggestBuilder.fromXContent(parser); } else if (SORT_FIELD.match(currentFieldName, parser.getDeprecationHandler())) { sorts = new ArrayList<>(SortBuilder.fromXContent(parser)); } else if (RESCORE_FIELD.match(currentFieldName, parser.getDeprecationHandler())) { rescoreBuilders = new ArrayList<>(); sorts = new ArrayList<>(SortBuilder.fromXContent(parser)); } else if (RESCORE_FIELD.match(currentFieldName, parser.getDeprecationHandler())) { rescoreBuilders = new ArrayList<>();
protected static Nested resolveNested(QueryShardContext context, NestedSortBuilder nestedSort) throws IOException { final Query childQuery = resolveNestedQuery(context, nestedSort, null); if (childQuery == null) { return null; } final ObjectMapper objectMapper = context.nestedScope().getObjectMapper(); final Query parentQuery; if (objectMapper == null) { parentQuery = Queries.newNonNestedFilter(context.indexVersionCreated()); } else { parentQuery = objectMapper.nestedTypeFilter(); } return new Nested(context.bitsetFilter(parentQuery), childQuery, nestedSort); }
path = parser.text(); } else if (currentName.equals(FILTER_FIELD.getPreferredName())) { filter = parseNestedFilter(parser); } else if (currentName.equals(MAX_CHILDREN_FIELD.getPreferredName())) { maxChildren = parser.intValue();
protected static Nested resolveNested(QueryShardContext context, String nestedPath, QueryBuilder nestedFilter) throws IOException { NestedSortBuilder nestedSortBuilder = new NestedSortBuilder(nestedPath); nestedSortBuilder.setFilter(nestedFilter); return resolveNested(context, nestedSortBuilder); }
public static List<SortBuilder<?>> fromXContent(XContentParser parser) throws IOException { List<SortBuilder<?>> sortFields = new ArrayList<>(2); XContentParser.Token token = parser.currentToken(); if (token == XContentParser.Token.START_ARRAY) { while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) { if (token == XContentParser.Token.START_OBJECT) { parseCompoundSortField(parser, sortFields); } else if (token == XContentParser.Token.VALUE_STRING) { String fieldName = parser.text(); sortFields.add(fieldOrScoreSort(fieldName)); } else { throw new IllegalArgumentException("malformed sort format, " + "within the sort array, an object, or an actual string are allowed"); } } } else if (token == XContentParser.Token.VALUE_STRING) { String fieldName = parser.text(); sortFields.add(fieldOrScoreSort(fieldName)); } else if (token == XContentParser.Token.START_OBJECT) { parseCompoundSortField(parser, sortFields); } else { throw new IllegalArgumentException("malformed sort format, either start with array, object, or an actual string"); } return sortFields; }
Optional<SortAndFormats> optionalSort = SortBuilder.buildSort(source.sorts(), context.getQueryShardContext()); if (optionalSort.isPresent()) { context.sort(optionalSort.get());
factory.highlighter(HighlightBuilder.fromXContent(parser)); } else if (SearchSourceBuilder.SORT_FIELD.match(currentFieldName, parser.getDeprecationHandler())) { List<SortBuilder<?>> sorts = SortBuilder.fromXContent(parser); factory.sorts(sorts); } else { List<SortBuilder<?>> sorts = SortBuilder.fromXContent(parser); factory.sorts(sorts); } else if (SearchSourceBuilder._SOURCE_FIELD.match(currentFieldName, parser.getDeprecationHandler())) {
try { context.nestedScope().nextLevel(nestedObjectMapper); return resolveNestedQuery(context, nestedNestedSort, childQuery); } finally { context.nestedScope().previousLevel();
path = parser.text(); } else if (currentName.equals(FILTER_FIELD.getPreferredName())) { filter = parseNestedFilter(parser); } else if (currentName.equals(MAX_CHILDREN_FIELD.getPreferredName())) { maxChildren = parser.intValue();
protected static Nested resolveNested(QueryShardContext context, String nestedPath, QueryBuilder nestedFilter) throws IOException { NestedSortBuilder nestedSortBuilder = new NestedSortBuilder(nestedPath); nestedSortBuilder.setFilter(nestedFilter); return resolveNested(context, nestedSortBuilder); }
builder.startArray(SearchSourceBuilder.SORT_FIELD.getPreferredName()); for (SortBuilder<?> sort : sorts) { sort.toXContent(builder, params);
private static void parseCompoundSortField(XContentParser parser, List<SortBuilder<?>> sortFields) throws IOException { XContentParser.Token token; while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) { if (token == XContentParser.Token.FIELD_NAME) { String fieldName = parser.currentName(); token = parser.nextToken(); if (token == XContentParser.Token.VALUE_STRING) { SortOrder order = SortOrder.fromString(parser.text()); sortFields.add(fieldOrScoreSort(fieldName).order(order)); } else { if (PARSERS.containsKey(fieldName)) { sortFields.add(PARSERS.get(fieldName).fromXContent(parser, fieldName)); } else { sortFields.add(FieldSortBuilder.fromXContent(parser, fieldName)); } } } } }
public static List<SortBuilder<?>> fromXContent(XContentParser parser) throws IOException { List<SortBuilder<?>> sortFields = new ArrayList<>(2); XContentParser.Token token = parser.currentToken(); if (token == XContentParser.Token.START_ARRAY) { while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) { if (token == XContentParser.Token.START_OBJECT) { parseCompoundSortField(parser, sortFields); } else if (token == XContentParser.Token.VALUE_STRING) { String fieldName = parser.text(); sortFields.add(fieldOrScoreSort(fieldName)); } else { throw new IllegalArgumentException("malformed sort format, " + "within the sort array, an object, or an actual string are allowed"); } } } else if (token == XContentParser.Token.VALUE_STRING) { String fieldName = parser.text(); sortFields.add(fieldOrScoreSort(fieldName)); } else if (token == XContentParser.Token.START_OBJECT) { parseCompoundSortField(parser, sortFields); } else { throw new IllegalArgumentException("malformed sort format, either start with array, object, or an actual string"); } return sortFields; }
Optional<SortAndFormats> optionalSort = SortBuilder.buildSort(innerHitBuilder.getSorts(), queryShardContext); if (optionalSort.isPresent()) { innerHitsContext.sort(optionalSort.get());