Java Suggest.Suggestion方法代码示例

import org.elasticsearch.search.suggest.Suggest; //导入方法依赖的package包/类
public void testSort() throws Exception {
    List<CompletionSuggestion> suggestions = new ArrayList<>();
    for (int i = 0; i < randomIntBetween(1, 5); i++) {
        suggestions.add(new CompletionSuggestion(randomAsciiOfLength(randomIntBetween(1, 5)), randomIntBetween(1, 20)));
    }
    int nShards = randomIntBetween(1, 20);
    int queryResultSize = randomBoolean() ? 0 : randomIntBetween(1, nShards * 2);
    AtomicArray<QuerySearchResultProvider> results = generateQueryResults(nShards, suggestions, queryResultSize, false);
    ScoreDoc[] sortedDocs = searchPhaseController.sortDocs(true, results);
    int accumulatedLength = Math.min(queryResultSize, getTotalQueryHits(results));
    for (Suggest.Suggestion<?> suggestion : reducedSuggest(results)) {
        int suggestionSize = suggestion.getEntries().get(0).getOptions().size();
        accumulatedLength += suggestionSize;
    }
    assertThat(sortedDocs.length, equalTo(accumulatedLength));
}
 

import org.elasticsearch.search.suggest.Suggest; //导入方法依赖的package包/类
@Override
public List<String> getSuggestions(String partial) {
    List<String> returnList = new ArrayList<>();

    String suggestionName = "suggestion";

    CompletionSuggestionBuilder completionSuggestionBuilder = new CompletionSuggestionBuilder(suggestionName);
    SuggestResponse suggestResponse = client.prepareSuggest("wow").setSuggestText(partial).addSuggestion(completionSuggestionBuilder.field("name.suggest")).execute().actionGet();
    Suggest suggest = suggestResponse.getSuggest();
    Suggest.Suggestion suggestion = suggest.getSuggestion(suggestionName);

    List<Suggest.Suggestion.Entry> list = suggestion.getEntries();
    for(Suggest.Suggestion.Entry entry : list) {
        List<Suggest.Suggestion.Entry.Option> options = entry.getOptions();
        for(Suggest.Suggestion.Entry.Option option : options) {
            returnList.add(option.getText().toString());
        }
    }

    return returnList;
}
 

import org.elasticsearch.search.suggest.Suggest; //导入方法依赖的package包/类
@Override
protected Suggest.Suggestion<? extends Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option>> innerExecute(String name,
        final CompletionSuggestionContext suggestionContext, final IndexSearcher searcher, CharsRefBuilder spare) throws IOException {
    if (suggestionContext.getFieldType() != null) {
        final CompletionFieldMapper.CompletionFieldType fieldType = suggestionContext.getFieldType();
        CompletionSuggestion completionSuggestion = new CompletionSuggestion(name, suggestionContext.getSize());
        spare.copyUTF8Bytes(suggestionContext.getText());
        CompletionSuggestion.Entry completionSuggestEntry = new CompletionSuggestion.Entry(
            new Text(spare.toString()), 0, spare.length());
        completionSuggestion.addTerm(completionSuggestEntry);
        TopSuggestDocsCollector collector = new TopDocumentsCollector(suggestionContext.getSize());
        suggest(searcher, suggestionContext.toQuery(), collector);
        int numResult = 0;
        for (TopSuggestDocs.SuggestScoreDoc suggestScoreDoc : collector.get().scoreLookupDocs()) {
            TopDocumentsCollector.SuggestDoc suggestDoc = (TopDocumentsCollector.SuggestDoc) suggestScoreDoc;
            // collect contexts
            Map<String, Set<CharSequence>> contexts = Collections.emptyMap();
            if (fieldType.hasContextMappings() && suggestDoc.getContexts().isEmpty() == false) {
                contexts = fieldType.getContextMappings().getNamedContexts(suggestDoc.getContexts());
            }
            if (numResult++ < suggestionContext.getSize()) {
                CompletionSuggestion.Entry.Option option = new CompletionSuggestion.Entry.Option(suggestDoc.doc,
                    new Text(suggestDoc.key.toString()), suggestDoc.score, contexts);
                completionSuggestEntry.addOption(option);
            } else {
                break;
            }
        }
        return completionSuggestion;
    }
    return null;
}
 

import org.elasticsearch.search.suggest.Suggest; //导入方法依赖的package包/类
/**
 * Reduces suggestions to a single suggestion containing at most
 * top {@link CompletionSuggestion#getSize()} options across <code>toReduce</code>
 */
public static CompletionSuggestion reduceTo(List<Suggest.Suggestion<Entry>> toReduce) {
    if (toReduce.isEmpty()) {
        return null;
    } else {
        final CompletionSuggestion leader = (CompletionSuggestion) toReduce.get(0);
        final Entry leaderEntry = leader.getEntries().get(0);
        final String name = leader.getName();
        if (toReduce.size() == 1) {
            return leader;
        } else {
            // combine suggestion entries from participating shards on the coordinating node
            // the global top <code>size</code> entries are collected from the shard results
            // using a priority queue
            OptionPriorityQueue priorityQueue = new OptionPriorityQueue(leader.getSize(), COMPARATOR);
            for (Suggest.Suggestion<Entry> suggestion : toReduce) {
                assert suggestion.getName().equals(name) : "name should be identical across all suggestions";
                for (Entry.Option option : ((CompletionSuggestion) suggestion).getOptions()) {
                    if (option == priorityQueue.insertWithOverflow(option)) {
                        // if the current option has overflown from pq,
                        // we can assume all of the successive options
                        // from this shard result will be overflown as well
                        break;
                    }
                }
            }
            final CompletionSuggestion suggestion = new CompletionSuggestion(leader.getName(), leader.getSize());
            final Entry entry = new Entry(leaderEntry.getText(), leaderEntry.getOffset(), leaderEntry.getLength());
            Collections.addAll(entry.getOptions(), priorityQueue.get());
            suggestion.addTerm(entry);
            return suggestion;
        }
    }
}
 

import org.elasticsearch.search.suggest.Suggest; //导入方法依赖的package包/类
private Suggest reducedSuggest(AtomicArray<QuerySearchResultProvider> results) {
    Map<String, List<Suggest.Suggestion<CompletionSuggestion.Entry>>> groupedSuggestion = new HashMap<>();
    for (AtomicArray.Entry<QuerySearchResultProvider> entry : results.asList()) {
        for (Suggest.Suggestion<?> suggestion : entry.value.queryResult().suggest()) {
            List<Suggest.Suggestion<CompletionSuggestion.Entry>> suggests =
                groupedSuggestion.computeIfAbsent(suggestion.getName(), s -> new ArrayList<>());
            suggests.add((Suggest.Suggestion<CompletionSuggestion.Entry>) suggestion);
        }
    }
    return new Suggest(groupedSuggestion.values().stream().map(CompletionSuggestion::reduceTo)
        .collect(Collectors.toList()));
}
 

import org.elasticsearch.search.suggest.Suggest; //导入方法依赖的package包/类
@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);
}
 

import org.elasticsearch.search.suggest.Suggest; //导入方法依赖的package包/类
private List<String> getSuggestions(PrefixSuggestionBuilder sugg) {
    Suggest suggest = node.client().prepareSuggest(TEST_INDEX).addSuggestion(sugg.field(FIELD)).execute().actionGet().getSuggest();
    List<String> found= new ArrayList<String>();
    for(Suggest.Suggestion<? extends Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option>> suggestion:suggest){
        for(Suggest.Suggestion.Entry<? extends Suggest.Suggestion.Entry.Option> entry:suggestion){
            for(Suggest.Suggestion.Entry.Option option:entry){
                found.add(option.getText().string());
            }
        }
    }
    return found;
}
 

import org.elasticsearch.search.suggest.Suggest; //导入方法依赖的package包/类
@Override
public Suggest.Suggestion<Entry> reduce(List<Suggest.Suggestion<Entry>> toReduce) {
    return reduceTo(toReduce);
}
 

import org.elasticsearch.search.suggest.Suggest; //导入方法依赖的package包/类
private Suggest.Suggestion<Suggest.Suggestion.Entry<Suggest.Suggestion.Entry.Option>> singleEntrySuggestion(String name, int size, Suggest.Suggestion.Entry<Suggest.Suggestion.Entry.Option> entry) {
    Suggest.Suggestion<Suggest.Suggestion.Entry<Suggest.Suggestion.Entry.Option>> o =  new Suggest.Suggestion<Suggest.Suggestion.Entry<Suggest.Suggestion.Entry.Option>>(name, size);
    o.addTerm(entry);
    return o;
}