org.elasticsearch.search.suggest.Suggest Java Examples

public static SearchResponse createEmptySearchResponse() throws IOException {
    return new SearchResponse(
        new InternalSearchResponse(
            new SearchHits(new SearchHit[0], new TotalHits(0, TotalHits.Relation.EQUAL_TO), 1.0f),
            new InternalAggregations(Collections.emptyList()),
            new Suggest(Collections.emptyList()),
            new SearchProfileShardResults(Collections.emptyMap()),
            false,
            false,
            1
        ),
        "",
        5,
        5,
        0,
        100,
        ShardSearchFailure.EMPTY_ARRAY,
        SearchResponse.Clusters.EMPTY
    );
}
 

public static SearchResponse createSearchResponse(ToXContentObject o) throws IOException {
    XContentBuilder content = o.toXContent(XContentFactory.jsonBuilder(), ToXContent.EMPTY_PARAMS);

    SearchHit[] hits = new SearchHit[1];
    hits[0] = new SearchHit(0).sourceRef(BytesReference.bytes(content));

    return new SearchResponse(
        new InternalSearchResponse(
            new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1.0f),
            new InternalAggregations(Collections.emptyList()),
            new Suggest(Collections.emptyList()),
            new SearchProfileShardResults(Collections.emptyMap()),
            false,
            false,
            1
        ),
        "",
        5,
        5,
        0,
        100,
        ShardSearchFailure.EMPTY_ARRAY,
        SearchResponse.Clusters.EMPTY
    );
}
 

@Override
public void readFrom(StreamInput in) throws IOException {
    hits = readSearchHits(in);
    if (in.readBoolean()) {
        aggregations = InternalAggregations.readAggregations(in);
    }
    if (in.readBoolean()) {
        suggest = Suggest.readSuggest(Suggest.Fields.SUGGEST, in);
    }
    timedOut = in.readBoolean();

    terminatedEarly = in.readOptionalBoolean();

    if (in.getVersion().onOrAfter(Version.V_2_2_0) && in.readBoolean()) {
        profileResults = new InternalProfileShardResults(in);
    } else {
        profileResults = null;
    }
}
 

private static SuggestionEntry mapToSuggestionEntry(Suggest.Suggestion.Entry<?> esSuggestionEntry) {
    final SuggestionEntry suggestionEntry = new SuggestionEntry()
            .setLength(esSuggestionEntry.getLength())
            .setOffset(esSuggestionEntry.getOffset())
            .setOptions(
                    esSuggestionEntry.getOptions()
                            .stream()
                            .map(e -> mapToSuggestionEntryOption(e))
                            .collect(Collectors.toList())
            );

    if (esSuggestionEntry.getText() != null) {
        suggestionEntry.setText(esSuggestionEntry.getText().string());
    }


    return suggestionEntry;
}
 

private static Suggestion mapToSuggestion(Suggest.Suggestion<?> esSuggestion) {
    final Suggestion suggestion = new Suggestion()
            .setName(esSuggestion.getName())
            .setSize(esSuggestion.getEntries().size())
            .setEntries(
                    esSuggestion.getEntries().stream()
                            .map(e -> mapToSuggestionEntry(e))
                            .collect(Collectors.toList())
            );

    if (esSuggestion instanceof CompletionSuggestion) {
        suggestion.setSuggestionType(SuggestionType.COMPLETION);
    } else if (esSuggestion instanceof PhraseSuggestion) {
        suggestion.setSuggestionType(SuggestionType.PHRASE);
    } else if (esSuggestion instanceof TermSuggestion) {
        suggestion.setSuggestionType(SuggestionType.TERM);
    } else {
        throw new RuntimeException("SuggestionType " + esSuggestion.getClass().getCanonicalName() + " unknown");
    }

    return suggestion;
}
 

@Override
protected XContentBuilder toXContent(SuggestRequest request, SuggestResponse response, XContentBuilder builder) throws IOException {
    builder.startObject();
    buildBroadcastShardsHeader(builder, response);
    Suggest suggest = response.getSuggest();
    if (suggest != null) {
        suggest.toXContent(builder, ToXContent.EMPTY_PARAMS);
    }
    builder.endObject();
    return builder;
}
 

private InternalSearchResponse parseInternalSearchResponse(Map<String,?> map) {
    InternalSearchHits internalSearchHits = parseInternalSearchHits(map);
    InternalAggregations internalAggregations = parseInternalAggregations(map);
    Suggest suggest = parseSuggest(map);
    InternalProfileShardResults internalProfileShardResults = null;
    Boolean timeout = false;
    Boolean terminatedEarly = false;
    return new InternalSearchResponse(internalSearchHits,
            internalAggregations,
            suggest,
            internalProfileShardResults,
            timeout,
            terminatedEarly);
}
 

@Override
public SearchResponse search(String searchTerms, List<String> references, List<String> siteIds, int start, int end, Map<String,String> additionalSearchInfromation) {
    return new SearchResponse(
            new InternalSearchResponse(new InternalSearchHits(new InternalSearchHit[0], 0, 0.0f), new InternalFacets(Collections.EMPTY_LIST), new InternalAggregations(Collections.EMPTY_LIST), new Suggest(), false, false),
            "no-op",
            1,
            1,
            1,
            new ShardSearchFailure[0]
    );
}
 

@Override
public SearchResponse search(String searchTerms, List<String> references, List<String> siteIds, int start, int end, Map<String,String> additionalSearchInfromation) {
    return new SearchResponse(
            new InternalSearchResponse(new InternalSearchHits(new InternalSearchHit[0], 0, 0.0f), new InternalFacets(Collections.EMPTY_LIST), new InternalAggregations(Collections.EMPTY_LIST), new Suggest(), false, false),
            "no-op",
            1,
            1,
            1,
            new ShardSearchFailure[0]
    );
}
 

private static SuggestionEntryOption mapToSuggestionEntryOption(Suggest.Suggestion.Entry.Option esSuggestionEntryOption) {
    final SuggestionEntryOption suggestionEntryOption = new SuggestionEntryOption()
            .setScore(esSuggestionEntryOption.getScore());

    if (esSuggestionEntryOption.getText() != null) {
        suggestionEntryOption.setText(esSuggestionEntryOption.getText().string());
    }

    if (esSuggestionEntryOption.getHighlighted() != null) {
        suggestionEntryOption.setHighlight(esSuggestionEntryOption.getHighlighted().string());
    }

    return suggestionEntryOption;
}
 

public static com.hubrick.vertx.elasticsearch.model.SearchResponse mapToSearchResponse(SearchResponse esSearchResponse) {
    final com.hubrick.vertx.elasticsearch.model.SearchResponse searchResponse = new com.hubrick.vertx.elasticsearch.model.SearchResponse();

    searchResponse.setRawResponse(readResponse(esSearchResponse));
    searchResponse.setTook(esSearchResponse.getTook().getMillis());
    searchResponse.setTimedOut(esSearchResponse.isTimedOut());
    searchResponse.setShards(mapToShards(esSearchResponse));
    searchResponse.setHits(mapToHits(esSearchResponse.getHits()));
    searchResponse.setScrollId(esSearchResponse.getScrollId());

    if (esSearchResponse.getSuggest() != null) {
        for (Suggest.Suggestion<?> entries : esSearchResponse.getSuggest()) {
            searchResponse.addSuggestion(entries.getName(), mapToSuggestion(entries));
        }
    }

    if (esSearchResponse.getAggregations() != null) {
        searchResponse.setAggregations(
                esSearchResponse.getAggregations().asMap()
                        .entrySet()
                        .stream()
                        .collect(Collectors.toMap(e -> e.getKey(), e -> readResponse((InternalAggregation) e.getValue())))
        );
    }

    return searchResponse;
}
 

@Override
protected ShardSuggestResponse shardOperation(ShardSuggestRequest request) {
    IndexService indexService = indicesService.indexServiceSafe(request.shardId().getIndex());
    IndexShard indexShard = indexService.shardSafe(request.shardId().id());
    ShardSuggestMetric suggestMetric = indexShard.getSuggestMetric();
    suggestMetric.preSuggest();
    long startTime = System.nanoTime();
    XContentParser parser = null;
    try (Engine.Searcher searcher = indexShard.acquireSearcher("suggest")) {
        BytesReference suggest = request.suggest();
        if (suggest != null && suggest.length() > 0) {
            parser = XContentFactory.xContent(suggest).createParser(suggest);
            if (parser.nextToken() != XContentParser.Token.START_OBJECT) {
                throw new IllegalArgumentException("suggest content missing");
            }
            final SuggestionSearchContext context = suggestPhase.parseElement().parseInternal(parser, indexService.mapperService(),
                    indexService.queryParserService(), request.shardId().getIndex(), request.shardId().id(), request);
            final Suggest result = suggestPhase.execute(context, searcher.searcher());
            return new ShardSuggestResponse(request.shardId(), result);
        }
        return new ShardSuggestResponse(request.shardId(), new Suggest());
    } catch (Throwable ex) {
        throw new ElasticsearchException("failed to execute suggest", ex);
    } finally {
        if (parser != null) {
            parser.close();
        }
        suggestMetric.postSuggest(System.nanoTime() - startTime);
    }
}
 

@Override
protected SuggestResponse newResponse(SuggestRequest request, AtomicReferenceArray shardsResponses, ClusterState clusterState) {
    int successfulShards = 0;
    int failedShards = 0;

    final Map<String, List<Suggest.Suggestion>> groupedSuggestions = new HashMap<>();

    List<ShardOperationFailedException> shardFailures = null;
    for (int i = 0; i < shardsResponses.length(); i++) {
        Object shardResponse = shardsResponses.get(i);
        if (shardResponse == null) {
            // simply ignore non active shards
        } else if (shardResponse instanceof BroadcastShardOperationFailedException) {
            failedShards++;
            if (shardFailures == null) {
                shardFailures = new ArrayList<>();
            }
            shardFailures.add(new DefaultShardOperationFailedException((BroadcastShardOperationFailedException) shardResponse));
        } else {
            Suggest suggest = ((ShardSuggestResponse) shardResponse).getSuggest();
            Suggest.group(groupedSuggestions, suggest);
            successfulShards++;
        }
    }

    return new SuggestResponse(new Suggest(Suggest.reduce(groupedSuggestions)), shardsResponses.length(), successfulShards, failedShards, shardFailures);
}
 

public InternalSearchResponse(InternalSearchHits hits, InternalAggregations aggregations, Suggest suggest,
                              InternalProfileShardResults profileResults, boolean timedOut, Boolean terminatedEarly) {
    this.hits = hits;
    this.aggregations = aggregations;
    this.suggest = suggest;
    this.profileResults = profileResults;
    this.timedOut = timedOut;
    this.terminatedEarly = terminatedEarly;
}
 

@Test
public void extractAggregationValue() {
    int docId = 0, docId1 = 1, docId2 = 2, docId3 = 3, docId4 = 400, docId5 = 5000;
    SearchHit[] hit = new SearchHit[6];
    hit[0] = new SearchHit(docId);
    hit[1] = new SearchHit(docId1);
    hit[2] = new SearchHit(docId2);
    hit[3] = new SearchHit(docId3);
    hit[4] = new SearchHit(docId4);
    hit[5] = new SearchHit(docId5);
    SearchHits hits = new SearchHits(hit, 30000, 450);

    Aggregations aggregations = new Aggregations(new ArrayList());

    List<Suggest.Suggestion<? extends Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option>>> suggestions = new ArrayList();
    suggestions.add(new Suggest.Suggestion("sug1", 1));
    suggestions.add(new Suggest.Suggestion("sug2", 2));
    suggestions.add(new Suggest.Suggestion("sug3", 3));
    suggestions.add(new Suggest.Suggestion("sug4", 4));
    suggestions.add(new Suggest.Suggestion("sug5", 50));

    Suggest suggest = new Suggest(suggestions);

    SearchProfileShardResults profileResults = new SearchProfileShardResults(Collections.emptyMap());

    SearchResponseSections internalResponse = new SearchResponseSections(hits, aggregations, suggest, false, false, profileResults, 0);

    ShardSearchFailure[] shardFailures = new ShardSearchFailure[0];

    SearchResponse.Clusters clusters = SearchResponse.Clusters.EMPTY;

    SearchResponse sRes = new SearchResponse(internalResponse, "id1", 1, 1, 1, 1, shardFailures, clusters);

    JSONObject res = QueryUtil.extractAggregationValue(sRes);

    assertNotNull(res.get("suggest"));
    assertNotNull(res.get("hits"));
}
 

SuggestResponse(Suggest suggest, int totalShards, int successfulShards, int failedShards, List<ShardOperationFailedException> shardFailures) {
    super(totalShards, successfulShards, failedShards, shardFailures);
    this.suggest = suggest;
}
 

/**
 * The Suggestions of the phrase.
 */
public Suggest getSuggest() {
    return suggest;
}
 

@Override
public SuggestResponse newResponse() {
    return new SuggestResponse(new Suggest());
}
 

ShardSuggestResponse() {
    this.suggest = new Suggest();
}
 

ShardSuggestResponse(ShardId shardId, Suggest suggest) {
    super(shardId);
    this.suggest = suggest;
}
 

public Suggest getSuggest() {
    return this.suggest;
}
 

SuggestResponse(Suggest suggest) {
    this.suggest = suggest;
}
 

public Suggest getSuggest() {
    return internalResponse.suggest();
}
 

@Override
public Suggest getSuggest() {
  return searchResponse.getSuggest();
}
 

public Suggest suggest() {
    return suggest;
}
 

public Suggest suggest() {
    return suggest;
}
 

private Suggest parseSuggest(Map<String,?> map) {
    return null;
}