honeymoose
/
OpenSearch
mirror of https://github.com/honeymoose/OpenSearch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Suggestions: Make field name mandatory ctor argument 

The field name is a required argument for all suggesters, but
it was specified via a field() setter in SuggestionBuilder so far.
This changes field name to being a mandatory constructor argument
and lets suggestion builders throw an error if field name is missing
or the empty string.
This commit is contained in:
Christoph Büscher 2016-03-01 19:57:58 +01:00
parent ef4db5c1e4
commit 30a788d87c
18 changed files with 518 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/src/main/java/org/elasticsearch/rest/action/search/RestSearchAction.java
View File

@ -256,7 +256,7 @@ public class RestSearchAction extends BaseRestHandler {
int suggestSize = request.paramAsInt("suggest_size", 5); int suggestSize = request.paramAsInt("suggest_size", 5);
String suggestMode = request.param("suggest_mode"); String suggestMode = request.param("suggest_mode");
searchSourceBuilder.suggest(new SuggestBuilder().addSuggestion(suggestField, searchSourceBuilder.suggest(new SuggestBuilder().addSuggestion(suggestField,
termSuggestion().field(suggestField) termSuggestion(suggestField)
.text(suggestText).size(suggestSize) .text(suggestText).size(suggestSize)
.suggestMode(SuggestMode.resolve(suggestMode)))); .suggestMode(SuggestMode.resolve(suggestMode))));
} }

18
core/src/main/java/org/elasticsearch/search/suggest/SuggestBuilders.java
View File

@ -29,32 +29,32 @@ import org.elasticsearch.search.suggest.term.TermSuggestionBuilder;
public abstract class SuggestBuilders { public abstract class SuggestBuilders {
/** /**
* Creates a term suggestion lookup query with the provided <code>name</code> * Creates a term suggestion lookup query with the provided <code>fieldname</code>
* *
* @return a {@link org.elasticsearch.search.suggest.term.TermSuggestionBuilder} * @return a {@link org.elasticsearch.search.suggest.term.TermSuggestionBuilder}
* instance * instance
*/ */
public static TermSuggestionBuilder termSuggestion() { public static TermSuggestionBuilder termSuggestion(String fieldname) {
return new TermSuggestionBuilder(); return new TermSuggestionBuilder(fieldname);
} }
/** /**
* Creates a phrase suggestion lookup query with the provided <code>name</code> * Creates a phrase suggestion lookup query with the provided <code>fieldname</code>
* *
* @return a {@link org.elasticsearch.search.suggest.phrase.PhraseSuggestionBuilder} * @return a {@link org.elasticsearch.search.suggest.phrase.PhraseSuggestionBuilder}
* instance * instance
*/ */
public static PhraseSuggestionBuilder phraseSuggestion() { public static PhraseSuggestionBuilder phraseSuggestion(String fieldname) {
return new PhraseSuggestionBuilder(); return new PhraseSuggestionBuilder(fieldname);
} }
/** /**
* Creates a completion suggestion lookup query with the provided <code>name</code> * Creates a completion suggestion lookup query with the provided <code>fieldname</code>
* *
* @return a {@link org.elasticsearch.search.suggest.completion.CompletionSuggestionBuilder} * @return a {@link org.elasticsearch.search.suggest.completion.CompletionSuggestionBuilder}
* instance * instance
*/ */
public static CompletionSuggestionBuilder completionSuggestion() { public static CompletionSuggestionBuilder completionSuggestion(String fieldname) {
return new CompletionSuggestionBuilder(); return new CompletionSuggestionBuilder(fieldname);
} }
} }

76
core/src/main/java/org/elasticsearch/search/suggest/SuggestionBuilder.java
View File

@ -23,6 +23,7 @@ import org.apache.lucene.analysis.Analyzer;
import org.elasticsearch.action.support.ToXContentToBytes; import org.elasticsearch.action.support.ToXContentToBytes;
import org.elasticsearch.common.ParseField; import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParseFieldMatcher; import org.elasticsearch.common.ParseFieldMatcher;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.io.stream.NamedWriteable; import org.elasticsearch.common.io.stream.NamedWriteable;
import org.elasticsearch.common.io.stream.StreamInput; import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.io.stream.StreamOutput;
@ -43,8 +44,7 @@ import java.util.Objects;
*/ */
public abstract class SuggestionBuilder<T extends SuggestionBuilder<T>> extends ToXContentToBytes implements NamedWriteable<T> { public abstract class SuggestionBuilder<T extends SuggestionBuilder<T>> extends ToXContentToBytes implements NamedWriteable<T> {
// TODO this seems mandatory and should be constructor arg protected final String fieldname;
protected String fieldname;
protected String text; protected String text;
protected String prefix; protected String prefix;
protected String regex; protected String regex;
@ -60,6 +60,31 @@ public abstract class SuggestionBuilder<T extends SuggestionBuilder<T>> extends
protected static final ParseField SIZE_FIELD = new ParseField("size"); protected static final ParseField SIZE_FIELD = new ParseField("size");
protected static final ParseField SHARDSIZE_FIELD = new ParseField("shard_size"); protected static final ParseField SHARDSIZE_FIELD = new ParseField("shard_size");
/**
* Creates a new suggestion.
* @param fieldname field to fetch the candidate suggestions from
*/
public SuggestionBuilder(String fieldname) {
Objects.requireNonNull(fieldname, "suggestion requires a field name");
if (fieldname.isEmpty()) {
throw new IllegalArgumentException("suggestion field name is empty");
}
this.fieldname = fieldname;
}
/**
* internal copy constructor that copies over all class fields from second SuggestionBuilder except field name.
*/
protected SuggestionBuilder(String fieldname, SuggestionBuilder<?> in) {
this(fieldname);
text = in.text;
prefix = in.prefix;
regex = in.regex;
analyzer = in.analyzer;
size = in.size;
shardSize = in.shardSize;
}
/** /**
* Same as in {@link SuggestBuilder#setGlobalText(String)}, but in the suggestion scope. * Same as in {@link SuggestBuilder#setGlobalText(String)}, but in the suggestion scope.
*/ */
@ -117,9 +142,7 @@ public abstract class SuggestionBuilder<T extends SuggestionBuilder<T>> extends
if (analyzer != null) { if (analyzer != null) {
builder.field(ANALYZER_FIELD.getPreferredName(), analyzer); builder.field(ANALYZER_FIELD.getPreferredName(), analyzer);
} }
if (fieldname != null) {
builder.field(FIELDNAME_FIELD.getPreferredName(), fieldname); builder.field(FIELDNAME_FIELD.getPreferredName(), fieldname);
}
if (size != null) { if (size != null) {
builder.field(SIZE_FIELD.getPreferredName(), size); builder.field(SIZE_FIELD.getPreferredName(), size);
} }
@ -139,7 +162,7 @@ public abstract class SuggestionBuilder<T extends SuggestionBuilder<T>> extends
XContentParser parser = parseContext.parser(); XContentParser parser = parseContext.parser();
ParseFieldMatcher parsefieldMatcher = parseContext.parseFieldMatcher(); ParseFieldMatcher parsefieldMatcher = parseContext.parseFieldMatcher();
XContentParser.Token token; XContentParser.Token token;
String fieldName = null; String currentFieldName = null;
String suggestText = null; String suggestText = null;
String prefix = null; String prefix = null;
String regex = null; String regex = null;
@ -147,21 +170,21 @@ public abstract class SuggestionBuilder<T extends SuggestionBuilder<T>> extends
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) { while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) { if (token == XContentParser.Token.FIELD_NAME) {
fieldName = parser.currentName(); currentFieldName = parser.currentName();
} else if (token.isValue()) { } else if (token.isValue()) {
if (parsefieldMatcher.match(fieldName, TEXT_FIELD)) { if (parsefieldMatcher.match(currentFieldName, TEXT_FIELD)) {
suggestText = parser.text(); suggestText = parser.text();
} else if (parsefieldMatcher.match(fieldName, PREFIX_FIELD)) { } else if (parsefieldMatcher.match(currentFieldName, PREFIX_FIELD)) {
prefix = parser.text(); prefix = parser.text();
} else if (parsefieldMatcher.match(fieldName, REGEX_FIELD)) { } else if (parsefieldMatcher.match(currentFieldName, REGEX_FIELD)) {
regex = parser.text(); regex = parser.text();
} else { } else {
throw new IllegalArgumentException("[suggestion] does not support [" + fieldName + "]"); throw new ParsingException(parser.getTokenLocation(), "suggestion does not support [" + currentFieldName + "]");
} }
} else if (token == XContentParser.Token.START_OBJECT) { } else if (token == XContentParser.Token.START_OBJECT) {
SuggestionBuilder<?> suggestParser = suggesters.getSuggestionPrototype(fieldName); SuggestionBuilder<?> suggestParser = suggesters.getSuggestionPrototype(currentFieldName);
if (suggestParser == null) { if (suggestParser == null) {
throw new IllegalArgumentException("Suggester[" + fieldName + "] not supported"); throw new ParsingException(parser.getTokenLocation(), "suggestion [" + currentFieldName + "] not supported");
} }
suggestionBuilder = suggestParser.innerFromXContent(parseContext); suggestionBuilder = suggestParser.innerFromXContent(parseContext);
} }
@ -182,10 +205,6 @@ public abstract class SuggestionBuilder<T extends SuggestionBuilder<T>> extends
public SuggestionContext build(QueryShardContext context) throws IOException { public SuggestionContext build(QueryShardContext context) throws IOException {
SuggestionContext suggestionContext = innerBuild(context); SuggestionContext suggestionContext = innerBuild(context);
// TODO make field mandatory in the builder, then remove this
if (suggestionContext.getField() == null) {
throw new IllegalArgumentException("The required field option is missing");
}
return suggestionContext; return suggestionContext;
} }
@ -254,20 +273,6 @@ public abstract class SuggestionBuilder<T extends SuggestionBuilder<T>> extends
return getWriteableName(); return getWriteableName();
} }
/**
* Sets from what field to fetch the candidate suggestions from. This is an
* required option and needs to be set via this setter or
* {@link org.elasticsearch.search.suggest.term.TermSuggestionBuilder#field(String)}
* method
*/
@SuppressWarnings("unchecked")
public T field(String field) {
Objects.requireNonNull(field, "fieldname must not be null");
this.fieldname = field;
return (T)this;
}
/** /**
* get the {@link #field()} parameter * get the {@link #field()} parameter
*/ */
@ -298,7 +303,7 @@ public abstract class SuggestionBuilder<T extends SuggestionBuilder<T>> extends
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public T size(int size) { public T size(int size) {
if (size <= 0) { if (size <= 0) {
throw new IllegalArgumentException("Size must be positive"); throw new IllegalArgumentException("size must be positive");
} }
this.size = size; this.size = size;
return (T)this; return (T)this;
@ -339,8 +344,8 @@ public abstract class SuggestionBuilder<T extends SuggestionBuilder<T>> extends
@Override @Override
public final T readFrom(StreamInput in) throws IOException { public final T readFrom(StreamInput in) throws IOException {
T suggestionBuilder = doReadFrom(in); String fieldname = in.readString();
suggestionBuilder.fieldname = in.readOptionalString(); T suggestionBuilder = doReadFrom(in, fieldname);
suggestionBuilder.text = in.readOptionalString(); suggestionBuilder.text = in.readOptionalString();
suggestionBuilder.prefix = in.readOptionalString(); suggestionBuilder.prefix = in.readOptionalString();
suggestionBuilder.regex = in.readOptionalString(); suggestionBuilder.regex = in.readOptionalString();
@ -353,13 +358,14 @@ public abstract class SuggestionBuilder<T extends SuggestionBuilder<T>> extends
/** /**
* Subclass should return a new instance, reading itself from the input string * Subclass should return a new instance, reading itself from the input string
* @param in the input string to read from * @param in the input string to read from
* @param fieldname the fieldname needed for ctor or concrete suggestion
*/ */
protected abstract T doReadFrom(StreamInput in) throws IOException; protected abstract T doReadFrom(StreamInput in, String fieldname) throws IOException;
@Override @Override
public final void writeTo(StreamOutput out) throws IOException { public final void writeTo(StreamOutput out) throws IOException {
out.writeString(fieldname);
doWriteTo(out); doWriteTo(out);
out.writeOptionalString(fieldname);
out.writeOptionalString(text); out.writeOptionalString(text);
out.writeOptionalString(prefix); out.writeOptionalString(prefix);
out.writeOptionalString(regex); out.writeOptionalString(regex);

10
core/src/main/java/org/elasticsearch/search/suggest/completion/CompletionSuggestionBuilder.java
View File

@ -50,7 +50,7 @@ import java.util.Set;
*/ */
public class CompletionSuggestionBuilder extends SuggestionBuilder<CompletionSuggestionBuilder> { public class CompletionSuggestionBuilder extends SuggestionBuilder<CompletionSuggestionBuilder> {
public static final CompletionSuggestionBuilder PROTOTYPE = new CompletionSuggestionBuilder(); public static final CompletionSuggestionBuilder PROTOTYPE = new CompletionSuggestionBuilder("_na_");
static final String SUGGESTION_NAME = "completion"; static final String SUGGESTION_NAME = "completion";
static final ParseField PAYLOAD_FIELD = new ParseField("payload"); static final ParseField PAYLOAD_FIELD = new ParseField("payload");
static final ParseField CONTEXTS_FIELD = new ParseField("contexts", "context"); static final ParseField CONTEXTS_FIELD = new ParseField("contexts", "context");
@ -60,6 +60,10 @@ public class CompletionSuggestionBuilder extends SuggestionBuilder<CompletionSug
private final Map<String, List<QueryContext>> queryContexts = new HashMap<>(); private final Map<String, List<QueryContext>> queryContexts = new HashMap<>();
private final Set<String> payloadFields = new HashSet<>(); private final Set<String> payloadFields = new HashSet<>();
public CompletionSuggestionBuilder(String fieldname) {
super(fieldname);
}
/** /**
* Sets the prefix to provide completions for. * Sets the prefix to provide completions for.
* The prefix gets analyzed by the suggest analyzer. * The prefix gets analyzed by the suggest analyzer.
@ -229,8 +233,8 @@ public class CompletionSuggestionBuilder extends SuggestionBuilder<CompletionSug
} }
@Override @Override
public CompletionSuggestionBuilder doReadFrom(StreamInput in) throws IOException { public CompletionSuggestionBuilder doReadFrom(StreamInput in, String fieldname) throws IOException {
CompletionSuggestionBuilder completionSuggestionBuilder = new CompletionSuggestionBuilder(); CompletionSuggestionBuilder completionSuggestionBuilder = new CompletionSuggestionBuilder(fieldname);
if (in.readBoolean()) { if (in.readBoolean()) {
int numPayloadField = in.readVInt(); int numPayloadField = in.readVInt();
for (int i = 0; i < numPayloadField; i++) { for (int i = 0; i < numPayloadField; i++) {

159
core/src/main/java/org/elasticsearch/search/suggest/phrase/PhraseSuggestionBuilder.java
View File

@ -21,6 +21,7 @@ package org.elasticsearch.search.suggest.phrase;
import org.elasticsearch.common.ParseField; import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParseFieldMatcher; import org.elasticsearch.common.ParseFieldMatcher;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.io.stream.StreamInput; import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.io.stream.StreamOutput;
import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.common.io.stream.Writeable;
@ -54,11 +55,11 @@ import java.util.Set;
/** /**
* Defines the actual suggest command for phrase suggestions ( <tt>phrase</tt>). * Defines the actual suggest command for phrase suggestions ( <tt>phrase</tt>).
*/ */
public final class PhraseSuggestionBuilder extends SuggestionBuilder<PhraseSuggestionBuilder> { public class PhraseSuggestionBuilder extends SuggestionBuilder<PhraseSuggestionBuilder> {
private static final String SUGGESTION_NAME = "phrase"; private static final String SUGGESTION_NAME = "phrase";
public static final PhraseSuggestionBuilder PROTOTYPE = new PhraseSuggestionBuilder(); public static final PhraseSuggestionBuilder PROTOTYPE = new PhraseSuggestionBuilder("_na_");
protected static final ParseField MAXERRORS_FIELD = new ParseField("max_errors"); protected static final ParseField MAXERRORS_FIELD = new ParseField("max_errors");
protected static final ParseField RWE_LIKELIHOOD_FIELD = new ParseField("real_word_error_likelihood"); protected static final ParseField RWE_LIKELIHOOD_FIELD = new ParseField("real_word_error_likelihood");
@ -93,6 +94,32 @@ public final class PhraseSuggestionBuilder extends SuggestionBuilder<PhraseSugge
private SmoothingModel model; private SmoothingModel model;
private final Map<String, List<CandidateGenerator>> generators = new HashMap<>(); private final Map<String, List<CandidateGenerator>> generators = new HashMap<>();
public PhraseSuggestionBuilder(String fieldname) {
super(fieldname);
}
/**
* internal copy constructor that copies over all class fields except for the fieldname which is
* set to the one provided in the first argument
*/
private PhraseSuggestionBuilder(String fieldname, PhraseSuggestionBuilder in) {
super(fieldname, in);
maxErrors = in.maxErrors;
separator = in.separator;
realWordErrorLikelihood = in.realWordErrorLikelihood;
confidence = in.confidence;
gramSize = in.gramSize;
forceUnigrams = in.forceUnigrams;
tokenLimit = in.tokenLimit;
preTag = in.preTag;
postTag = in.postTag;
collateQuery = in.collateQuery;
collateParams = in.collateParams;
collatePrune = in.collatePrune;
model = in.model;
generators.putAll(in.generators);
}
/** /**
* Sets the gram size for the n-gram model used for this suggester. The * Sets the gram size for the n-gram model used for this suggester. The
* default value is <tt>1</tt> corresponding to <tt>unigrams</tt>. Use * default value is <tt>1</tt> corresponding to <tt>unigrams</tt>. Use
@ -395,102 +422,114 @@ public final class PhraseSuggestionBuilder extends SuggestionBuilder<PhraseSugge
@Override @Override
protected PhraseSuggestionBuilder innerFromXContent(QueryParseContext parseContext) throws IOException { protected PhraseSuggestionBuilder innerFromXContent(QueryParseContext parseContext) throws IOException {
XContentParser parser = parseContext.parser(); XContentParser parser = parseContext.parser();
PhraseSuggestionBuilder suggestion = new PhraseSuggestionBuilder(); PhraseSuggestionBuilder tmpSuggestion = new PhraseSuggestionBuilder("_na_");
ParseFieldMatcher parseFieldMatcher = parseContext.parseFieldMatcher(); ParseFieldMatcher parseFieldMatcher = parseContext.parseFieldMatcher();
XContentParser.Token token; XContentParser.Token token;
String fieldName = null; String currentFieldName = null;
String fieldname = null;
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) { while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) { if (token == XContentParser.Token.FIELD_NAME) {
fieldName = parser.currentName(); currentFieldName = parser.currentName();
} else if (token.isValue()) { } else if (token.isValue()) {
if (parseFieldMatcher.match(fieldName, SuggestionBuilder.ANALYZER_FIELD)) { if (parseFieldMatcher.match(currentFieldName, SuggestionBuilder.ANALYZER_FIELD)) {
suggestion.analyzer(parser.text()); tmpSuggestion.analyzer(parser.text());
} else if (parseFieldMatcher.match(fieldName, SuggestionBuilder.FIELDNAME_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, SuggestionBuilder.FIELDNAME_FIELD)) {
suggestion.field(parser.text()); fieldname = parser.text();
} else if (parseFieldMatcher.match(fieldName, SuggestionBuilder.SIZE_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, SuggestionBuilder.SIZE_FIELD)) {
suggestion.size(parser.intValue()); tmpSuggestion.size(parser.intValue());
} else if (parseFieldMatcher.match(fieldName, SuggestionBuilder.SHARDSIZE_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, SuggestionBuilder.SHARDSIZE_FIELD)) {
suggestion.shardSize(parser.intValue()); tmpSuggestion.shardSize(parser.intValue());
} else if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.RWE_LIKELIHOOD_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.RWE_LIKELIHOOD_FIELD)) {
suggestion.realWordErrorLikelihood(parser.floatValue()); tmpSuggestion.realWordErrorLikelihood(parser.floatValue());
} else if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.CONFIDENCE_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.CONFIDENCE_FIELD)) {
suggestion.confidence(parser.floatValue()); tmpSuggestion.confidence(parser.floatValue());
} else if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.SEPARATOR_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.SEPARATOR_FIELD)) {
suggestion.separator(parser.text()); tmpSuggestion.separator(parser.text());
} else if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.MAXERRORS_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.MAXERRORS_FIELD)) {
suggestion.maxErrors(parser.floatValue()); tmpSuggestion.maxErrors(parser.floatValue());
} else if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.GRAMSIZE_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.GRAMSIZE_FIELD)) {
suggestion.gramSize(parser.intValue()); tmpSuggestion.gramSize(parser.intValue());
} else if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.FORCE_UNIGRAM_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.FORCE_UNIGRAM_FIELD)) {
suggestion.forceUnigrams(parser.booleanValue()); tmpSuggestion.forceUnigrams(parser.booleanValue());
} else if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.TOKEN_LIMIT_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.TOKEN_LIMIT_FIELD)) {
suggestion.tokenLimit(parser.intValue()); tmpSuggestion.tokenLimit(parser.intValue());
} else { } else {
throw new IllegalArgumentException("suggester[phrase] doesn't support field [" + fieldName + "]"); throw new ParsingException(parser.getTokenLocation(),
"suggester[phrase] doesn't support field [" + currentFieldName + "]");
} }
} else if (token == Token.START_ARRAY) { } else if (token == Token.START_ARRAY) {
if (parseFieldMatcher.match(fieldName, DirectCandidateGeneratorBuilder.DIRECT_GENERATOR_FIELD)) { if (parseFieldMatcher.match(currentFieldName, DirectCandidateGeneratorBuilder.DIRECT_GENERATOR_FIELD)) {
// for now we only have a single type of generators // for now we only have a single type of generators
while ((token = parser.nextToken()) == Token.START_OBJECT) { while ((token = parser.nextToken()) == Token.START_OBJECT) {
suggestion.addCandidateGenerator(DirectCandidateGeneratorBuilder.PROTOTYPE.fromXContent(parseContext)); tmpSuggestion.addCandidateGenerator(DirectCandidateGeneratorBuilder.PROTOTYPE.fromXContent(parseContext));
} }
} else { } else {
throw new IllegalArgumentException("suggester[phrase] doesn't support array field [" + fieldName + "]"); throw new ParsingException(parser.getTokenLocation(),
"suggester[phrase] doesn't support array field [" + currentFieldName + "]");
} }
} else if (token == Token.START_OBJECT) { } else if (token == Token.START_OBJECT) {
if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.SMOOTHING_MODEL_FIELD)) { if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.SMOOTHING_MODEL_FIELD)) {
ensureNoSmoothing(suggestion); ensureNoSmoothing(tmpSuggestion);
suggestion.smoothingModel(SmoothingModel.fromXContent(parseContext)); tmpSuggestion.smoothingModel(SmoothingModel.fromXContent(parseContext));
} else if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.HIGHLIGHT_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.HIGHLIGHT_FIELD)) {
String preTag = null; String preTag = null;
String postTag = null; String postTag = null;
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) { while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) { if (token == XContentParser.Token.FIELD_NAME) {
fieldName = parser.currentName(); currentFieldName = parser.currentName();
} else if (token.isValue()) { } else if (token.isValue()) {
if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.PRE_TAG_FIELD)) { if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.PRE_TAG_FIELD)) {
preTag = parser.text(); preTag = parser.text();
} else if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.POST_TAG_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.POST_TAG_FIELD)) {
postTag = parser.text(); postTag = parser.text();
} else { } else {
throw new IllegalArgumentException( throw new ParsingException(parser.getTokenLocation(),
"suggester[phrase][highlight] doesn't support field [" + fieldName + "]"); "suggester[phrase][highlight] doesn't support field [" + currentFieldName + "]");
} }
} }
} }
suggestion.highlight(preTag, postTag); tmpSuggestion.highlight(preTag, postTag);
} else if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.COLLATE_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.COLLATE_FIELD)) {
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) { while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) { if (token == XContentParser.Token.FIELD_NAME) {
fieldName = parser.currentName(); currentFieldName = parser.currentName();
} else if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.COLLATE_QUERY_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.COLLATE_QUERY_FIELD)) {
if (suggestion.collateQuery() != null) { if (tmpSuggestion.collateQuery() != null) {
throw new IllegalArgumentException( throw new ParsingException(parser.getTokenLocation(),
"suggester[phrase][collate] query already set, doesn't support additional [" + fieldName + "]"); "suggester[phrase][collate] query already set, doesn't support additional ["
+ currentFieldName + "]");
} }
Template template = Template.parse(parser, parseFieldMatcher); Template template = Template.parse(parser, parseFieldMatcher);
suggestion.collateQuery(template); tmpSuggestion.collateQuery(template);
} else if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.COLLATE_QUERY_PARAMS)) { } else if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.COLLATE_QUERY_PARAMS)) {
suggestion.collateParams(parser.map()); tmpSuggestion.collateParams(parser.map());
} else if (parseFieldMatcher.match(fieldName, PhraseSuggestionBuilder.COLLATE_QUERY_PRUNE)) { } else if (parseFieldMatcher.match(currentFieldName, PhraseSuggestionBuilder.COLLATE_QUERY_PRUNE)) {
if (parser.isBooleanValue()) { if (parser.isBooleanValue()) {
suggestion.collatePrune(parser.booleanValue()); tmpSuggestion.collatePrune(parser.booleanValue());
} else { } else {
throw new IllegalArgumentException("suggester[phrase][collate] prune must be either 'true' or 'false'"); throw new ParsingException(parser.getTokenLocation(),
"suggester[phrase][collate] prune must be either 'true' or 'false'");
} }
} else { } else {
throw new IllegalArgumentException( throw new ParsingException(parser.getTokenLocation(),
"suggester[phrase][collate] doesn't support field [" + fieldName + "]"); "suggester[phrase][collate] doesn't support field [" + currentFieldName + "]");
} }
} }
} else { } else {
throw new IllegalArgumentException("suggester[phrase] doesn't support array field [" + fieldName + "]"); throw new ParsingException(parser.getTokenLocation(),
"suggester[phrase] doesn't support array field [" + currentFieldName + "]");
} }
} else { } else {
throw new IllegalArgumentException("suggester[phrase] doesn't support field [" + fieldName + "]"); throw new ParsingException(parser.getTokenLocation(),
"suggester[phrase] doesn't support field [" + currentFieldName + "]");
} }
} }
return suggestion;
// now we should have field name, check and copy fields over to the suggestion builder we return
if (fieldname == null) {
throw new ParsingException(parser.getTokenLocation(), "the required field option is missing");
}
return new PhraseSuggestionBuilder(fieldname, tmpSuggestion);
} }
@ -616,8 +655,8 @@ public final class PhraseSuggestionBuilder extends SuggestionBuilder<PhraseSugge
} }
@Override @Override
public PhraseSuggestionBuilder doReadFrom(StreamInput in) throws IOException { public PhraseSuggestionBuilder doReadFrom(StreamInput in, String fieldname) throws IOException {
PhraseSuggestionBuilder builder = new PhraseSuggestionBuilder(); PhraseSuggestionBuilder builder = new PhraseSuggestionBuilder(fieldname);
builder.maxErrors = in.readFloat(); builder.maxErrors = in.readFloat();
builder.realWordErrorLikelihood = in.readFloat(); builder.realWordErrorLikelihood = in.readFloat();
builder.confidence = in.readFloat(); builder.confidence = in.readFloat();

128
core/src/main/java/org/elasticsearch/search/suggest/term/TermSuggestionBuilder.java
View File

@ -26,6 +26,7 @@ import org.apache.lucene.search.spell.LuceneLevenshteinDistance;
import org.apache.lucene.search.spell.NGramDistance; import org.apache.lucene.search.spell.NGramDistance;
import org.apache.lucene.search.spell.StringDistance; import org.apache.lucene.search.spell.StringDistance;
import org.elasticsearch.common.ParseFieldMatcher; import org.elasticsearch.common.ParseFieldMatcher;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.io.stream.StreamInput; import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.io.stream.StreamOutput;
import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.common.io.stream.Writeable;
@ -67,19 +68,40 @@ import static org.elasticsearch.search.suggest.SuggestUtils.Fields.SUGGEST_MODE;
*/ */
public class TermSuggestionBuilder extends SuggestionBuilder<TermSuggestionBuilder> { public class TermSuggestionBuilder extends SuggestionBuilder<TermSuggestionBuilder> {
public static final TermSuggestionBuilder PROTOTYPE = new TermSuggestionBuilder(); public static final TermSuggestionBuilder PROTOTYPE = new TermSuggestionBuilder("_na_");
private static final String SUGGESTION_NAME = "term"; private static final String SUGGESTION_NAME = "term";
private SuggestMode suggestMode = SuggestMode.MISSING; private SuggestMode suggestMode = SuggestMode.MISSING;
private Float accuracy = DEFAULT_ACCURACY; private float accuracy = DEFAULT_ACCURACY;
private SortBy sort = SortBy.SCORE; private SortBy sort = SortBy.SCORE;
private StringDistanceImpl stringDistance = StringDistanceImpl.INTERNAL; private StringDistanceImpl stringDistance = StringDistanceImpl.INTERNAL;
private Integer maxEdits = DEFAULT_MAX_EDITS; private int maxEdits = DEFAULT_MAX_EDITS;
private Integer maxInspections = DEFAULT_MAX_INSPECTIONS; private int maxInspections = DEFAULT_MAX_INSPECTIONS;
private Float maxTermFreq = DEFAULT_MAX_TERM_FREQ; private float maxTermFreq = DEFAULT_MAX_TERM_FREQ;
private Integer prefixLength = DEFAULT_PREFIX_LENGTH; private int prefixLength = DEFAULT_PREFIX_LENGTH;
private Integer minWordLength = DEFAULT_MIN_WORD_LENGTH; private int minWordLength = DEFAULT_MIN_WORD_LENGTH;
private Float minDocFreq = DEFAULT_MIN_DOC_FREQ; private float minDocFreq = DEFAULT_MIN_DOC_FREQ;
public TermSuggestionBuilder(String fieldname) {
super(fieldname);
}
/**
* internal copy constructor that copies over all class field except fieldname.
*/
private TermSuggestionBuilder(String fieldname, TermSuggestionBuilder in) {
super(fieldname, in);
suggestMode = in.suggestMode;
accuracy = in.accuracy;
sort = in.sort;
stringDistance = in.stringDistance;
maxEdits = in.maxEdits;
maxInspections = in.maxInspections;
maxTermFreq = in.maxTermFreq;
prefixLength = in.prefixLength;
minWordLength = in.minWordLength;
minDocFreq = in.minDocFreq;
}
/** /**
* The global suggest mode controls what suggested terms are included or * The global suggest mode controls what suggested terms are included or
@ -126,7 +148,7 @@ public class TermSuggestionBuilder extends SuggestionBuilder<TermSuggestionBuild
/** /**
* Get the accuracy setting. * Get the accuracy setting.
*/ */
public Float accuracy() { public float accuracy() {
return accuracy; return accuracy;
} }
@ -202,7 +224,7 @@ public class TermSuggestionBuilder extends SuggestionBuilder<TermSuggestionBuild
/** /**
* Get the maximum edit distance setting. * Get the maximum edit distance setting.
*/ */
public Integer maxEdits() { public int maxEdits() {
return maxEdits; return maxEdits;
} }
@ -222,7 +244,7 @@ public class TermSuggestionBuilder extends SuggestionBuilder<TermSuggestionBuild
/** /**
* Get the factor for inspecting more candidate suggestions setting. * Get the factor for inspecting more candidate suggestions setting.
*/ */
public Integer maxInspections() { public int maxInspections() {
return maxInspections; return maxInspections;
} }
@ -251,7 +273,7 @@ public class TermSuggestionBuilder extends SuggestionBuilder<TermSuggestionBuild
/** /**
* Get the maximum term frequency threshold setting. * Get the maximum term frequency threshold setting.
*/ */
public Float maxTermFreq() { public float maxTermFreq() {
return maxTermFreq; return maxTermFreq;
} }
@ -272,7 +294,7 @@ public class TermSuggestionBuilder extends SuggestionBuilder<TermSuggestionBuild
/** /**
* Get the minimum prefix length that must match setting. * Get the minimum prefix length that must match setting.
*/ */
public Integer prefixLength() { public int prefixLength() {
return prefixLength; return prefixLength;
} }
@ -291,7 +313,7 @@ public class TermSuggestionBuilder extends SuggestionBuilder<TermSuggestionBuild
/** /**
* Get the minimum length of a text term to be corrected setting. * Get the minimum length of a text term to be corrected setting.
*/ */
public Integer minWordLength() { public int minWordLength() {
return minWordLength; return minWordLength;
} }
@ -317,7 +339,7 @@ public class TermSuggestionBuilder extends SuggestionBuilder<TermSuggestionBuild
* Get the minimal threshold for the frequency of a term appearing in the * Get the minimal threshold for the frequency of a term appearing in the
* document set setting. * document set setting.
*/ */
public Float minDocFreq() { public float minDocFreq() {
return minDocFreq; return minDocFreq;
} }
@ -339,48 +361,54 @@ public class TermSuggestionBuilder extends SuggestionBuilder<TermSuggestionBuild
@Override @Override
protected TermSuggestionBuilder innerFromXContent(QueryParseContext parseContext) throws IOException { protected TermSuggestionBuilder innerFromXContent(QueryParseContext parseContext) throws IOException {
XContentParser parser = parseContext.parser(); XContentParser parser = parseContext.parser();
TermSuggestionBuilder suggestion = new TermSuggestionBuilder(); TermSuggestionBuilder tmpSuggestion = new TermSuggestionBuilder("_na_");
ParseFieldMatcher parseFieldMatcher = parseContext.parseFieldMatcher(); ParseFieldMatcher parseFieldMatcher = parseContext.parseFieldMatcher();
XContentParser.Token token; XContentParser.Token token;
String fieldName = null; String currentFieldName = null;
String fieldname = null;
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) { while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) { if (token == XContentParser.Token.FIELD_NAME) {
fieldName = parser.currentName(); currentFieldName = parser.currentName();
} else if (token.isValue()) { } else if (token.isValue()) {
if (parseFieldMatcher.match(fieldName, SuggestionBuilder.ANALYZER_FIELD)) { if (parseFieldMatcher.match(currentFieldName, SuggestionBuilder.ANALYZER_FIELD)) {
suggestion.analyzer(parser.text()); tmpSuggestion.analyzer(parser.text());
} else if (parseFieldMatcher.match(fieldName, SuggestionBuilder.FIELDNAME_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, SuggestionBuilder.FIELDNAME_FIELD)) {
suggestion.field(parser.text()); fieldname = parser.text();
} else if (parseFieldMatcher.match(fieldName, SuggestionBuilder.SIZE_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, SuggestionBuilder.SIZE_FIELD)) {
suggestion.size(parser.intValue()); tmpSuggestion.size(parser.intValue());
} else if (parseFieldMatcher.match(fieldName, SuggestionBuilder.SHARDSIZE_FIELD)) { } else if (parseFieldMatcher.match(currentFieldName, SuggestionBuilder.SHARDSIZE_FIELD)) {
suggestion.shardSize(parser.intValue()); tmpSuggestion.shardSize(parser.intValue());
} else if (parseFieldMatcher.match(fieldName, SUGGEST_MODE)) { } else if (parseFieldMatcher.match(currentFieldName, SUGGEST_MODE)) {
suggestion.suggestMode(SuggestMode.resolve(parser.text())); tmpSuggestion.suggestMode(SuggestMode.resolve(parser.text()));
} else if (parseFieldMatcher.match(fieldName, ACCURACY)) { } else if (parseFieldMatcher.match(currentFieldName, ACCURACY)) {
suggestion.accuracy(parser.floatValue()); tmpSuggestion.accuracy(parser.floatValue());
} else if (parseFieldMatcher.match(fieldName, SORT)) { } else if (parseFieldMatcher.match(currentFieldName, SORT)) {
suggestion.sort(SortBy.resolve(parser.text())); tmpSuggestion.sort(SortBy.resolve(parser.text()));
} else if (parseFieldMatcher.match(fieldName, STRING_DISTANCE)) { } else if (parseFieldMatcher.match(currentFieldName, STRING_DISTANCE)) {
suggestion.stringDistance(StringDistanceImpl.resolve(parser.text())); tmpSuggestion.stringDistance(StringDistanceImpl.resolve(parser.text()));
} else if (parseFieldMatcher.match(fieldName, MAX_EDITS)) { } else if (parseFieldMatcher.match(currentFieldName, MAX_EDITS)) {
suggestion.maxEdits(parser.intValue()); tmpSuggestion.maxEdits(parser.intValue());
} else if (parseFieldMatcher.match(fieldName, MAX_INSPECTIONS)) { } else if (parseFieldMatcher.match(currentFieldName, MAX_INSPECTIONS)) {
suggestion.maxInspections(parser.intValue()); tmpSuggestion.maxInspections(parser.intValue());
} else if (parseFieldMatcher.match(fieldName, MAX_TERM_FREQ)) { } else if (parseFieldMatcher.match(currentFieldName, MAX_TERM_FREQ)) {
suggestion.maxTermFreq(parser.floatValue()); tmpSuggestion.maxTermFreq(parser.floatValue());
} else if (parseFieldMatcher.match(fieldName, PREFIX_LENGTH)) { } else if (parseFieldMatcher.match(currentFieldName, PREFIX_LENGTH)) {
suggestion.prefixLength(parser.intValue()); tmpSuggestion.prefixLength(parser.intValue());
} else if (parseFieldMatcher.match(fieldName, MIN_WORD_LENGTH)) { } else if (parseFieldMatcher.match(currentFieldName, MIN_WORD_LENGTH)) {
suggestion.minWordLength(parser.intValue()); tmpSuggestion.minWordLength(parser.intValue());
} else if (parseFieldMatcher.match(fieldName, MIN_DOC_FREQ)) { } else if (parseFieldMatcher.match(currentFieldName, MIN_DOC_FREQ)) {
suggestion.minDocFreq(parser.floatValue()); tmpSuggestion.minDocFreq(parser.floatValue());
} }
} else { } else {
throw new IllegalArgumentException("suggester[term] doesn't support field [" + fieldName + "]"); throw new ParsingException(parser.getTokenLocation(), "suggester[term] doesn't support field [" + currentFieldName + "]");
} }
} }
return suggestion;
// now we should have field name, check and copy fields over to the suggestion builder we return
if (fieldname == null) {
throw new ParsingException(parser.getTokenLocation(), "the required field option is missing");
}
return new TermSuggestionBuilder(fieldname, tmpSuggestion);
} }
@Override @Override
@ -423,8 +451,8 @@ public class TermSuggestionBuilder extends SuggestionBuilder<TermSuggestionBuild
} }
@Override @Override
public TermSuggestionBuilder doReadFrom(StreamInput in) throws IOException { public TermSuggestionBuilder doReadFrom(StreamInput in, String fieldname) throws IOException {
TermSuggestionBuilder builder = new TermSuggestionBuilder(); TermSuggestionBuilder builder = new TermSuggestionBuilder(fieldname);
builder.suggestMode = SuggestMode.PROTOTYPE.readFrom(in); builder.suggestMode = SuggestMode.PROTOTYPE.readFrom(in);
builder.accuracy = in.readFloat(); builder.accuracy = in.readFloat();
builder.sort = SortBy.PROTOTYPE.readFrom(in); builder.sort = SortBy.PROTOTYPE.readFrom(in);

4
core/src/test/java/org/elasticsearch/index/suggest/stats/SuggestStatsIT.java
View File

@ -139,9 +139,9 @@ public class SuggestStatsIT extends ESIntegTestCase {
private SuggestRequestBuilder addSuggestions(SuggestRequestBuilder request, int i) { private SuggestRequestBuilder addSuggestions(SuggestRequestBuilder request, int i) {
for (int s = 0; s < randomIntBetween(2, 10); s++) { for (int s = 0; s < randomIntBetween(2, 10); s++) {
if (randomBoolean()) { if (randomBoolean()) {
request.addSuggestion("s" + s, new PhraseSuggestionBuilder().field("f").text("test" + i + " test" + (i - 1))); request.addSuggestion("s" + s, new PhraseSuggestionBuilder("f").text("test" + i + " test" + (i - 1)));
} else { } else {
request.addSuggestion("s" + s, new TermSuggestionBuilder().field("f").text("test" + i)); request.addSuggestion("s" + s, new TermSuggestionBuilder("f").text("test" + i));
} }
} }
return request; return request;

2
core/src/test/java/org/elasticsearch/indices/IndicesOptionsIntegrationIT.java
View File

@ -749,7 +749,7 @@ public class IndicesOptionsIntegrationIT extends ESIntegTestCase {
} }
private static SuggestRequestBuilder suggest(String... indices) { private static SuggestRequestBuilder suggest(String... indices) {
return client().prepareSuggest(indices).addSuggestion("name", SuggestBuilders.termSuggestion().field("a")); return client().prepareSuggest(indices).addSuggestion("name", SuggestBuilders.termSuggestion("a"));
} }
private static GetAliasesRequestBuilder getAliases(String... indices) { private static GetAliasesRequestBuilder getAliases(String... indices) {

2
core/src/test/java/org/elasticsearch/search/builder/SearchSourceBuilderTests.java
View File

@ -412,7 +412,7 @@ public class SearchSourceBuilderTests extends ESTestCase {
// NORELEASE need a random suggest builder method // NORELEASE need a random suggest builder method
builder.suggest(new SuggestBuilder().setGlobalText(randomAsciiOfLengthBetween(1, 5)).addSuggestion( builder.suggest(new SuggestBuilder().setGlobalText(randomAsciiOfLengthBetween(1, 5)).addSuggestion(
randomAsciiOfLengthBetween(1, 5), randomAsciiOfLengthBetween(1, 5),
SuggestBuilders.termSuggestion())); SuggestBuilders.termSuggestion(randomAsciiOfLengthBetween(1, 5))));
} }
if (randomBoolean()) { if (randomBoolean()) {
// NORELEASE need a random inner hits builder method // NORELEASE need a random inner hits builder method

12
core/src/test/java/org/elasticsearch/search/suggest/AbstractSuggestionBuilderTestCase.java
View File

@ -135,7 +135,6 @@ public abstract class AbstractSuggestionBuilderTestCase<SB extends SuggestionBui
*/ */
protected SB randomTestBuilder() { protected SB randomTestBuilder() {
SB randomSuggestion = randomSuggestionBuilder(); SB randomSuggestion = randomSuggestionBuilder();
randomSuggestion.field(randomAsciiOfLengthBetween(2, 20));
maybeSet(randomSuggestion::text, randomAsciiOfLengthBetween(2, 20)); maybeSet(randomSuggestion::text, randomAsciiOfLengthBetween(2, 20));
maybeSet(randomSuggestion::prefix, randomAsciiOfLengthBetween(2, 20)); maybeSet(randomSuggestion::prefix, randomAsciiOfLengthBetween(2, 20));
maybeSet(randomSuggestion::regex, randomAsciiOfLengthBetween(2, 20)); maybeSet(randomSuggestion::regex, randomAsciiOfLengthBetween(2, 20));
@ -309,9 +308,9 @@ public abstract class AbstractSuggestionBuilderTestCase<SB extends SuggestionBui
private SB mutate(SB firstBuilder) throws IOException { private SB mutate(SB firstBuilder) throws IOException {
SB mutation = serializedCopy(firstBuilder); SB mutation = serializedCopy(firstBuilder);
assertNotSame(mutation, firstBuilder); assertNotSame(mutation, firstBuilder);
// change ither one of the shared SuggestionBuilder parameters, or delegate to the specific tests mutate method
if (randomBoolean()) { if (randomBoolean()) {
// change one of the common SuggestionBuilder parameters switch (randomIntBetween(0, 5)) {
switch (randomIntBetween(0, 6)) {
case 0: case 0:
mutation.text(randomValueOtherThan(mutation.text(), () -> randomAsciiOfLengthBetween(2, 20))); mutation.text(randomValueOtherThan(mutation.text(), () -> randomAsciiOfLengthBetween(2, 20)));
break; break;
@ -322,15 +321,12 @@ public abstract class AbstractSuggestionBuilderTestCase<SB extends SuggestionBui
mutation.regex(randomValueOtherThan(mutation.regex(), () -> randomAsciiOfLengthBetween(2, 20))); mutation.regex(randomValueOtherThan(mutation.regex(), () -> randomAsciiOfLengthBetween(2, 20)));
break; break;
case 3: case 3:
mutation.field(randomValueOtherThan(mutation.field(), () -> randomAsciiOfLengthBetween(2, 20)));
break;
case 4:
mutation.analyzer(randomValueOtherThan(mutation.analyzer(), () -> randomAsciiOfLengthBetween(2, 20))); mutation.analyzer(randomValueOtherThan(mutation.analyzer(), () -> randomAsciiOfLengthBetween(2, 20)));
break; break;
case 5: case 4:
mutation.size(randomValueOtherThan(mutation.size(), () -> randomIntBetween(1, 20))); mutation.size(randomValueOtherThan(mutation.size(), () -> randomIntBetween(1, 20)));
break; break;
case 6: case 5:
mutation.shardSize(randomValueOtherThan(mutation.shardSize(), () -> randomIntBetween(1, 20))); mutation.shardSize(randomValueOtherThan(mutation.shardSize(), () -> randomIntBetween(1, 20)));
break; break;
} }

60
core/src/test/java/org/elasticsearch/search/suggest/CompletionSuggestSearchIT.java
View File

@ -105,7 +105,7 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
)); ));
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
assertSuggestions("foo", prefix, "suggestion10", "suggestion9", "suggestion8", "suggestion7", "suggestion6"); assertSuggestions("foo", prefix, "suggestion10", "suggestion9", "suggestion8", "suggestion7", "suggestion6");
} }
@ -126,7 +126,7 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
)); ));
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).regex("sugg.*es"); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).regex("sugg.*es");
assertSuggestions("foo", prefix, "sugg10estion", "sugg9estion", "sugg8estion", "sugg7estion", "sugg6estion"); assertSuggestions("foo", prefix, "sugg10estion", "sugg9estion", "sugg8estion", "sugg7estion", "sugg6estion");
} }
@ -147,7 +147,7 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
)); ));
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg", Fuzziness.ONE); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg", Fuzziness.ONE);
assertSuggestions("foo", prefix, "sugxgestion10", "sugxgestion9", "sugxgestion8", "sugxgestion7", "sugxgestion6"); assertSuggestions("foo", prefix, "sugxgestion10", "sugxgestion9", "sugxgestion8", "sugxgestion7", "sugxgestion6");
} }
@ -173,13 +173,13 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
for (int i = 0; i < size; i++) { for (int i = 0; i < size; i++) {
outputs[i] = "suggestion" + (numDocs - i); outputs[i] = "suggestion" + (numDocs - i);
} }
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sug").size(size); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sug").size(size);
assertSuggestions("foo", prefix, outputs); assertSuggestions("foo", prefix, outputs);
CompletionSuggestionBuilder regex = SuggestBuilders.completionSuggestion().field(FIELD).regex("su[g|s]g").size(size); CompletionSuggestionBuilder regex = SuggestBuilders.completionSuggestion(FIELD).regex("su[g|s]g").size(size);
assertSuggestions("foo", regex, outputs); assertSuggestions("foo", regex, outputs);
CompletionSuggestionBuilder fuzzyPrefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg", Fuzziness.ONE).size(size); CompletionSuggestionBuilder fuzzyPrefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg", Fuzziness.ONE).size(size);
assertSuggestions("foo", fuzzyPrefix, outputs); assertSuggestions("foo", fuzzyPrefix, outputs);
} }
@ -198,7 +198,7 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"). CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg").
size(numDocs).payload(Collections.singletonList("count")); size(numDocs).payload(Collections.singletonList("count"));
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", prefix).execute().actionGet(); SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", prefix).execute().actionGet();
assertNoFailures(suggestResponse); assertNoFailures(suggestResponse);
@ -245,7 +245,7 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
client().prepareIndex(INDEX, TYPE, "2").setSource(FIELD, "suggestion") client().prepareIndex(INDEX, TYPE, "2").setSource(FIELD, "suggestion")
); );
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg") CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg")
.payload(Collections.singletonList("test_field")); .payload(Collections.singletonList("test_field"));
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", prefix).execute().actionGet(); SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", prefix).execute().actionGet();
assertNoFailures(suggestResponse); assertNoFailures(suggestResponse);
@ -283,7 +283,7 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
indexRequestBuilders.add(client().prepareIndex(INDEX, TYPE, "2").setSource(source)); indexRequestBuilders.add(client().prepareIndex(INDEX, TYPE, "2").setSource(source));
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg") CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg")
.payload(Arrays.asList("title", "count")); .payload(Arrays.asList("title", "count"));
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", prefix).execute().actionGet(); SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", prefix).execute().actionGet();
assertNoFailures(suggestResponse); assertNoFailures(suggestResponse);
@ -334,7 +334,7 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
payloadFields.add("test_field" + i); payloadFields.add("test_field" + i);
} }
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg") CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg")
.size(suggestionSize).payload(payloadFields); .size(suggestionSize).payload(payloadFields);
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", prefix).execute().actionGet(); SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", prefix).execute().actionGet();
assertNoFailures(suggestResponse); assertNoFailures(suggestResponse);
@ -435,7 +435,7 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
refresh(); refresh();
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("testSuggestions", SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("testSuggestions",
new CompletionSuggestionBuilder().field(FIELD).text("test").size(10) new CompletionSuggestionBuilder(FIELD).text("test").size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(suggestResponse, "testSuggestions", "testing"); assertSuggestions(suggestResponse, "testSuggestions", "testing");
@ -636,7 +636,7 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
assertThat(putMappingResponse.isAcknowledged(), is(true)); assertThat(putMappingResponse.isAcknowledged(), is(true));
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("suggs", SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("suggs",
SuggestBuilders.completionSuggestion().field(FIELD + ".suggest").text("f").size(10) SuggestBuilders.completionSuggestion(FIELD + ".suggest").text("f").size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(suggestResponse, "suggs"); assertSuggestions(suggestResponse, "suggs");
@ -644,7 +644,7 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
ensureGreen(INDEX); ensureGreen(INDEX);
SuggestResponse afterReindexingResponse = client().prepareSuggest(INDEX).addSuggestion("suggs", SuggestResponse afterReindexingResponse = client().prepareSuggest(INDEX).addSuggestion("suggs",
SuggestBuilders.completionSuggestion().field(FIELD + ".suggest").text("f").size(10) SuggestBuilders.completionSuggestion(FIELD + ".suggest").text("f").size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(afterReindexingResponse, "suggs", "Foo Fighters"); assertSuggestions(afterReindexingResponse, "suggs", "Foo Fighters");
} }
@ -661,12 +661,12 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
refresh(); refresh();
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo",
SuggestBuilders.completionSuggestion().field(FIELD).prefix("Nirv").size(10) SuggestBuilders.completionSuggestion(FIELD).prefix("Nirv").size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(suggestResponse, false, "foo", "Nirvana"); assertSuggestions(suggestResponse, false, "foo", "Nirvana");
suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo",
SuggestBuilders.completionSuggestion().field(FIELD).prefix("Nirw", Fuzziness.ONE).size(10) SuggestBuilders.completionSuggestion(FIELD).prefix("Nirw", Fuzziness.ONE).size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(suggestResponse, false, "foo", "Nirvana"); assertSuggestions(suggestResponse, false, "foo", "Nirvana");
} }
@ -684,13 +684,13 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
// edit distance 1 // edit distance 1
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo",
SuggestBuilders.completionSuggestion().field(FIELD).prefix("Norw", Fuzziness.ONE).size(10) SuggestBuilders.completionSuggestion(FIELD).prefix("Norw", Fuzziness.ONE).size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(suggestResponse, false, "foo"); assertSuggestions(suggestResponse, false, "foo");
// edit distance 2 // edit distance 2
suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo",
SuggestBuilders.completionSuggestion().field(FIELD).prefix("Norw", Fuzziness.TWO).size(10) SuggestBuilders.completionSuggestion(FIELD).prefix("Norw", Fuzziness.TWO).size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(suggestResponse, false, "foo", "Nirvana"); assertSuggestions(suggestResponse, false, "foo", "Nirvana");
} }
@ -707,12 +707,12 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
refresh(); refresh();
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo",
SuggestBuilders.completionSuggestion().field(FIELD).prefix("Nriv", FuzzyOptions.builder().setTranspositions(false).build()).size(10) SuggestBuilders.completionSuggestion(FIELD).prefix("Nriv", FuzzyOptions.builder().setTranspositions(false).build()).size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(suggestResponse, false, "foo"); assertSuggestions(suggestResponse, false, "foo");
suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo",
SuggestBuilders.completionSuggestion().field(FIELD).prefix("Nriv", Fuzziness.ONE).size(10) SuggestBuilders.completionSuggestion(FIELD).prefix("Nriv", Fuzziness.ONE).size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(suggestResponse, false, "foo", "Nirvana"); assertSuggestions(suggestResponse, false, "foo", "Nirvana");
} }
@ -729,12 +729,12 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
refresh(); refresh();
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo",
SuggestBuilders.completionSuggestion().field(FIELD).prefix("Nriva", FuzzyOptions.builder().setFuzzyMinLength(6).build()).size(10) SuggestBuilders.completionSuggestion(FIELD).prefix("Nriva", FuzzyOptions.builder().setFuzzyMinLength(6).build()).size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(suggestResponse, false, "foo"); assertSuggestions(suggestResponse, false, "foo");
suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo",
SuggestBuilders.completionSuggestion().field(FIELD).prefix("Nrivan", FuzzyOptions.builder().setFuzzyMinLength(6).build()).size(10) SuggestBuilders.completionSuggestion(FIELD).prefix("Nrivan", FuzzyOptions.builder().setFuzzyMinLength(6).build()).size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(suggestResponse, false, "foo", "Nirvana"); assertSuggestions(suggestResponse, false, "foo", "Nirvana");
} }
@ -751,12 +751,12 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
refresh(); refresh();
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo",
SuggestBuilders.completionSuggestion().field(FIELD).prefix("Nirw", FuzzyOptions.builder().setFuzzyPrefixLength(4).build()).size(10) SuggestBuilders.completionSuggestion(FIELD).prefix("Nirw", FuzzyOptions.builder().setFuzzyPrefixLength(4).build()).size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(suggestResponse, false, "foo"); assertSuggestions(suggestResponse, false, "foo");
suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo",
SuggestBuilders.completionSuggestion().field(FIELD).prefix("Nirvo", FuzzyOptions.builder().setFuzzyPrefixLength(4).build()).size(10) SuggestBuilders.completionSuggestion(FIELD).prefix("Nirvo", FuzzyOptions.builder().setFuzzyPrefixLength(4).build()).size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(suggestResponse, false, "foo", "Nirvana"); assertSuggestions(suggestResponse, false, "foo", "Nirvana");
} }
@ -774,18 +774,18 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
// suggestion with a character, which needs unicode awareness // suggestion with a character, which needs unicode awareness
org.elasticsearch.search.suggest.completion.CompletionSuggestionBuilder completionSuggestionBuilder = org.elasticsearch.search.suggest.completion.CompletionSuggestionBuilder completionSuggestionBuilder =
SuggestBuilders.completionSuggestion().field(FIELD).prefix("öööи", FuzzyOptions.builder().setUnicodeAware(true).build()).size(10); SuggestBuilders.completionSuggestion(FIELD).prefix("öööи", FuzzyOptions.builder().setUnicodeAware(true).build()).size(10);
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", completionSuggestionBuilder).execute().actionGet(); SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", completionSuggestionBuilder).execute().actionGet();
assertSuggestions(suggestResponse, false, "foo", "ööööö"); assertSuggestions(suggestResponse, false, "foo", "ööööö");
// removing unicode awareness leads to no result // removing unicode awareness leads to no result
completionSuggestionBuilder = SuggestBuilders.completionSuggestion().field(FIELD).prefix("öööи", FuzzyOptions.builder().setUnicodeAware(false).build()).size(10); completionSuggestionBuilder = SuggestBuilders.completionSuggestion(FIELD).prefix("öööи", FuzzyOptions.builder().setUnicodeAware(false).build()).size(10);
suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", completionSuggestionBuilder).execute().actionGet(); suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", completionSuggestionBuilder).execute().actionGet();
assertSuggestions(suggestResponse, false, "foo"); assertSuggestions(suggestResponse, false, "foo");
// increasing edit distance instead of unicode awareness works again, as this is only a single character // increasing edit distance instead of unicode awareness works again, as this is only a single character
completionSuggestionBuilder = SuggestBuilders.completionSuggestion().field(FIELD).prefix("öööи", FuzzyOptions.builder().setUnicodeAware(false).setFuzziness(Fuzziness.TWO).build()).size(10); completionSuggestionBuilder = SuggestBuilders.completionSuggestion(FIELD).prefix("öööи", FuzzyOptions.builder().setUnicodeAware(false).setFuzziness(Fuzziness.TWO).build()).size(10);
suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", completionSuggestionBuilder).execute().actionGet(); suggestResponse = client().prepareSuggest(INDEX).addSuggestion("foo", completionSuggestionBuilder).execute().actionGet();
assertSuggestions(suggestResponse, false, "foo", "ööööö"); assertSuggestions(suggestResponse, false, "foo", "ööööö");
} }
@ -815,8 +815,8 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
refresh(); refresh();
ensureGreen(); ensureGreen();
// load the fst index into ram // load the fst index into ram
client().prepareSuggest(INDEX).addSuggestion("foo", SuggestBuilders.completionSuggestion().field(FIELD).prefix("f")).get(); client().prepareSuggest(INDEX).addSuggestion("foo", SuggestBuilders.completionSuggestion(FIELD).prefix("f")).get();
client().prepareSuggest(INDEX).addSuggestion("foo", SuggestBuilders.completionSuggestion().field(otherField).prefix("f")).get(); client().prepareSuggest(INDEX).addSuggestion("foo", SuggestBuilders.completionSuggestion(otherField).prefix("f")).get();
// Get all stats // Get all stats
IndicesStatsResponse indicesStatsResponse = client().admin().indices().prepareStats(INDEX).setIndices(INDEX).setCompletion(true).get(); IndicesStatsResponse indicesStatsResponse = client().admin().indices().prepareStats(INDEX).setIndices(INDEX).setCompletion(true).get();
@ -921,14 +921,14 @@ public class CompletionSuggestSearchIT extends ESIntegTestCase {
} }
public void assertSuggestions(String suggestion, String... suggestions) { public void assertSuggestions(String suggestion, String... suggestions) {
String suggestionName = RandomStrings.randomAsciiOfLength(random(), 10); String suggestionName = RandomStrings.randomAsciiOfLength(random(), 10);
CompletionSuggestionBuilder suggestionBuilder = SuggestBuilders.completionSuggestion().field(FIELD).text(suggestion).size(10); CompletionSuggestionBuilder suggestionBuilder = SuggestBuilders.completionSuggestion(FIELD).text(suggestion).size(10);
assertSuggestions(suggestionName, suggestionBuilder, suggestions); assertSuggestions(suggestionName, suggestionBuilder, suggestions);
} }
public void assertSuggestionsNotInOrder(String suggestString, String... suggestions) { public void assertSuggestionsNotInOrder(String suggestString, String... suggestions) {
String suggestionName = RandomStrings.randomAsciiOfLength(random(), 10); String suggestionName = RandomStrings.randomAsciiOfLength(random(), 10);
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion(suggestionName, SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion(suggestionName,
SuggestBuilders.completionSuggestion().field(FIELD).text(suggestString).size(10) SuggestBuilders.completionSuggestion(FIELD).text(suggestString).size(10)
).execute().actionGet(); ).execute().actionGet();
assertSuggestions(suggestResponse, false, suggestionName, suggestions); assertSuggestions(suggestResponse, false, suggestionName, suggestions);

46
core/src/test/java/org/elasticsearch/search/suggest/ContextCompletionSuggestSearchIT.java
View File

@ -90,7 +90,7 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
ensureYellow(INDEX); ensureYellow(INDEX);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5"); assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5");
} }
@ -122,7 +122,7 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
ensureYellow(INDEX); ensureYellow(INDEX);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).regex("sugg.*es"); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).regex("sugg.*es");
assertSuggestions("foo", prefix, "sugg9estion", "sugg8estion", "sugg7estion", "sugg6estion", "sugg5estion"); assertSuggestions("foo", prefix, "sugg9estion", "sugg8estion", "sugg7estion", "sugg6estion", "sugg5estion");
} }
@ -154,7 +154,7 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
ensureYellow(INDEX); ensureYellow(INDEX);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg", Fuzziness.ONE); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg", Fuzziness.ONE);
assertSuggestions("foo", prefix, "sugxgestion9", "sugxgestion8", "sugxgestion7", "sugxgestion6", "sugxgestion5"); assertSuggestions("foo", prefix, "sugxgestion9", "sugxgestion8", "sugxgestion7", "sugxgestion6", "sugxgestion5");
} }
@ -179,7 +179,7 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
ensureYellow(INDEX); ensureYellow(INDEX);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg") CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg")
.categoryContexts("cat", CategoryQueryContext.builder().setCategory("cat0").build()); .categoryContexts("cat", CategoryQueryContext.builder().setCategory("cat0").build());
assertSuggestions("foo", prefix, "suggestion8", "suggestion6", "suggestion4", "suggestion2", "suggestion0"); assertSuggestions("foo", prefix, "suggestion8", "suggestion6", "suggestion4", "suggestion2", "suggestion0");
@ -206,7 +206,7 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
ensureYellow(INDEX); ensureYellow(INDEX);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg") CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg")
.categoryContexts("cat", .categoryContexts("cat",
CategoryQueryContext.builder().setCategory("cat0").setBoost(3).build(), CategoryQueryContext.builder().setCategory("cat0").setBoost(3).build(),
CategoryQueryContext.builder().setCategory("cat1").build() CategoryQueryContext.builder().setCategory("cat1").build()
@ -236,7 +236,7 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
ensureYellow(INDEX); ensureYellow(INDEX);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5"); assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5");
} }
@ -266,17 +266,17 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
ensureYellow(INDEX); ensureYellow(INDEX);
// filter only on context cat // filter only on context cat
CompletionSuggestionBuilder catFilterSuggest = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder catFilterSuggest = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
catFilterSuggest.categoryContexts("cat", CategoryQueryContext.builder().setCategory("cat0").build()); catFilterSuggest.categoryContexts("cat", CategoryQueryContext.builder().setCategory("cat0").build());
assertSuggestions("foo", catFilterSuggest, "suggestion8", "suggestion6", "suggestion4", "suggestion2", "suggestion0"); assertSuggestions("foo", catFilterSuggest, "suggestion8", "suggestion6", "suggestion4", "suggestion2", "suggestion0");
// filter only on context type // filter only on context type
CompletionSuggestionBuilder typeFilterSuggest = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder typeFilterSuggest = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
typeFilterSuggest.categoryContexts("type", CategoryQueryContext.builder().setCategory("type2").build(), typeFilterSuggest.categoryContexts("type", CategoryQueryContext.builder().setCategory("type2").build(),
CategoryQueryContext.builder().setCategory("type1").build()); CategoryQueryContext.builder().setCategory("type1").build());
assertSuggestions("foo", typeFilterSuggest, "suggestion9", "suggestion6", "suggestion5", "suggestion2", "suggestion1"); assertSuggestions("foo", typeFilterSuggest, "suggestion9", "suggestion6", "suggestion5", "suggestion2", "suggestion1");
CompletionSuggestionBuilder multiContextFilterSuggest = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder multiContextFilterSuggest = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
// query context order should never matter // query context order should never matter
if (randomBoolean()) { if (randomBoolean()) {
multiContextFilterSuggest.categoryContexts("type", CategoryQueryContext.builder().setCategory("type2").build()); multiContextFilterSuggest.categoryContexts("type", CategoryQueryContext.builder().setCategory("type2").build());
@ -314,21 +314,21 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
ensureYellow(INDEX); ensureYellow(INDEX);
// boost only on context cat // boost only on context cat
CompletionSuggestionBuilder catBoostSuggest = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder catBoostSuggest = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
catBoostSuggest.categoryContexts("cat", catBoostSuggest.categoryContexts("cat",
CategoryQueryContext.builder().setCategory("cat0").setBoost(3).build(), CategoryQueryContext.builder().setCategory("cat0").setBoost(3).build(),
CategoryQueryContext.builder().setCategory("cat1").build()); CategoryQueryContext.builder().setCategory("cat1").build());
assertSuggestions("foo", catBoostSuggest, "suggestion8", "suggestion6", "suggestion4", "suggestion9", "suggestion2"); assertSuggestions("foo", catBoostSuggest, "suggestion8", "suggestion6", "suggestion4", "suggestion9", "suggestion2");
// boost only on context type // boost only on context type
CompletionSuggestionBuilder typeBoostSuggest = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder typeBoostSuggest = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
typeBoostSuggest.categoryContexts("type", typeBoostSuggest.categoryContexts("type",
CategoryQueryContext.builder().setCategory("type2").setBoost(2).build(), CategoryQueryContext.builder().setCategory("type2").setBoost(2).build(),
CategoryQueryContext.builder().setCategory("type1").setBoost(4).build()); CategoryQueryContext.builder().setCategory("type1").setBoost(4).build());
assertSuggestions("foo", typeBoostSuggest, "suggestion9", "suggestion5", "suggestion6", "suggestion1", "suggestion2"); assertSuggestions("foo", typeBoostSuggest, "suggestion9", "suggestion5", "suggestion6", "suggestion1", "suggestion2");
// boost on both contexts // boost on both contexts
CompletionSuggestionBuilder multiContextBoostSuggest = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder multiContextBoostSuggest = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
// query context order should never matter // query context order should never matter
if (randomBoolean()) { if (randomBoolean()) {
multiContextBoostSuggest.categoryContexts("type", multiContextBoostSuggest.categoryContexts("type",
@ -375,7 +375,7 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
ensureYellow(INDEX); ensureYellow(INDEX);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5"); assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5");
} }
@ -406,7 +406,7 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
ensureYellow(INDEX); ensureYellow(INDEX);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
assertSuggestions("foo", prefix, "suggestion0", "suggestion1", "suggestion2", "suggestion3", "suggestion4"); assertSuggestions("foo", prefix, "suggestion0", "suggestion1", "suggestion2", "suggestion3", "suggestion4");
} }
@ -432,7 +432,7 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
ensureYellow(INDEX); ensureYellow(INDEX);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5"); assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5");
} }
@ -459,10 +459,10 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
ensureYellow(INDEX); ensureYellow(INDEX);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5"); assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5");
CompletionSuggestionBuilder geoFilteringPrefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg") CompletionSuggestionBuilder geoFilteringPrefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg")
.geoContexts("geo", GeoQueryContext.builder().setGeoPoint(new GeoPoint(geoPoints[0])).build()); .geoContexts("geo", GeoQueryContext.builder().setGeoPoint(new GeoPoint(geoPoints[0])).build());
assertSuggestions("foo", geoFilteringPrefix, "suggestion8", "suggestion6", "suggestion4", "suggestion2", "suggestion0"); assertSuggestions("foo", geoFilteringPrefix, "suggestion8", "suggestion6", "suggestion4", "suggestion2", "suggestion0");
@ -491,12 +491,12 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
ensureYellow(INDEX); ensureYellow(INDEX);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5"); assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5");
GeoQueryContext context1 = GeoQueryContext.builder().setGeoPoint(geoPoints[0]).setBoost(2).build(); GeoQueryContext context1 = GeoQueryContext.builder().setGeoPoint(geoPoints[0]).setBoost(2).build();
GeoQueryContext context2 = GeoQueryContext.builder().setGeoPoint(geoPoints[1]).build(); GeoQueryContext context2 = GeoQueryContext.builder().setGeoPoint(geoPoints[1]).build();
CompletionSuggestionBuilder geoBoostingPrefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg") CompletionSuggestionBuilder geoBoostingPrefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg")
.geoContexts("geo", context1, context2); .geoContexts("geo", context1, context2);
assertSuggestions("foo", geoBoostingPrefix, "suggestion8", "suggestion6", "suggestion4", "suggestion9", "suggestion7"); assertSuggestions("foo", geoBoostingPrefix, "suggestion8", "suggestion6", "suggestion4", "suggestion9", "suggestion7");
@ -527,7 +527,7 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
ensureYellow(INDEX); ensureYellow(INDEX);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg") CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg")
.geoContexts("geo", GeoQueryContext.builder().setGeoPoint(new GeoPoint(52.2263, 4.543)).build()); .geoContexts("geo", GeoQueryContext.builder().setGeoPoint(new GeoPoint(52.2263, 4.543)).build());
assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5"); assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5");
} }
@ -565,10 +565,10 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
} }
indexRandom(true, indexRequestBuilders); indexRandom(true, indexRequestBuilders);
ensureYellow(INDEX); ensureYellow(INDEX);
CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg"); CompletionSuggestionBuilder prefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg");
assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5"); assertSuggestions("foo", prefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5");
CompletionSuggestionBuilder geoNeighbourPrefix = SuggestBuilders.completionSuggestion().field(FIELD).prefix("sugg") CompletionSuggestionBuilder geoNeighbourPrefix = SuggestBuilders.completionSuggestion(FIELD).prefix("sugg")
.geoContexts("geo", GeoQueryContext.builder().setGeoPoint(GeoPoint.fromGeohash(geohash)).build()); .geoContexts("geo", GeoQueryContext.builder().setGeoPoint(GeoPoint.fromGeohash(geohash)).build());
assertSuggestions("foo", geoNeighbourPrefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5"); assertSuggestions("foo", geoNeighbourPrefix, "suggestion9", "suggestion8", "suggestion7", "suggestion6", "suggestion5");
@ -625,7 +625,7 @@ public class ContextCompletionSuggestSearchIT extends ESIntegTestCase {
refresh(); refresh();
String suggestionName = randomAsciiOfLength(10); String suggestionName = randomAsciiOfLength(10);
CompletionSuggestionBuilder context = SuggestBuilders.completionSuggestion().field(FIELD).text("h").size(10) CompletionSuggestionBuilder context = SuggestBuilders.completionSuggestion(FIELD).text("h").size(10)
.geoContexts("st", GeoQueryContext.builder().setGeoPoint(new GeoPoint(52.52, 13.4)).build()); .geoContexts("st", GeoQueryContext.builder().setGeoPoint(new GeoPoint(52.52, 13.4)).build());
SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion(suggestionName, context).get(); SuggestResponse suggestResponse = client().prepareSuggest(INDEX).addSuggestion(suggestionName, context).get();

22
core/src/test/java/org/elasticsearch/search/suggest/CustomSuggesterSearchIT.java
View File

@ -86,17 +86,15 @@ public class CustomSuggesterSearchIT extends ESIntegTestCase {
public final static CustomSuggestionBuilder PROTOTYPE = new CustomSuggestionBuilder("_na_", "_na_"); public final static CustomSuggestionBuilder PROTOTYPE = new CustomSuggestionBuilder("_na_", "_na_");
private String randomField;
private String randomSuffix; private String randomSuffix;
public CustomSuggestionBuilder(String randomField, String randomSuffix) { public CustomSuggestionBuilder(String randomField, String randomSuffix) {
this.randomField = randomField; super(randomField);
this.randomSuffix = randomSuffix; this.randomSuffix = randomSuffix;
} }
@Override @Override
protected XContentBuilder innerToXContent(XContentBuilder builder, Params params) throws IOException { protected XContentBuilder innerToXContent(XContentBuilder builder, Params params) throws IOException {
builder.field("field", randomField);
builder.field("suffix", randomSuffix); builder.field("suffix", randomSuffix);
return builder; return builder;
} }
@ -108,39 +106,39 @@ public class CustomSuggesterSearchIT extends ESIntegTestCase {
@Override @Override
public void doWriteTo(StreamOutput out) throws IOException { public void doWriteTo(StreamOutput out) throws IOException {
out.writeString(randomField);
out.writeString(randomSuffix); out.writeString(randomSuffix);
} }
@Override @Override
public CustomSuggestionBuilder doReadFrom(StreamInput in) throws IOException { public CustomSuggestionBuilder doReadFrom(StreamInput in, String fieldname) throws IOException {
return new CustomSuggestionBuilder(in.readString(), in.readString()); return new CustomSuggestionBuilder(fieldname, in.readString());
} }
@Override @Override
protected boolean doEquals(CustomSuggestionBuilder other) { protected boolean doEquals(CustomSuggestionBuilder other) {
return Objects.equals(randomField, other.randomField) && return Objects.equals(randomSuffix, other.randomSuffix);
Objects.equals(randomSuffix, other.randomSuffix);
} }
@Override @Override
protected int doHashCode() { protected int doHashCode() {
return Objects.hash(randomField, randomSuffix); return Objects.hash(randomSuffix);
} }
@Override @Override
protected CustomSuggestionBuilder innerFromXContent(QueryParseContext parseContext) protected CustomSuggestionBuilder innerFromXContent(QueryParseContext parseContext)
throws IOException { throws IOException {
// TODO some parsing // TODO some parsing
return new CustomSuggestionBuilder(randomField, randomSuffix); return new CustomSuggestionBuilder(field(), randomSuffix);
} }
@Override @Override
protected SuggestionContext innerBuild(QueryShardContext context) throws IOException { protected SuggestionContext innerBuild(QueryShardContext context) throws IOException {
Map<String, Object> options = new HashMap<>(); Map<String, Object> options = new HashMap<>();
options.put("field", randomField); options.put("field", field());
options.put("suffix", randomSuffix); options.put("suffix", randomSuffix);
return new CustomSuggester.CustomSuggestionsContext(context, options); CustomSuggester.CustomSuggestionsContext customSuggestionsContext = new CustomSuggester.CustomSuggestionsContext(context, options);
customSuggestionsContext.setField(field());
return customSuggestionsContext;
} }
} }

2
core/src/test/java/org/elasticsearch/search/suggest/completion/CompletionSuggesterBuilderTests.java
View File

@ -42,7 +42,7 @@ public class CompletionSuggesterBuilderTests extends AbstractSuggestionBuilderTe
@Override @Override
protected CompletionSuggestionBuilder randomSuggestionBuilder() { protected CompletionSuggestionBuilder randomSuggestionBuilder() {
CompletionSuggestionBuilder testBuilder = new CompletionSuggestionBuilder(); CompletionSuggestionBuilder testBuilder = new CompletionSuggestionBuilder(randomAsciiOfLengthBetween(2, 20));
switch (randomIntBetween(0, 3)) { switch (randomIntBetween(0, 3)) {
case 0: case 0:
testBuilder.prefix(randomAsciiOfLength(10)); testBuilder.prefix(randomAsciiOfLength(10));

81
core/src/test/java/org/elasticsearch/search/suggest/phrase/PhraseSuggestionBuilderTests.java
View File

@ -47,7 +47,7 @@ public class PhraseSuggestionBuilderTests extends AbstractSuggestionBuilderTestC
} }
public static PhraseSuggestionBuilder randomPhraseSuggestionBuilder() { public static PhraseSuggestionBuilder randomPhraseSuggestionBuilder() {
PhraseSuggestionBuilder testBuilder = new PhraseSuggestionBuilder(); PhraseSuggestionBuilder testBuilder = new PhraseSuggestionBuilder(randomAsciiOfLengthBetween(2, 20));
maybeSet(testBuilder::maxErrors, randomFloat()); maybeSet(testBuilder::maxErrors, randomFloat());
maybeSet(testBuilder::separator, randomAsciiOfLengthBetween(1, 10)); maybeSet(testBuilder::separator, randomAsciiOfLengthBetween(1, 10));
maybeSet(testBuilder::realWordErrorLikelihood, randomFloat()); maybeSet(testBuilder::realWordErrorLikelihood, randomFloat());
@ -193,4 +193,83 @@ public class PhraseSuggestionBuilderTests extends AbstractSuggestionBuilderTestC
} }
} }
public void testInvalidParameters() throws IOException {
// test missing field name
try {
new PhraseSuggestionBuilder(null);
fail("Should not allow null as field name");
} catch (NullPointerException e) {
assertEquals("suggestion requires a field name", e.getMessage());
}
// test emtpy field name
try {
new PhraseSuggestionBuilder("");
fail("Should not allow empty string as field name");
} catch (IllegalArgumentException e) {
assertEquals("suggestion field name is empty", e.getMessage());
}
PhraseSuggestionBuilder builder = new PhraseSuggestionBuilder(randomAsciiOfLengthBetween(2, 20));
try {
builder.gramSize(0);
fail("Should not allow gramSize < 1");
} catch (IllegalArgumentException e) {
assertEquals("gramSize must be >= 1", e.getMessage());
}
try {
builder.gramSize(-1);
fail("Should not allow gramSize < 1");
} catch (IllegalArgumentException e) {
assertEquals("gramSize must be >= 1", e.getMessage());
}
try {
builder.maxErrors(-1);
fail("Should not allow maxErrors < 0");
} catch (IllegalArgumentException e) {
assertEquals("max_error must be > 0.0", e.getMessage());
}
try {
builder.separator(null);
fail("Should not allow null as separator");
} catch (NullPointerException e) {
assertEquals("separator cannot be set to null", e.getMessage());
}
try {
builder.realWordErrorLikelihood(-1);
fail("Should not allow real world error likelihood < 0");
} catch (IllegalArgumentException e) {
assertEquals("real_word_error_likelihood must be > 0.0", e.getMessage());
}
try {
builder.confidence(-1);
fail("Should not allow confidence < 0");
} catch (IllegalArgumentException e) {
assertEquals("confidence must be >= 0.0", e.getMessage());
}
try {
builder.tokenLimit(0);
fail("token_limit must be >= 1");
} catch (IllegalArgumentException e) {
assertEquals("token_limit must be >= 1", e.getMessage());
}
try {
if (randomBoolean()) {
builder.highlight(null, "</b>");
} else {
builder.highlight("<b>", null);
}
fail("Pre and post tag must both be null or both not be null.");
} catch (IllegalArgumentException e) {
assertEquals("Pre and post tag must both be null or both not be null.", e.getMessage());
}
}
} }

50
core/src/test/java/org/elasticsearch/search/suggest/term/TermSuggestionBuilderTests.java
View File

@ -28,7 +28,13 @@ import org.elasticsearch.search.suggest.term.TermSuggestionBuilder.SuggestMode;
import java.io.IOException; import java.io.IOException;
import static org.hamcrest.Matchers.notNullValue; import static org.elasticsearch.search.suggest.DirectSpellcheckerSettings.DEFAULT_ACCURACY;
import static org.elasticsearch.search.suggest.DirectSpellcheckerSettings.DEFAULT_MAX_EDITS;
import static org.elasticsearch.search.suggest.DirectSpellcheckerSettings.DEFAULT_MAX_INSPECTIONS;
import static org.elasticsearch.search.suggest.DirectSpellcheckerSettings.DEFAULT_MAX_TERM_FREQ;
import static org.elasticsearch.search.suggest.DirectSpellcheckerSettings.DEFAULT_MIN_DOC_FREQ;
import static org.elasticsearch.search.suggest.DirectSpellcheckerSettings.DEFAULT_MIN_WORD_LENGTH;
import static org.elasticsearch.search.suggest.DirectSpellcheckerSettings.DEFAULT_PREFIX_LENGTH;
/** /**
* Test the {@link TermSuggestionBuilder} class. * Test the {@link TermSuggestionBuilder} class.
@ -40,7 +46,7 @@ public class TermSuggestionBuilderTests extends AbstractSuggestionBuilderTestCas
*/ */
@Override @Override
protected TermSuggestionBuilder randomSuggestionBuilder() { protected TermSuggestionBuilder randomSuggestionBuilder() {
TermSuggestionBuilder testBuilder = new TermSuggestionBuilder(); TermSuggestionBuilder testBuilder = new TermSuggestionBuilder(randomAsciiOfLengthBetween(2, 20));
maybeSet(testBuilder::suggestMode, randomSuggestMode()); maybeSet(testBuilder::suggestMode, randomSuggestMode());
maybeSet(testBuilder::accuracy, randomFloat()); maybeSet(testBuilder::accuracy, randomFloat());
maybeSet(testBuilder::sort, randomSort()); maybeSet(testBuilder::sort, randomSort());
@ -124,7 +130,23 @@ public class TermSuggestionBuilderTests extends AbstractSuggestionBuilderTestCas
} }
public void testInvalidParameters() throws IOException { public void testInvalidParameters() throws IOException {
TermSuggestionBuilder builder = new TermSuggestionBuilder(); // test missing field name
try {
new TermSuggestionBuilder(null);
fail("Should not allow null as field name");
} catch (NullPointerException e) {
assertEquals("suggestion requires a field name", e.getMessage());
}
// test emtpy field name
try {
new TermSuggestionBuilder("");
fail("Should not allow empty string as field name");
} catch (IllegalArgumentException e) {
assertEquals("suggestion field name is empty", e.getMessage());
}
TermSuggestionBuilder builder = new TermSuggestionBuilder(randomAsciiOfLengthBetween(2, 20));
// test invalid accuracy values // test invalid accuracy values
try { try {
builder.accuracy(-0.5f); builder.accuracy(-0.5f);
@ -237,17 +259,17 @@ public class TermSuggestionBuilderTests extends AbstractSuggestionBuilderTestCas
} }
public void testDefaultValuesSet() { public void testDefaultValuesSet() {
TermSuggestionBuilder builder = new TermSuggestionBuilder(); TermSuggestionBuilder builder = new TermSuggestionBuilder(randomAsciiOfLengthBetween(2, 20));
assertThat(builder.accuracy(), notNullValue()); assertEquals(DEFAULT_ACCURACY, builder.accuracy(), Float.MIN_VALUE);
assertThat(builder.maxEdits(), notNullValue()); assertEquals(DEFAULT_MAX_EDITS, builder.maxEdits());
assertThat(builder.maxInspections(), notNullValue()); assertEquals(DEFAULT_MAX_INSPECTIONS, builder.maxInspections());
assertThat(builder.maxTermFreq(), notNullValue()); assertEquals(DEFAULT_MAX_TERM_FREQ, builder.maxTermFreq(), Float.MIN_VALUE);
assertThat(builder.minDocFreq(), notNullValue()); assertEquals(DEFAULT_MIN_DOC_FREQ, builder.minDocFreq(), Float.MIN_VALUE);
assertThat(builder.minWordLength(), notNullValue()); assertEquals(DEFAULT_MIN_WORD_LENGTH, builder.minWordLength());
assertThat(builder.prefixLength(), notNullValue()); assertEquals(DEFAULT_PREFIX_LENGTH, builder.prefixLength());
assertThat(builder.sort(), notNullValue()); assertEquals(SortBy.SCORE, builder.sort());
assertThat(builder.stringDistance(), notNullValue()); assertEquals(StringDistanceImpl.INTERNAL, builder.stringDistance());
assertThat(builder.suggestMode(), notNullValue()); assertEquals(SuggestMode.MISSING, builder.suggestMode());
} }
@Override @Override

7
docs/reference/migration/migrate_5_0.asciidoc
View File

@ -671,6 +671,13 @@ The inner DirectCandidateGenerator class has been moved out to its own class cal
The `setText` method has been changed to `setGlobalText` to make the intent more clear, and a `getGlobalText` method has been added. The `setText` method has been changed to `setGlobalText` to make the intent more clear, and a `getGlobalText` method has been added.
The `addSuggestion` method now required the user specified suggestion name, previously used in the ctor of each
suggestion.
=== SuggestionBuilder
The `field` setter has been deleted. Instead the field name needs to be specified as constructor argument.
==== Elasticsearch will no longer detect logging implementations ==== Elasticsearch will no longer detect logging implementations
Elasticsearch now logs only to log4j 1.2. Previously if log4j wasn't on the classpath it made some effort to degrade to Elasticsearch now logs only to log4j 1.2. Previously if log4j wasn't on the classpath it made some effort to degrade to

179
modules/lang-mustache/src/test/java/org/elasticsearch/messy/tests/SuggestSearchTests.java
View File

@ -20,38 +20,6 @@
package org.elasticsearch.messy.tests; package org.elasticsearch.messy.tests;
import static org.elasticsearch.cluster.metadata.IndexMetaData.SETTING_NUMBER_OF_REPLICAS;
import static org.elasticsearch.cluster.metadata.IndexMetaData.SETTING_NUMBER_OF_SHARDS;
import static org.elasticsearch.common.settings.Settings.settingsBuilder;
import static org.elasticsearch.index.query.QueryBuilders.matchQuery;
import static org.elasticsearch.search.suggest.SuggestBuilders.phraseSuggestion;
import static org.elasticsearch.search.suggest.SuggestBuilders.termSuggestion;
import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertNoFailures;
import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertSuggestion;
import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertSuggestionPhraseCollateMatchExists;
import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertSuggestionSize;
import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertThrows;
import static org.hamcrest.Matchers.anyOf;
import static org.hamcrest.Matchers.endsWith;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.nullValue;
import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ExecutionException;
import org.elasticsearch.ElasticsearchException; import org.elasticsearch.ElasticsearchException;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder;
import org.elasticsearch.action.index.IndexRequestBuilder; import org.elasticsearch.action.index.IndexRequestBuilder;
@ -81,6 +49,38 @@ import org.elasticsearch.search.suggest.term.TermSuggestionBuilder.SuggestMode;
import org.elasticsearch.test.ESIntegTestCase; import org.elasticsearch.test.ESIntegTestCase;
import org.elasticsearch.test.hamcrest.ElasticsearchAssertions; import org.elasticsearch.test.hamcrest.ElasticsearchAssertions;
import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ExecutionException;
import static org.elasticsearch.cluster.metadata.IndexMetaData.SETTING_NUMBER_OF_REPLICAS;
import static org.elasticsearch.cluster.metadata.IndexMetaData.SETTING_NUMBER_OF_SHARDS;
import static org.elasticsearch.common.settings.Settings.settingsBuilder;
import static org.elasticsearch.index.query.QueryBuilders.matchQuery;
import static org.elasticsearch.search.suggest.SuggestBuilders.phraseSuggestion;
import static org.elasticsearch.search.suggest.SuggestBuilders.termSuggestion;
import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertNoFailures;
import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertSuggestion;
import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertSuggestionPhraseCollateMatchExists;
import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertSuggestionSize;
import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertThrows;
import static org.hamcrest.Matchers.anyOf;
import static org.hamcrest.Matchers.endsWith;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.nullValue;
/** /**
* Integration tests for term and phrase suggestions. Many of these tests many requests that vary only slightly from one another. Where * Integration tests for term and phrase suggestions. Many of these tests many requests that vary only slightly from one another. Where
* possible these tests should declare for the first request, make the request, modify the configuration for the next request, make that * possible these tests should declare for the first request, make the request, modify the configuration for the next request, make that
@ -104,10 +104,9 @@ public class SuggestSearchTests extends ESIntegTestCase {
index("test", "type1", "4", "text", "abcc"); index("test", "type1", "4", "text", "abcc");
refresh(); refresh();
TermSuggestionBuilder termSuggest = termSuggestion() TermSuggestionBuilder termSuggest = termSuggestion("text")
.suggestMode(TermSuggestionBuilder.SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests. .suggestMode(TermSuggestionBuilder.SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests.
.text("abcd") .text("abcd");
.field("text");
logger.info("--> run suggestions with one index"); logger.info("--> run suggestions with one index");
searchSuggest("test", termSuggest); searchSuggest("test", termSuggest);
createIndex("test_1"); createIndex("test_1");
@ -118,11 +117,10 @@ public class SuggestSearchTests extends ESIntegTestCase {
index("test_1", "type1", "3", "text", "ab bd"); index("test_1", "type1", "3", "text", "ab bd");
index("test_1", "type1", "4", "text", "ab cc"); index("test_1", "type1", "4", "text", "ab cc");
refresh(); refresh();
termSuggest = termSuggestion() termSuggest = termSuggestion("text")
.suggestMode(SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests. .suggestMode(SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests.
.text("ab cd") .text("ab cd")
.minWordLength(1) .minWordLength(1);
.field("text");
logger.info("--> run suggestions with two indices"); logger.info("--> run suggestions with two indices");
searchSuggest("test", termSuggest); searchSuggest("test", termSuggest);
@ -145,11 +143,10 @@ public class SuggestSearchTests extends ESIntegTestCase {
index("test_2", "type1", "4", "text", "abcc"); index("test_2", "type1", "4", "text", "abcc");
refresh(); refresh();
termSuggest = termSuggestion() termSuggest = termSuggestion("text")
.suggestMode(SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests. .suggestMode(SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests.
.text("ab cd") .text("ab cd")
.minWordLength(1) .minWordLength(1);
.field("text");
logger.info("--> run suggestions with three indices"); logger.info("--> run suggestions with three indices");
try { try {
searchSuggest("test", termSuggest); searchSuggest("test", termSuggest);
@ -165,11 +162,10 @@ public class SuggestSearchTests extends ESIntegTestCase {
} }
termSuggest = termSuggestion() termSuggest = termSuggestion("text")
.suggestMode(SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests. .suggestMode(SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests.
.text("ABCD") .text("ABCD")
.minWordLength(1) .minWordLength(1);
.field("text");
logger.info("--> run suggestions with four indices"); logger.info("--> run suggestions with four indices");
try { try {
searchSuggest("test", termSuggest); searchSuggest("test", termSuggest);
@ -219,7 +215,7 @@ public class SuggestSearchTests extends ESIntegTestCase {
refresh(); refresh();
DirectCandidateGeneratorBuilder generator = candidateGenerator("name").prefixLength(0).minWordLength(0).suggestMode("always").maxEdits(2); DirectCandidateGeneratorBuilder generator = candidateGenerator("name").prefixLength(0).minWordLength(0).suggestMode("always").maxEdits(2);
PhraseSuggestionBuilder phraseSuggestion = phraseSuggestion().field("name.shingled") PhraseSuggestionBuilder phraseSuggestion = phraseSuggestion("name.shingled")
.addCandidateGenerator(generator) .addCandidateGenerator(generator)
.gramSize(3); .gramSize(3);
Suggest searchSuggest = searchSuggest("ice tea", "did_you_mean", phraseSuggestion); Suggest searchSuggest = searchSuggest("ice tea", "did_you_mean", phraseSuggestion);
@ -255,10 +251,9 @@ public class SuggestSearchTests extends ESIntegTestCase {
SearchResponse search = client().prepareSearch().setQuery(matchQuery("text", "spellchecker")).get(); SearchResponse search = client().prepareSearch().setQuery(matchQuery("text", "spellchecker")).get();
assertThat("didn't ask for suggestions but got some", search.getSuggest(), nullValue()); assertThat("didn't ask for suggestions but got some", search.getSuggest(), nullValue());
TermSuggestionBuilder termSuggestion = termSuggestion() TermSuggestionBuilder termSuggestion = termSuggestion("text")
.suggestMode(SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests. .suggestMode(SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests.
.text("abcd") .text("abcd")
.field("text")
.size(10); .size(10);
Suggest suggest = searchSuggest("test", termSuggestion); Suggest suggest = searchSuggest("test", termSuggestion);
assertSuggestion(suggest, 0, "test", 10, "abc0"); assertSuggestion(suggest, 0, "test", 10, "abc0");
@ -298,13 +293,15 @@ public class SuggestSearchTests extends ESIntegTestCase {
client().prepareIndex("test", "type1").setSource("name", "I like ice cream.")); client().prepareIndex("test", "type1").setSource("name", "I like ice cream."));
refresh(); refresh();
PhraseSuggestionBuilder phraseSuggestion = phraseSuggestion().field("name.shingled") PhraseSuggestionBuilder phraseSuggestion = phraseSuggestion("name.shingled")
.addCandidateGenerator(candidateGenerator("name").prefixLength(0).minWordLength(0).suggestMode("always").maxEdits(2)) .addCandidateGenerator(candidateGenerator("name").prefixLength(0).minWordLength(0).suggestMode("always").maxEdits(2))
.gramSize(3); .gramSize(3);
Suggest searchSuggest = searchSuggest("ice tea", "did_you_mean", phraseSuggestion); Suggest searchSuggest = searchSuggest("ice tea", "did_you_mean", phraseSuggestion);
assertSuggestion(searchSuggest, 0, 0, "did_you_mean", "iced tea"); assertSuggestion(searchSuggest, 0, 0, "did_you_mean", "iced tea");
phraseSuggestion.field("nosuchField"); phraseSuggestion = phraseSuggestion("nosuchField")
.addCandidateGenerator(candidateGenerator("name").prefixLength(0).minWordLength(0).suggestMode("always").maxEdits(2))
.gramSize(3);
{ {
SearchRequestBuilder searchBuilder = client().prepareSearch().setSize(0); SearchRequestBuilder searchBuilder = client().prepareSearch().setSize(0);
searchBuilder.suggest(new SuggestBuilder().setGlobalText("tetsting sugestion").addSuggestion("did_you_mean", phraseSuggestion)); searchBuilder.suggest(new SuggestBuilder().setGlobalText("tetsting sugestion").addSuggestion("did_you_mean", phraseSuggestion));
@ -330,10 +327,9 @@ public class SuggestSearchTests extends ESIntegTestCase {
SearchResponse search = client().prepareSearch().setQuery(matchQuery("text", "spellcecker")).get(); SearchResponse search = client().prepareSearch().setQuery(matchQuery("text", "spellcecker")).get();
assertThat("didn't ask for suggestions but got some", search.getSuggest(), nullValue()); assertThat("didn't ask for suggestions but got some", search.getSuggest(), nullValue());
TermSuggestionBuilder termSuggest = termSuggestion() TermSuggestionBuilder termSuggest = termSuggestion("text")
.suggestMode(SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests. .suggestMode(SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests.
.text("abcd") .text("abcd");
.field("text");
Suggest suggest = searchSuggest("test", termSuggest); Suggest suggest = searchSuggest("test", termSuggest);
assertSuggestion(suggest, 0, "test", "aacd", "abbd", "abcc"); assertSuggestion(suggest, 0, "test", "aacd", "abbd", "abcc");
assertThat(suggest.getSuggestion("test").getEntries().get(0).getText().string(), equalTo("abcd")); assertThat(suggest.getSuggestion("test").getEntries().get(0).getText().string(), equalTo("abcd"));
@ -350,10 +346,9 @@ public class SuggestSearchTests extends ESIntegTestCase {
index("test", "type1", "1", "foo", "bar"); index("test", "type1", "1", "foo", "bar");
refresh(); refresh();
TermSuggestionBuilder termSuggest = termSuggestion() TermSuggestionBuilder termSuggest = termSuggestion("text")
.suggestMode(SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests. .suggestMode(SuggestMode.ALWAYS) // Always, otherwise the results can vary between requests.
.text("abcd") .text("abcd");
.field("text");
Suggest suggest = searchSuggest("test", termSuggest); Suggest suggest = searchSuggest("test", termSuggest);
assertSuggestionSize(suggest, 0, 0, "test"); assertSuggestionSize(suggest, 0, 0, "test");
assertThat(suggest.getSuggestion("test").getEntries().get(0).getText().string(), equalTo("abcd")); assertThat(suggest.getSuggestion("test").getEntries().get(0).getText().string(), equalTo("abcd"));
@ -374,14 +369,14 @@ public class SuggestSearchTests extends ESIntegTestCase {
refresh(); refresh();
Map<String, SuggestionBuilder<?>> suggestions = new HashMap<>(); Map<String, SuggestionBuilder<?>> suggestions = new HashMap<>();
suggestions.put("size1", termSuggestion() suggestions.put("size1", termSuggestion("field1")
.size(1).text("prefix_abcd").maxTermFreq(10).prefixLength(1).minDocFreq(0) .size(1).text("prefix_abcd").maxTermFreq(10).prefixLength(1).minDocFreq(0)
.field("field1").suggestMode(SuggestMode.ALWAYS)); .suggestMode(SuggestMode.ALWAYS));
suggestions.put("field2", termSuggestion() suggestions.put("field2", termSuggestion("field2")
.field("field2").text("prefix_eeeh prefix_efgh") .text("prefix_eeeh prefix_efgh")
.maxTermFreq(10).minDocFreq(0).suggestMode(SuggestMode.ALWAYS)); .maxTermFreq(10).minDocFreq(0).suggestMode(SuggestMode.ALWAYS));
suggestions.put("accuracy", termSuggestion() suggestions.put("accuracy", termSuggestion("field2")
.field("field2").text("prefix_efgh").accuracy(1f) .text("prefix_efgh").accuracy(1f)
.maxTermFreq(10).minDocFreq(0).suggestMode(SuggestMode.ALWAYS)); .maxTermFreq(10).minDocFreq(0).suggestMode(SuggestMode.ALWAYS));
Suggest suggest = searchSuggest(null, 0, suggestions); Suggest suggest = searchSuggest(null, 0, suggestions);
assertSuggestion(suggest, 0, "size1", "prefix_aacd"); assertSuggestion(suggest, 0, "size1", "prefix_aacd");
@ -418,16 +413,16 @@ public class SuggestSearchTests extends ESIntegTestCase {
refresh(); refresh();
Map<String, SuggestionBuilder<?>> suggestions = new HashMap<>(); Map<String, SuggestionBuilder<?>> suggestions = new HashMap<>();
suggestions.put("size3SortScoreFirst", termSuggestion() suggestions.put("size3SortScoreFirst", termSuggestion("field1")
.size(3).minDocFreq(0).field("field1").suggestMode(SuggestMode.ALWAYS)); .size(3).minDocFreq(0).suggestMode(SuggestMode.ALWAYS));
suggestions.put("size10SortScoreFirst", termSuggestion() suggestions.put("size10SortScoreFirst", termSuggestion("field1")
.size(10).minDocFreq(0).field("field1").suggestMode(SuggestMode.ALWAYS).shardSize(50)); .size(10).minDocFreq(0).suggestMode(SuggestMode.ALWAYS).shardSize(50));
suggestions.put("size3SortScoreFirstMaxEdits1", termSuggestion() suggestions.put("size3SortScoreFirstMaxEdits1", termSuggestion("field1")
.maxEdits(1) .maxEdits(1)
.size(10).minDocFreq(0).field("field1").suggestMode(SuggestMode.ALWAYS)); .size(10).minDocFreq(0).suggestMode(SuggestMode.ALWAYS));
suggestions.put("size10SortFrequencyFirst", termSuggestion() suggestions.put("size10SortFrequencyFirst", termSuggestion("field1")
.size(10).sort(SortBy.FREQUENCY).shardSize(1000) .size(10).sort(SortBy.FREQUENCY).shardSize(1000)
.minDocFreq(0).field("field1").suggestMode(SuggestMode.ALWAYS)); .minDocFreq(0).suggestMode(SuggestMode.ALWAYS));
Suggest suggest = searchSuggest("prefix_abcd", 0, suggestions); Suggest suggest = searchSuggest("prefix_abcd", 0, suggestions);
// The commented out assertions fail sometimes because suggestions are based off of shard frequencies instead of index frequencies. // The commented out assertions fail sometimes because suggestions are based off of shard frequencies instead of index frequencies.
@ -453,7 +448,7 @@ public class SuggestSearchTests extends ESIntegTestCase {
refresh(); refresh();
Suggest searchSuggest = searchSuggest( "a an the", "simple_phrase", Suggest searchSuggest = searchSuggest( "a an the", "simple_phrase",
phraseSuggestion().field("body").gramSize(1) phraseSuggestion("body").gramSize(1)
.addCandidateGenerator(candidateGenerator("body").minWordLength(1).suggestMode("always")) .addCandidateGenerator(candidateGenerator("body").minWordLength(1).suggestMode("always"))
.size(1)); .size(1));
assertSuggestionSize(searchSuggest, 0, 0, "simple_phrase"); assertSuggestionSize(searchSuggest, 0, 0, "simple_phrase");
@ -489,13 +484,13 @@ public class SuggestSearchTests extends ESIntegTestCase {
refresh(); refresh();
Suggest searchSuggest = searchSuggest( "hello word", "simple_phrase", Suggest searchSuggest = searchSuggest( "hello word", "simple_phrase",
phraseSuggestion().field("body") phraseSuggestion("body")
.addCandidateGenerator(candidateGenerator("body").prefixLength(4).minWordLength(1).suggestMode("always")) .addCandidateGenerator(candidateGenerator("body").prefixLength(4).minWordLength(1).suggestMode("always"))
.size(1).confidence(1.0f)); .size(1).confidence(1.0f));
assertSuggestion(searchSuggest, 0, "simple_phrase", "hello words"); assertSuggestion(searchSuggest, 0, "simple_phrase", "hello words");
searchSuggest = searchSuggest( "hello word", "simple_phrase", searchSuggest = searchSuggest( "hello word", "simple_phrase",
phraseSuggestion().field("body") phraseSuggestion("body")
.addCandidateGenerator(candidateGenerator("body").prefixLength(2).minWordLength(1).suggestMode("always")) .addCandidateGenerator(candidateGenerator("body").prefixLength(2).minWordLength(1).suggestMode("always"))
.size(1).confidence(1.0f)); .size(1).confidence(1.0f));
assertSuggestion(searchSuggest, 0, "simple_phrase", "hello world"); assertSuggestion(searchSuggest, 0, "simple_phrase", "hello world");
@ -543,8 +538,7 @@ public class SuggestSearchTests extends ESIntegTestCase {
} }
refresh(); refresh();
PhraseSuggestionBuilder phraseSuggest = phraseSuggestion() PhraseSuggestionBuilder phraseSuggest = phraseSuggestion("bigram").gramSize(2).analyzer("body")
.field("bigram").gramSize(2).analyzer("body")
.addCandidateGenerator(candidateGenerator("body").minWordLength(1).suggestMode("always")) .addCandidateGenerator(candidateGenerator("body").minWordLength(1).suggestMode("always"))
.size(1); .size(1);
Suggest searchSuggest = searchSuggest( "american ame", "simple_phrase", phraseSuggest); Suggest searchSuggest = searchSuggest( "american ame", "simple_phrase", phraseSuggest);
@ -680,9 +674,8 @@ public class SuggestSearchTests extends ESIntegTestCase {
index("test", "type1", "2", "body", line, "body_reverse", line, "bigram", line); index("test", "type1", "2", "body", line, "body_reverse", line, "bigram", line);
refresh(); refresh();
PhraseSuggestionBuilder phraseSuggestion = phraseSuggestion() PhraseSuggestionBuilder phraseSuggestion = phraseSuggestion("bigram")
.realWordErrorLikelihood(0.95f) .realWordErrorLikelihood(0.95f)
.field("bigram")
.gramSize(2) .gramSize(2)
.analyzer("body") .analyzer("body")
.addCandidateGenerator(candidateGenerator("body").minWordLength(1).prefixLength(1).suggestMode("always").size(1).accuracy(0.1f)) .addCandidateGenerator(candidateGenerator("body").minWordLength(1).prefixLength(1).suggestMode("always").size(1).accuracy(0.1f))
@ -740,8 +733,7 @@ public class SuggestSearchTests extends ESIntegTestCase {
NumShards numShards = getNumShards("test"); NumShards numShards = getNumShards("test");
// Lets make sure some things throw exceptions // Lets make sure some things throw exceptions
PhraseSuggestionBuilder phraseSuggestion = phraseSuggestion() PhraseSuggestionBuilder phraseSuggestion = phraseSuggestion("bigram")
.field("bigram")
.analyzer("body") .analyzer("body")
.addCandidateGenerator(candidateGenerator("does_not_exist").minWordLength(1).suggestMode("always")) .addCandidateGenerator(candidateGenerator("does_not_exist").minWordLength(1).suggestMode("always"))
.realWordErrorLikelihood(0.95f) .realWordErrorLikelihood(0.95f)
@ -773,10 +765,15 @@ public class SuggestSearchTests extends ESIntegTestCase {
searchSuggest( "Xor the Got-Jewel", 0, suggestion); searchSuggest( "Xor the Got-Jewel", 0, suggestion);
// Field doesn't produce unigrams but the analyzer does // Field doesn't produce unigrams but the analyzer does
phraseSuggestion.forceUnigrams(true).field("bigram").analyzer("ngram"); phraseSuggestion.forceUnigrams(true).analyzer("ngram");
searchSuggest( "Xor the Got-Jewel", 0, suggestion); searchSuggest( "Xor the Got-Jewel", 0, suggestion);
phraseSuggestion.field("ngram").analyzer("myDefAnalyzer") phraseSuggestion = phraseSuggestion("ngram")
.analyzer("myDefAnalyzer")
.forceUnigrams(true)
.realWordErrorLikelihood(0.95f)
.maxErrors(0.5f)
.size(1)
.addCandidateGenerator(candidateGenerator("body").minWordLength(1).suggestMode("always")); .addCandidateGenerator(candidateGenerator("body").minWordLength(1).suggestMode("always"));
Suggest suggest = searchSuggest( "Xor the Got-Jewel", 0, suggestion); Suggest suggest = searchSuggest( "Xor the Got-Jewel", 0, suggestion);
@ -801,8 +798,8 @@ public class SuggestSearchTests extends ESIntegTestCase {
client().prepareIndex("test", "type1", "3").setSource("field1", "foobar3").setRouting("3")); client().prepareIndex("test", "type1", "3").setSource("field1", "foobar3").setRouting("3"));
Suggest suggest = searchSuggest( "foobar", "simple", Suggest suggest = searchSuggest( "foobar", "simple",
termSuggestion() termSuggestion("field1")
.size(10).minDocFreq(0).field("field1").suggestMode(SuggestMode.ALWAYS)); .size(10).minDocFreq(0).suggestMode(SuggestMode.ALWAYS));
ElasticsearchAssertions.assertSuggestionSize(suggest, 0, 3, "simple"); ElasticsearchAssertions.assertSuggestionSize(suggest, 0, 3, "simple");
} }
@ -842,14 +839,14 @@ public class SuggestSearchTests extends ESIntegTestCase {
SearchRequestBuilder request = client().prepareSearch().setSize(0) SearchRequestBuilder request = client().prepareSearch().setSize(0)
.suggest( .suggest(
new SuggestBuilder().setGlobalText("tetsting sugestion").addSuggestion("did_you_mean", new SuggestBuilder().setGlobalText("tetsting sugestion").addSuggestion("did_you_mean",
phraseSuggestion().field("fielddoesnotexist").maxErrors(5.0f))); phraseSuggestion("fielddoesnotexist").maxErrors(5.0f)));
assertThrows(request, SearchPhaseExecutionException.class); assertThrows(request, SearchPhaseExecutionException.class);
// When searching on a shard which does not hold yet any document of an existing type, we should not fail // When searching on a shard which does not hold yet any document of an existing type, we should not fail
SearchResponse searchResponse = client().prepareSearch().setSize(0) SearchResponse searchResponse = client().prepareSearch().setSize(0)
.suggest( .suggest(
new SuggestBuilder().setGlobalText("tetsting sugestion").addSuggestion("did_you_mean", new SuggestBuilder().setGlobalText("tetsting sugestion").addSuggestion("did_you_mean",
phraseSuggestion().field("name").maxErrors(5.0f))) phraseSuggestion("name").maxErrors(5.0f)))
.get(); .get();
ElasticsearchAssertions.assertNoFailures(searchResponse); ElasticsearchAssertions.assertNoFailures(searchResponse);
ElasticsearchAssertions.assertSuggestion(searchResponse.getSuggest(), 0, 0, "did_you_mean", "testing suggestions"); ElasticsearchAssertions.assertSuggestion(searchResponse.getSuggest(), 0, 0, "did_you_mean", "testing suggestions");
@ -888,7 +885,7 @@ public class SuggestSearchTests extends ESIntegTestCase {
.setSize(0) .setSize(0)
.suggest( .suggest(
new SuggestBuilder().setGlobalText("tetsting sugestion").addSuggestion("did_you_mean", new SuggestBuilder().setGlobalText("tetsting sugestion").addSuggestion("did_you_mean",
phraseSuggestion().field("name").maxErrors(5.0f))) phraseSuggestion("name").maxErrors(5.0f)))
.get(); .get();
assertNoFailures(searchResponse); assertNoFailures(searchResponse);
@ -945,16 +942,14 @@ public class SuggestSearchTests extends ESIntegTestCase {
} }
refresh(); refresh();
Suggest searchSuggest = searchSuggest("nobel prize", "simple_phrase", phraseSuggestion() Suggest searchSuggest = searchSuggest("nobel prize", "simple_phrase", phraseSuggestion("body")
.field("body")
.addCandidateGenerator(candidateGenerator("body").minWordLength(1).suggestMode("always").maxTermFreq(.99f)) .addCandidateGenerator(candidateGenerator("body").minWordLength(1).suggestMode("always").maxTermFreq(.99f))
.confidence(2f) .confidence(2f)
.maxErrors(5f) .maxErrors(5f)
.size(1)); .size(1));
assertSuggestionSize(searchSuggest, 0, 0, "simple_phrase"); assertSuggestionSize(searchSuggest, 0, 0, "simple_phrase");
searchSuggest = searchSuggest("noble prize", "simple_phrase", phraseSuggestion() searchSuggest = searchSuggest("noble prize", "simple_phrase", phraseSuggestion("body")
.field("body")
.addCandidateGenerator(candidateGenerator("body").minWordLength(1).suggestMode("always").maxTermFreq(.99f)) .addCandidateGenerator(candidateGenerator("body").minWordLength(1).suggestMode("always").maxTermFreq(.99f))
.confidence(2f) .confidence(2f)
.maxErrors(5f) .maxErrors(5f)
@ -1084,8 +1079,7 @@ public class SuggestSearchTests extends ESIntegTestCase {
} }
indexRandom(true, builders); indexRandom(true, builders);
PhraseSuggestionBuilder suggest = phraseSuggestion() PhraseSuggestionBuilder suggest = phraseSuggestion("title")
.field("title")
.addCandidateGenerator(candidateGenerator("title") .addCandidateGenerator(candidateGenerator("title")
.suggestMode("always") .suggestMode("always")
.maxTermFreq(.99f) .maxTermFreq(.99f)
@ -1149,8 +1143,7 @@ public class SuggestSearchTests extends ESIntegTestCase {
indexRandom(true, builders); indexRandom(true, builders);
// suggest without collate // suggest without collate
PhraseSuggestionBuilder suggest = phraseSuggestion() PhraseSuggestionBuilder suggest = phraseSuggestion("title")
.field("title")
.addCandidateGenerator(candidateGenerator("title") .addCandidateGenerator(candidateGenerator("title")
.suggestMode("always") .suggestMode("always")
.maxTermFreq(.99f) .maxTermFreq(.99f)