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

Merge pull request #14249 from MaineC/enhancement/8964 

Switch query parsers to use ParseField
This commit is contained in:
Isabel Drost-Fromm 2015-11-23 14:16:40 +01:00
parent c1264b926f 38e1ad5596
commit 37d7629146
123 changed files with 1942 additions and 542 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
core/src/main/java/org/elasticsearch/index/query/AbstractQueryBuilder.java
View File

@ -67,9 +67,9 @@ public abstract class AbstractQueryBuilder<QB extends AbstractQueryBuilder> exte
protected abstract void doXContent(XContentBuilder builder, Params params) throws IOException;
protected void printBoostAndQueryName(XContentBuilder builder) throws IOException {
builder.field("boost", boost);
builder.field(BOOST_FIELD.getPreferredName(), boost);
if (queryName != null) {
builder.field("_name", queryName);
builder.field(NAME_FIELD.getPreferredName(), queryName);
}
}
@ -107,7 +107,7 @@ public abstract class AbstractQueryBuilder<QB extends AbstractQueryBuilder> exte
protected abstract Query doToQuery(QueryShardContext context) throws IOException;
/**
* Returns the query name for the query.
* Sets the query name for the query.
*/
@SuppressWarnings("unchecked")
@Override
@ -117,7 +117,7 @@ public abstract class AbstractQueryBuilder<QB extends AbstractQueryBuilder> exte
}
/**
* Sets the query name for the query.
* Returns the query name for the query.
*/
@Override
public final String queryName() {

5
core/src/main/java/org/elasticsearch/index/query/BaseTermQueryBuilder.java
View File

@ -20,6 +20,7 @@
package org.elasticsearch.index.query;
import org.apache.lucene.util.BytesRef;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.io.stream.StreamOutput;
@ -30,6 +31,8 @@ import java.util.Objects;
public abstract class BaseTermQueryBuilder<QB extends BaseTermQueryBuilder<QB>> extends AbstractQueryBuilder<QB> {
public static final ParseField VALUE_FIELD = new ParseField("value");
/** Name of field to match against. */
protected final String fieldName;
@ -133,7 +136,7 @@ public abstract class BaseTermQueryBuilder<QB extends BaseTermQueryBuilder<QB>>
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(getName());
builder.startObject(fieldName);
builder.field("value", convertToStringIfBytesRef(this.value));
builder.field(VALUE_FIELD.getPreferredName(), convertToStringIfBytesRef(this.value));
printBoostAndQueryName(builder);
builder.endObject();
builder.endObject();

14
core/src/main/java/org/elasticsearch/index/query/BoolQueryBuilder.java
View File

@ -231,14 +231,14 @@ public class BoolQueryBuilder extends AbstractQueryBuilder<BoolQueryBuilder> {
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
doXArrayContent("must", mustClauses, builder, params);
doXArrayContent("filter", filterClauses, builder, params);
doXArrayContent("must_not", mustNotClauses, builder, params);
doXArrayContent("should", shouldClauses, builder, params);
builder.field("disable_coord", disableCoord);
builder.field("adjust_pure_negative", adjustPureNegative);
doXArrayContent(BoolQueryParser.MUST, mustClauses, builder, params);
doXArrayContent(BoolQueryParser.FILTER, filterClauses, builder, params);
doXArrayContent(BoolQueryParser.MUST_NOT, mustNotClauses, builder, params);
doXArrayContent(BoolQueryParser.SHOULD, shouldClauses, builder, params);
builder.field(BoolQueryParser.DISABLE_COORD_FIELD.getPreferredName(), disableCoord);
builder.field(BoolQueryParser.ADJUST_PURE_NEGATIVE.getPreferredName(), adjustPureNegative);
if (minimumShouldMatch != null) {
builder.field("minimum_should_match", minimumShouldMatch);
builder.field(BoolQueryParser.MINIMUM_SHOULD_MATCH.getPreferredName(), minimumShouldMatch);
}
printBoostAndQueryName(builder);
builder.endObject();

43
core/src/main/java/org/elasticsearch/index/query/BoolQueryParser.java
View File

@ -20,6 +20,7 @@
package org.elasticsearch.index.query;
import org.apache.lucene.search.BooleanQuery;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.inject.Inject;
import org.elasticsearch.common.settings.Settings;
@ -34,6 +35,16 @@ import java.util.List;
*/
public class BoolQueryParser implements QueryParser<BoolQueryBuilder> {
public static final String MUSTNOT = "mustNot";
public static final String MUST_NOT = "must_not";
public static final String FILTER = "filter";
public static final String SHOULD = "should";
public static final String MUST = "must";
public static final ParseField DISABLE_COORD_FIELD = new ParseField("disable_coord");
public static final ParseField MINIMUM_SHOULD_MATCH = new ParseField("minimum_should_match");
public static final ParseField MINIMUM_NUMBER_SHOULD_MATCH = new ParseField("minimum_number_should_match");
public static final ParseField ADJUST_PURE_NEGATIVE = new ParseField("adjust_pure_negative");
@Inject
public BoolQueryParser(Settings settings) {
BooleanQuery.setMaxClauseCount(settings.getAsInt("index.query.bool.max_clause_count", settings.getAsInt("indices.query.bool.max_clause_count", BooleanQuery.getMaxClauseCount())));
@ -69,20 +80,20 @@ public class BoolQueryParser implements QueryParser<BoolQueryBuilder> {
// skip
} else if (token == XContentParser.Token.START_OBJECT) {
switch (currentFieldName) {
case "must":
case MUST:
query = parseContext.parseInnerQueryBuilder();
mustClauses.add(query);
break;
case "should":
case SHOULD:
query = parseContext.parseInnerQueryBuilder();
shouldClauses.add(query);
break;
case "filter":
case FILTER:
query = parseContext.parseInnerQueryBuilder();
filterClauses.add(query);
break;
case "must_not":
case "mustNot":
case MUST_NOT:
case MUSTNOT:
query = parseContext.parseInnerQueryBuilder();
mustNotClauses.add(query);
break;
@ -92,20 +103,20 @@ public class BoolQueryParser implements QueryParser<BoolQueryBuilder> {
} else if (token == XContentParser.Token.START_ARRAY) {
while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
switch (currentFieldName) {
case "must":
case MUST:
query = parseContext.parseInnerQueryBuilder();
mustClauses.add(query);
break;
case "should":
case SHOULD:
query = parseContext.parseInnerQueryBuilder();
shouldClauses.add(query);
break;
case "filter":
case FILTER:
query = parseContext.parseInnerQueryBuilder();
filterClauses.add(query);
break;
case "must_not":
case "mustNot":
case MUST_NOT:
case MUSTNOT:
query = parseContext.parseInnerQueryBuilder();
mustNotClauses.add(query);
break;
@ -114,17 +125,17 @@ public class BoolQueryParser implements QueryParser<BoolQueryBuilder> {
}
}
} else if (token.isValue()) {
if ("disable_coord".equals(currentFieldName) || "disableCoord".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, DISABLE_COORD_FIELD)) {
disableCoord = parser.booleanValue();
} else if ("minimum_should_match".equals(currentFieldName) || "minimumShouldMatch".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MINIMUM_SHOULD_MATCH)) {
minimumShouldMatch = parser.textOrNull();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("minimum_number_should_match".equals(currentFieldName) || "minimumNumberShouldMatch".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MINIMUM_NUMBER_SHOULD_MATCH)) {
minimumShouldMatch = parser.textOrNull();
} else if ("adjust_pure_negative".equals(currentFieldName) || "adjustPureNegative".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, ADJUST_PURE_NEGATIVE)) {
adjustPureNegative = parser.booleanValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[bool] query does not support [" + currentFieldName + "]");

6
core/src/main/java/org/elasticsearch/index/query/BoostingQueryBuilder.java
View File

@ -104,11 +104,11 @@ public class BoostingQueryBuilder extends AbstractQueryBuilder<BoostingQueryBuil
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("positive");
builder.field(BoostingQueryParser.POSITIVE_FIELD.getPreferredName());
positiveQuery.toXContent(builder, params);
builder.field("negative");
builder.field(BoostingQueryParser.NEGATIVE_FIELD.getPreferredName());
negativeQuery.toXContent(builder, params);
builder.field("negative_boost", negativeBoost);
builder.field(BoostingQueryParser.NEGATIVE_BOOST_FIELD.getPreferredName(), negativeBoost);
printBoostAndQueryName(builder);
builder.endObject();
}

15
core/src/main/java/org/elasticsearch/index/query/BoostingQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.xcontent.XContentParser;
@ -29,6 +30,10 @@ import java.io.IOException;
*/
public class BoostingQueryParser implements QueryParser<BoostingQueryBuilder> {
public static final ParseField POSITIVE_FIELD = new ParseField("positive");
public static final ParseField NEGATIVE_FIELD = new ParseField("negative");
public static final ParseField NEGATIVE_BOOST_FIELD = new ParseField("negative_boost");
@Override
public String[] names() {
return new String[]{BoostingQueryBuilder.NAME};
@ -52,21 +57,21 @@ public class BoostingQueryParser implements QueryParser<BoostingQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if ("positive".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, POSITIVE_FIELD)) {
positiveQuery = parseContext.parseInnerQueryBuilder();
positiveQueryFound = true;
} else if ("negative".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, NEGATIVE_FIELD)) {
negativeQuery = parseContext.parseInnerQueryBuilder();
negativeQueryFound = true;
} else {
throw new ParsingException(parser.getTokenLocation(), "[boosting] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("negative_boost".equals(currentFieldName) || "negativeBoost".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, NEGATIVE_BOOST_FIELD)) {
negativeBoost = parser.floatValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else {
throw new ParsingException(parser.getTokenLocation(), "[boosting] query does not support [" + currentFieldName + "]");

18
core/src/main/java/org/elasticsearch/index/query/CommonTermsQueryBuilder.java
View File

@ -202,21 +202,21 @@ public class CommonTermsQueryBuilder extends AbstractQueryBuilder<CommonTermsQue
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.startObject(fieldName);
builder.field("query", text);
builder.field("disable_coord", disableCoord);
builder.field("high_freq_operator", highFreqOperator.toString());
builder.field("low_freq_operator", lowFreqOperator.toString());
builder.field(CommonTermsQueryParser.QUERY_FIELD.getPreferredName(), text);
builder.field(CommonTermsQueryParser.DISABLE_COORD_FIELD.getPreferredName(), disableCoord);
builder.field(CommonTermsQueryParser.HIGH_FREQ_OPERATOR_FIELD.getPreferredName(), highFreqOperator.toString());
builder.field(CommonTermsQueryParser.LOW_FREQ_OPERATOR_FIELD.getPreferredName(), lowFreqOperator.toString());
if (analyzer != null) {
builder.field("analyzer", analyzer);
builder.field(CommonTermsQueryParser.ANALYZER_FIELD.getPreferredName(), analyzer);
}
builder.field("cutoff_frequency", cutoffFrequency);
builder.field(CommonTermsQueryParser.CUTOFF_FREQUENCY_FIELD.getPreferredName(), cutoffFrequency);
if (lowFreqMinimumShouldMatch != null || highFreqMinimumShouldMatch != null) {
builder.startObject("minimum_should_match");
builder.startObject(CommonTermsQueryParser.MINIMUM_SHOULD_MATCH_FIELD.getPreferredName());
if (lowFreqMinimumShouldMatch != null) {
builder.field("low_freq", lowFreqMinimumShouldMatch);
builder.field(CommonTermsQueryParser.LOW_FREQ_FIELD.getPreferredName(), lowFreqMinimumShouldMatch);
}
if (highFreqMinimumShouldMatch != null) {
builder.field("high_freq", highFreqMinimumShouldMatch);
builder.field(CommonTermsQueryParser.HIGH_FREQ_FIELD.getPreferredName(), highFreqMinimumShouldMatch);
}
builder.endObject();
}

35
core/src/main/java/org/elasticsearch/index/query/CommonTermsQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.xcontent.XContentParser;
@ -29,6 +30,16 @@ import java.io.IOException;
*/
public class CommonTermsQueryParser implements QueryParser<CommonTermsQueryBuilder> {
public static final ParseField CUTOFF_FREQUENCY_FIELD = new ParseField("cutoff_frequency");
public static final ParseField MINIMUM_SHOULD_MATCH_FIELD = new ParseField("minimum_should_match");
public static final ParseField LOW_FREQ_OPERATOR_FIELD = new ParseField("low_freq_operator");
public static final ParseField HIGH_FREQ_OPERATOR_FIELD = new ParseField("high_freq_operator");
public static final ParseField DISABLE_COORD_FIELD = new ParseField("disable_coord");
public static final ParseField ANALYZER_FIELD = new ParseField("analyzer");
public static final ParseField QUERY_FIELD = new ParseField("query");
public static final ParseField HIGH_FREQ_FIELD = new ParseField("high_freq");
public static final ParseField LOW_FREQ_FIELD = new ParseField("low_freq");
@Override
public String[] names() {
return new String[] { CommonTermsQueryBuilder.NAME };
@ -59,15 +70,15 @@ public class CommonTermsQueryParser implements QueryParser<CommonTermsQueryBuild
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if ("minimum_should_match".equals(currentFieldName) || "minimumShouldMatch".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, MINIMUM_SHOULD_MATCH_FIELD)) {
String innerFieldName = null;
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) {
innerFieldName = parser.currentName();
} else if (token.isValue()) {
if ("low_freq".equals(innerFieldName) || "lowFreq".equals(innerFieldName)) {
if (parseContext.parseFieldMatcher().match(innerFieldName, LOW_FREQ_FIELD)) {
lowFreqMinimumShouldMatch = parser.text();
} else if ("high_freq".equals(innerFieldName) || "highFreq".equals(innerFieldName)) {
} else if (parseContext.parseFieldMatcher().match(innerFieldName, HIGH_FREQ_FIELD)) {
highFreqMinimumShouldMatch = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[" + CommonTermsQueryBuilder.NAME + "] query does not support [" + innerFieldName
@ -82,23 +93,23 @@ public class CommonTermsQueryParser implements QueryParser<CommonTermsQueryBuild
throw new ParsingException(parser.getTokenLocation(), "[" + CommonTermsQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("query".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, QUERY_FIELD)) {
text = parser.objectText();
} else if ("analyzer".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, ANALYZER_FIELD)) {
analyzer = parser.text();
} else if ("disable_coord".equals(currentFieldName) || "disableCoord".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, DISABLE_COORD_FIELD)) {
disableCoord = parser.booleanValue();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("high_freq_operator".equals(currentFieldName) || "highFreqOperator".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, HIGH_FREQ_OPERATOR_FIELD)) {
highFreqOperator = Operator.fromString(parser.text());
} else if ("low_freq_operator".equals(currentFieldName) || "lowFreqOperator".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LOW_FREQ_OPERATOR_FIELD)) {
lowFreqOperator = Operator.fromString(parser.text());
} else if ("minimum_should_match".equals(currentFieldName) || "minimumShouldMatch".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MINIMUM_SHOULD_MATCH_FIELD)) {
lowFreqMinimumShouldMatch = parser.text();
} else if ("cutoff_frequency".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, CUTOFF_FREQUENCY_FIELD)) {
cutoffFrequency = parser.floatValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[" + CommonTermsQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");

2
core/src/main/java/org/elasticsearch/index/query/ConstantScoreQueryBuilder.java
View File

@ -63,7 +63,7 @@ public class ConstantScoreQueryBuilder extends AbstractQueryBuilder<ConstantScor
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("filter");
builder.field(ConstantScoreQueryParser.INNER_QUERY_FIELD.getPreferredName());
filterBuilder.toXContent(builder, params);
printBoostAndQueryName(builder);
builder.endObject();

6
core/src/main/java/org/elasticsearch/index/query/ConstantScoreQueryParser.java
View File

@ -31,7 +31,7 @@ import java.io.IOException;
*/
public class ConstantScoreQueryParser implements QueryParser<ConstantScoreQueryBuilder> {
private static final ParseField INNER_QUERY_FIELD = new ParseField("filter", "query");
public static final ParseField INNER_QUERY_FIELD = new ParseField("filter", "query");
@Override
public String[] names() {
@ -62,9 +62,9 @@ public class ConstantScoreQueryParser implements QueryParser<ConstantScoreQueryB
throw new ParsingException(parser.getTokenLocation(), "[constant_score] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("_name".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else {
throw new ParsingException(parser.getTokenLocation(), "[constant_score] query does not support [" + currentFieldName + "]");

4
core/src/main/java/org/elasticsearch/index/query/DisMaxQueryBuilder.java
View File

@ -88,8 +88,8 @@ public class DisMaxQueryBuilder extends AbstractQueryBuilder<DisMaxQueryBuilder>
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("tie_breaker", tieBreaker);
builder.startArray("queries");
builder.field(DisMaxQueryParser.TIE_BREAKER_FIELD.getPreferredName(), tieBreaker);
builder.startArray(DisMaxQueryParser.QUERIES_FIELD.getPreferredName());
for (QueryBuilder queryBuilder : queries) {
queryBuilder.toXContent(builder, params);
}

14
core/src/main/java/org/elasticsearch/index/query/DisMaxQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
@ -32,6 +33,9 @@ import java.util.List;
*/
public class DisMaxQueryParser implements QueryParser<DisMaxQueryBuilder> {
public static final ParseField TIE_BREAKER_FIELD = new ParseField("tie_breaker");
public static final ParseField QUERIES_FIELD = new ParseField("queries");
@Override
public String[] names() {
return new String[]{DisMaxQueryBuilder.NAME, Strings.toCamelCase(DisMaxQueryBuilder.NAME)};
@ -54,7 +58,7 @@ public class DisMaxQueryParser implements QueryParser<DisMaxQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if ("queries".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, QUERIES_FIELD)) {
queriesFound = true;
QueryBuilder query = parseContext.parseInnerQueryBuilder();
queries.add(query);
@ -62,7 +66,7 @@ public class DisMaxQueryParser implements QueryParser<DisMaxQueryBuilder> {
throw new ParsingException(parser.getTokenLocation(), "[dis_max] query does not support [" + currentFieldName + "]");
}
} else if (token == XContentParser.Token.START_ARRAY) {
if ("queries".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, QUERIES_FIELD)) {
queriesFound = true;
while (token != XContentParser.Token.END_ARRAY) {
QueryBuilder query = parseContext.parseInnerQueryBuilder();
@ -73,11 +77,11 @@ public class DisMaxQueryParser implements QueryParser<DisMaxQueryBuilder> {
throw new ParsingException(parser.getTokenLocation(), "[dis_max] query does not support [" + currentFieldName + "]");
}
} else {
if ("boost".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("tie_breaker".equals(currentFieldName) || "tieBreaker".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, TIE_BREAKER_FIELD)) {
tieBreaker = parser.floatValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[dis_max] query does not support [" + currentFieldName + "]");

2
core/src/main/java/org/elasticsearch/index/query/ExistsQueryBuilder.java
View File

@ -61,7 +61,7 @@ public class ExistsQueryBuilder extends AbstractQueryBuilder<ExistsQueryBuilder>
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("field", fieldName);
builder.field(ExistsQueryParser.FIELD_FIELD.getPreferredName(), fieldName);
printBoostAndQueryName(builder);
builder.endObject();
}

9
core/src/main/java/org/elasticsearch/index/query/ExistsQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.xcontent.XContentParser;
@ -29,6 +30,8 @@ import java.io.IOException;
*/
public class ExistsQueryParser implements QueryParser<ExistsQueryBuilder> {
public static final ParseField FIELD_FIELD = new ParseField("field");
@Override
public String[] names() {
return new String[]{ExistsQueryBuilder.NAME};
@ -48,11 +51,11 @@ public class ExistsQueryParser implements QueryParser<ExistsQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token.isValue()) {
if ("field".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, FIELD_FIELD)) {
fieldPattern = parser.text();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else {
throw new ParsingException(parser.getTokenLocation(), "[" + ExistsQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");

4
core/src/main/java/org/elasticsearch/index/query/FieldMaskingSpanQueryBuilder.java
View File

@ -75,9 +75,9 @@ public class FieldMaskingSpanQueryBuilder extends AbstractQueryBuilder<FieldMask
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("query");
builder.field(FieldMaskingSpanQueryParser.QUERY_FIELD.getPreferredName());
queryBuilder.toXContent(builder, params);
builder.field("field", fieldName);
builder.field(FieldMaskingSpanQueryParser.FIELD_FIELD.getPreferredName(), fieldName);
printBoostAndQueryName(builder);
builder.endObject();
}

12
core/src/main/java/org/elasticsearch/index/query/FieldMaskingSpanQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
@ -29,6 +30,9 @@ import java.io.IOException;
*/
public class FieldMaskingSpanQueryParser implements QueryParser<FieldMaskingSpanQueryBuilder> {
public static final ParseField FIELD_FIELD = new ParseField("field");
public static final ParseField QUERY_FIELD = new ParseField("query");
@Override
public String[] names() {
return new String[]{FieldMaskingSpanQueryBuilder.NAME, Strings.toCamelCase(FieldMaskingSpanQueryBuilder.NAME)};
@ -50,7 +54,7 @@ public class FieldMaskingSpanQueryParser implements QueryParser<FieldMaskingSpan
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if ("query".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, QUERY_FIELD)) {
QueryBuilder query = parseContext.parseInnerQueryBuilder();
if (!(query instanceof SpanQueryBuilder)) {
throw new ParsingException(parser.getTokenLocation(), "[field_masking_span] query must be of type span query");
@ -61,11 +65,11 @@ public class FieldMaskingSpanQueryParser implements QueryParser<FieldMaskingSpan
+ currentFieldName + "]");
}
} else {
if ("boost".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("field".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, FIELD_FIELD)) {
field = parser.text();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[field_masking_span] query does not support [" + currentFieldName + "]");

22
core/src/main/java/org/elasticsearch/index/query/FuzzyQueryBuilder.java
View File

@ -209,16 +209,16 @@ public class FuzzyQueryBuilder extends AbstractQueryBuilder<FuzzyQueryBuilder> i
}
@Override
public void doXContent(XContentBuilder builder, Params params) throws IOException {
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.startObject(fieldName);
builder.field("value", convertToStringIfBytesRef(this.value));
builder.field(FuzzyQueryParser.VALUE_FIELD.getPreferredName(), convertToStringIfBytesRef(this.value));
fuzziness.toXContent(builder, params);
builder.field("prefix_length", prefixLength);
builder.field("max_expansions", maxExpansions);
builder.field("transpositions", transpositions);
builder.field(FuzzyQueryParser.PREFIX_LENGTH_FIELD.getPreferredName(), prefixLength);
builder.field(FuzzyQueryParser.MAX_EXPANSIONS_FIELD.getPreferredName(), maxExpansions);
builder.field(FuzzyQueryParser.TRANSPOSITIONS_FIELD.getPreferredName(), transpositions);
if (rewrite != null) {
builder.field("rewrite", rewrite);
builder.field(FuzzyQueryParser.REWRITE_FIELD.getPreferredName(), rewrite);
}
printBoostAndQueryName(builder);
builder.endObject();
@ -231,7 +231,7 @@ public class FuzzyQueryBuilder extends AbstractQueryBuilder<FuzzyQueryBuilder> i
}
@Override
public Query doToQuery(QueryShardContext context) throws IOException {
protected Query doToQuery(QueryShardContext context) throws IOException {
Query query = null;
String rewrite = this.rewrite;
if (rewrite == null && context.isFilter()) {
@ -253,7 +253,7 @@ public class FuzzyQueryBuilder extends AbstractQueryBuilder<FuzzyQueryBuilder> i
}
@Override
public FuzzyQueryBuilder doReadFrom(StreamInput in) throws IOException {
protected FuzzyQueryBuilder doReadFrom(StreamInput in) throws IOException {
FuzzyQueryBuilder fuzzyQueryBuilder = new FuzzyQueryBuilder(in.readString(), in.readGenericValue());
fuzzyQueryBuilder.fuzziness = Fuzziness.readFuzzinessFrom(in);
fuzzyQueryBuilder.prefixLength = in.readVInt();
@ -264,7 +264,7 @@ public class FuzzyQueryBuilder extends AbstractQueryBuilder<FuzzyQueryBuilder> i
}
@Override
public void doWriteTo(StreamOutput out) throws IOException {
protected void doWriteTo(StreamOutput out) throws IOException {
out.writeString(this.fieldName);
out.writeGenericValue(this.value);
this.fuzziness.writeTo(out);
@ -275,12 +275,12 @@ public class FuzzyQueryBuilder extends AbstractQueryBuilder<FuzzyQueryBuilder> i
}
@Override
public int doHashCode() {
protected int doHashCode() {
return Objects.hash(fieldName, value, fuzziness, prefixLength, maxExpansions, transpositions, rewrite);
}
@Override
public boolean doEquals(FuzzyQueryBuilder other) {
protected boolean doEquals(FuzzyQueryBuilder other) {
return Objects.equals(fieldName, other.fieldName) &&
Objects.equals(value, other.value) &&
Objects.equals(fuzziness, other.fuzziness) &&

24
core/src/main/java/org/elasticsearch/index/query/FuzzyQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.common.xcontent.XContentParser;
@ -27,6 +28,13 @@ import java.io.IOException;
public class FuzzyQueryParser implements QueryParser<FuzzyQueryBuilder> {
public static final ParseField TERM_FIELD = new ParseField("term");
public static final ParseField VALUE_FIELD = new ParseField("value");
public static final ParseField PREFIX_LENGTH_FIELD = new ParseField("prefix_length");
public static final ParseField MAX_EXPANSIONS_FIELD = new ParseField("max_expansions");
public static final ParseField TRANSPOSITIONS_FIELD = new ParseField("transpositions");
public static final ParseField REWRITE_FIELD = new ParseField("rewrite");
@Override
public String[] names() {
return new String[]{ FuzzyQueryBuilder.NAME };
@ -60,23 +68,23 @@ public class FuzzyQueryParser implements QueryParser<FuzzyQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else {
if ("term".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, TERM_FIELD)) {
value = parser.objectBytes();
} else if ("value".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, VALUE_FIELD)) {
value = parser.objectBytes();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if (parseContext.parseFieldMatcher().match(currentFieldName, Fuzziness.FIELD)) {
fuzziness = Fuzziness.parse(parser);
} else if ("prefix_length".equals(currentFieldName) || "prefixLength".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, PREFIX_LENGTH_FIELD)) {
prefixLength = parser.intValue();
} else if ("max_expansions".equals(currentFieldName) || "maxExpansions".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MAX_EXPANSIONS_FIELD)) {
maxExpansions = parser.intValue();
} else if ("transpositions".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, TRANSPOSITIONS_FIELD)) {
transpositions = parser.booleanValue();
} else if ("rewrite".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, REWRITE_FIELD)) {
rewrite = parser.textOrNull();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[fuzzy] query does not support [" + currentFieldName + "]");

16
core/src/main/java/org/elasticsearch/index/query/GeoBoundingBoxQueryBuilder.java
View File

@ -292,11 +292,11 @@ public class GeoBoundingBoxQueryBuilder extends AbstractQueryBuilder<GeoBounding
builder.startObject(NAME);
builder.startObject(fieldName);
builder.array(GeoBoundingBoxQueryParser.TOP_LEFT, topLeft.getLon(), topLeft.getLat());
builder.array(GeoBoundingBoxQueryParser.BOTTOM_RIGHT, bottomRight.getLon(), bottomRight.getLat());
builder.array(GeoBoundingBoxQueryParser.TOP_LEFT_FIELD.getPreferredName(), topLeft.getLon(), topLeft.getLat());
builder.array(GeoBoundingBoxQueryParser.BOTTOM_RIGHT_FIELD.getPreferredName(), bottomRight.getLon(), bottomRight.getLat());
builder.endObject();
builder.field("validation_method", validationMethod);
builder.field("type", type);
builder.field(GeoBoundingBoxQueryParser.VALIDATION_METHOD_FIELD.getPreferredName(), validationMethod);
builder.field(GeoBoundingBoxQueryParser.TYPE_FIELD.getPreferredName(), type);
printBoostAndQueryName(builder);
@ -304,7 +304,7 @@ public class GeoBoundingBoxQueryBuilder extends AbstractQueryBuilder<GeoBounding
}
@Override
public boolean doEquals(GeoBoundingBoxQueryBuilder other) {
protected boolean doEquals(GeoBoundingBoxQueryBuilder other) {
return Objects.equals(topLeft, other.topLeft) &&
Objects.equals(bottomRight, other.bottomRight) &&
Objects.equals(type, other.type) &&
@ -313,12 +313,12 @@ public class GeoBoundingBoxQueryBuilder extends AbstractQueryBuilder<GeoBounding
}
@Override
public int doHashCode() {
protected int doHashCode() {
return Objects.hash(topLeft, bottomRight, type, validationMethod, fieldName);
}
@Override
public GeoBoundingBoxQueryBuilder doReadFrom(StreamInput in) throws IOException {
protected GeoBoundingBoxQueryBuilder doReadFrom(StreamInput in) throws IOException {
String fieldName = in.readString();
GeoBoundingBoxQueryBuilder geo = new GeoBoundingBoxQueryBuilder(fieldName);
geo.topLeft = in.readGeoPoint();
@ -329,7 +329,7 @@ public class GeoBoundingBoxQueryBuilder extends AbstractQueryBuilder<GeoBounding
}
@Override
public void doWriteTo(StreamOutput out) throws IOException {
protected void doWriteTo(StreamOutput out) throws IOException {
out.writeString(fieldName);
out.writeGeoPoint(topLeft);
out.writeGeoPoint(bottomRight);

72
core/src/main/java/org/elasticsearch/index/query/GeoBoundingBoxQueryParser.java
View File

@ -20,6 +20,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.ElasticsearchParseException;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.geo.GeoPoint;
import org.elasticsearch.common.geo.GeoUtils;
@ -31,34 +32,19 @@ public class GeoBoundingBoxQueryParser implements QueryParser<GeoBoundingBoxQuer
public static final String NAME = "geo_bbox";
/** Key to refer to the top of the bounding box. */
public static final String TOP = "top";
/** Key to refer to the left of the bounding box. */
public static final String LEFT = "left";
/** Key to refer to the right of the bounding box. */
public static final String RIGHT = "right";
/** Key to refer to the bottom of the bounding box. */
public static final String BOTTOM = "bottom";
/** Key to refer to top_left corner of bounding box. */
public static final String TOP_LEFT = TOP + "_" + LEFT;
/** Key to refer to bottom_right corner of bounding box. */
public static final String BOTTOM_RIGHT = BOTTOM + "_" + RIGHT;
/** Key to refer to top_right corner of bounding box. */
public static final String TOP_RIGHT = TOP + "_" + RIGHT;
/** Key to refer to bottom left corner of bounding box. */
public static final String BOTTOM_LEFT = BOTTOM + "_" + LEFT;
/** Key to refer to top_left corner of bounding box. */
public static final String TOPLEFT = "topLeft";
/** Key to refer to bottom_right corner of bounding box. */
public static final String BOTTOMRIGHT = "bottomRight";
/** Key to refer to top_right corner of bounding box. */
public static final String TOPRIGHT = "topRight";
/** Key to refer to bottom left corner of bounding box. */
public static final String BOTTOMLEFT = "bottomLeft";
public static final String FIELD = "field";
public static final ParseField IGNORE_MALFORMED_FIELD = new ParseField("ignore_malformed");
public static final ParseField TYPE_FIELD = new ParseField("type");
public static final ParseField VALIDATION_METHOD_FIELD = new ParseField("validation_method");
public static final ParseField COERCE_FIELD = new ParseField("coerce", "normalize");
public static final ParseField FIELD_FIELD = new ParseField("field");
public static final ParseField TOP_FIELD = new ParseField("top");
public static final ParseField BOTTOM_FIELD = new ParseField("bottom");
public static final ParseField LEFT_FIELD = new ParseField("left");
public static final ParseField RIGHT_FIELD = new ParseField("right");
public static final ParseField TOP_LEFT_FIELD = new ParseField("top_left");
public static final ParseField BOTTOM_RIGHT_FIELD = new ParseField("bottom_right");
public static final ParseField TOP_RIGHT_FIELD = new ParseField("top_right");
public static final ParseField BOTTOM_LEFT_FIELD = new ParseField("bottom_left");
@Override
public String[] names() {
@ -100,30 +86,30 @@ public class GeoBoundingBoxQueryParser implements QueryParser<GeoBoundingBoxQuer
token = parser.nextToken();
if (parseContext.isDeprecatedSetting(currentFieldName)) {
// skip
} else if (FIELD.equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, FIELD_FIELD)) {
fieldName = parser.text();
} else if (TOP.equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, TOP_FIELD)) {
top = parser.doubleValue();
} else if (BOTTOM.equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, BOTTOM_FIELD)) {
bottom = parser.doubleValue();
} else if (LEFT.equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LEFT_FIELD)) {
left = parser.doubleValue();
} else if (RIGHT.equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, RIGHT_FIELD)) {
right = parser.doubleValue();
} else {
if (TOP_LEFT.equals(currentFieldName) || TOPLEFT.equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, TOP_LEFT_FIELD)) {
GeoUtils.parseGeoPoint(parser, sparse);
top = sparse.getLat();
left = sparse.getLon();
} else if (BOTTOM_RIGHT.equals(currentFieldName) || BOTTOMRIGHT.equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, BOTTOM_RIGHT_FIELD)) {
GeoUtils.parseGeoPoint(parser, sparse);
bottom = sparse.getLat();
right = sparse.getLon();
} else if (TOP_RIGHT.equals(currentFieldName) || TOPRIGHT.equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, TOP_RIGHT_FIELD)) {
GeoUtils.parseGeoPoint(parser, sparse);
top = sparse.getLat();
right = sparse.getLon();
} else if (BOTTOM_LEFT.equals(currentFieldName) || BOTTOMLEFT.equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, BOTTOM_LEFT_FIELD)) {
GeoUtils.parseGeoPoint(parser, sparse);
bottom = sparse.getLat();
left = sparse.getLon();
@ -136,20 +122,20 @@ public class GeoBoundingBoxQueryParser implements QueryParser<GeoBoundingBoxQuer
}
}
} else if (token.isValue()) {
if ("_name".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("coerce".equals(currentFieldName) || ("normalize".equals(currentFieldName))) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, COERCE_FIELD)) {
coerce = parser.booleanValue();
if (coerce) {
ignoreMalformed = true;
}
} else if ("validation_method".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, VALIDATION_METHOD_FIELD)) {
validationMethod = GeoValidationMethod.fromString(parser.text());
} else if ("type".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, TYPE_FIELD)) {
type = parser.text();
} else if ("ignore_malformed".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, IGNORE_MALFORMED_FIELD)) {
ignoreMalformed = parser.booleanValue();
} else {
throw new ParsingException(parser.getTokenLocation(), "failed to parse [{}] query. unexpected field [{}]", NAME, currentFieldName);

12
core/src/main/java/org/elasticsearch/index/query/GeoDistanceQueryBuilder.java
View File

@ -239,21 +239,21 @@ public class GeoDistanceQueryBuilder extends AbstractQueryBuilder<GeoDistanceQue
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.startArray(fieldName).value(center.lon()).value(center.lat()).endArray();
builder.field("distance", distance);
builder.field("distance_type", geoDistance.name().toLowerCase(Locale.ROOT));
builder.field("optimize_bbox", optimizeBbox);
builder.field("validation_method", validationMethod);
builder.field(GeoDistanceQueryParser.DISTANCE_FIELD.getPreferredName(), distance);
builder.field(GeoDistanceQueryParser.DISTANCE_TYPE_FIELD.getPreferredName(), geoDistance.name().toLowerCase(Locale.ROOT));
builder.field(GeoDistanceQueryParser.OPTIMIZE_BBOX_FIELD.getPreferredName(), optimizeBbox);
builder.field(GeoDistanceQueryParser.VALIDATION_METHOD_FIELD.getPreferredName(), validationMethod);
printBoostAndQueryName(builder);
builder.endObject();
}
@Override
public int doHashCode() {
protected int doHashCode() {
return Objects.hash(center, geoDistance, optimizeBbox, distance, validationMethod);
}
@Override
public boolean doEquals(GeoDistanceQueryBuilder other) {
protected boolean doEquals(GeoDistanceQueryBuilder other) {
return Objects.equals(fieldName, other.fieldName) &&
(distance == other.distance) &&
Objects.equals(validationMethod, other.validationMethod) &&

27
core/src/main/java/org/elasticsearch/index/query/GeoDistanceQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.geo.GeoDistance;
import org.elasticsearch.common.geo.GeoPoint;
@ -41,6 +42,14 @@ import java.io.IOException;
*/
public class GeoDistanceQueryParser implements QueryParser<GeoDistanceQueryBuilder> {
public static final ParseField VALIDATION_METHOD_FIELD = new ParseField("validation_method");
public static final ParseField IGNORE_MALFORMED_FIELD = new ParseField("ignore_malformed");
public static final ParseField COERCE_FIELD = new ParseField("coerce", "normalize");
public static final ParseField OPTIMIZE_BBOX_FIELD = new ParseField("optimize_bbox");
public static final ParseField DISTANCE_TYPE_FIELD = new ParseField("distance_type");
public static final ParseField UNIT_FIELD = new ParseField("unit");
public static final ParseField DISTANCE_FIELD = new ParseField("distance");
@Override
public String[] names() {
return new String[]{GeoDistanceQueryBuilder.NAME, "geoDistance"};
@ -95,15 +104,15 @@ public class GeoDistanceQueryParser implements QueryParser<GeoDistanceQueryBuild
}
}
} else if (token.isValue()) {
if ("distance".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, DISTANCE_FIELD)) {
if (token == XContentParser.Token.VALUE_STRING) {
vDistance = parser.text(); // a String
} else {
vDistance = parser.numberValue(); // a Number
}
} else if ("unit".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, UNIT_FIELD)) {
unit = DistanceUnit.fromString(parser.text());
} else if ("distance_type".equals(currentFieldName) || "distanceType".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, DISTANCE_TYPE_FIELD)) {
geoDistance = GeoDistance.fromString(parser.text());
} else if (currentFieldName.endsWith(GeoPointFieldMapper.Names.LAT_SUFFIX)) {
point.resetLat(parser.doubleValue());
@ -114,20 +123,20 @@ public class GeoDistanceQueryParser implements QueryParser<GeoDistanceQueryBuild
} else if (currentFieldName.endsWith(GeoPointFieldMapper.Names.GEOHASH_SUFFIX)) {
point.resetFromGeoHash(parser.text());
fieldName = currentFieldName.substring(0, currentFieldName.length() - GeoPointFieldMapper.Names.GEOHASH_SUFFIX.length());
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("optimize_bbox".equals(currentFieldName) || "optimizeBbox".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, OPTIMIZE_BBOX_FIELD)) {
optimizeBbox = parser.textOrNull();
} else if ("coerce".equals(currentFieldName) || ("normalize".equals(currentFieldName))) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, COERCE_FIELD)) {
coerce = parser.booleanValue();
if (coerce == true) {
ignoreMalformed = true;
}
} else if ("ignore_malformed".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, IGNORE_MALFORMED_FIELD)) {
ignoreMalformed = parser.booleanValue();
} else if ("validation_method".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, VALIDATION_METHOD_FIELD)) {
validationMethod = GeoValidationMethod.fromString(parser.text());
} else {
if (fieldName == null) {

10
core/src/main/java/org/elasticsearch/index/query/HasChildQueryBuilder.java
View File

@ -185,12 +185,12 @@ public class HasChildQueryBuilder extends AbstractQueryBuilder<HasChildQueryBuil
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("query");
builder.field(HasChildQueryParser.QUERY_FIELD.getPreferredName());
query.toXContent(builder, params);
builder.field("child_type", type);
builder.field("score_mode", scoreMode.name().toLowerCase(Locale.ROOT));
builder.field("min_children", minChildren);
builder.field("max_children", maxChildren);
builder.field(HasChildQueryParser.TYPE_FIELD.getPreferredName(), type);
builder.field(HasChildQueryParser.SCORE_MODE_FIELD.getPreferredName(), scoreMode.name().toLowerCase(Locale.ROOT));
builder.field(HasChildQueryParser.MIN_CHILDREN_FIELD.getPreferredName(), minChildren);
builder.field(HasChildQueryParser.MAX_CHILDREN_FIELD.getPreferredName(), maxChildren);
printBoostAndQueryName(builder);
if (queryInnerHits != null) {
queryInnerHits.toXContent(builder, params);

21
core/src/main/java/org/elasticsearch/index/query/HasChildQueryParser.java
View File

@ -33,7 +33,12 @@ import java.io.IOException;
*/
public class HasChildQueryParser implements QueryParser<HasChildQueryBuilder> {
private static final ParseField QUERY_FIELD = new ParseField("query", "filter");
public static final ParseField QUERY_FIELD = new ParseField("query", "filter");
public static final ParseField TYPE_FIELD = new ParseField("type", "child_type");
public static final ParseField MAX_CHILDREN_FIELD = new ParseField("max_children");
public static final ParseField MIN_CHILDREN_FIELD = new ParseField("min_children");
public static final ParseField SCORE_MODE_FIELD = new ParseField("score_mode");
public static final ParseField INNER_HITS_FIELD = new ParseField("inner_hits");
@Override
public String[] names() {
@ -61,23 +66,23 @@ public class HasChildQueryParser implements QueryParser<HasChildQueryBuilder> {
} else if (token == XContentParser.Token.START_OBJECT) {
if (parseContext.parseFieldMatcher().match(currentFieldName, QUERY_FIELD)) {
iqb = parseContext.parseInnerQueryBuilder();
} else if ("inner_hits".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, INNER_HITS_FIELD)) {
queryInnerHits = new QueryInnerHits(parser);
} else {
throw new ParsingException(parser.getTokenLocation(), "[has_child] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("type".equals(currentFieldName) || "child_type".equals(currentFieldName) || "childType".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, TYPE_FIELD)) {
childType = parser.text();
} else if ("score_mode".equals(currentFieldName) || "scoreMode".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, SCORE_MODE_FIELD)) {
scoreMode = parseScoreMode(parser.text());
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("min_children".equals(currentFieldName) || "minChildren".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MIN_CHILDREN_FIELD)) {
minChildren = parser.intValue(true);
} else if ("max_children".equals(currentFieldName) || "maxChildren".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MAX_CHILDREN_FIELD)) {
maxChildren = parser.intValue(true);
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[has_child] query does not support [" + currentFieldName + "]");

6
core/src/main/java/org/elasticsearch/index/query/HasParentQueryBuilder.java
View File

@ -199,10 +199,10 @@ public class HasParentQueryBuilder extends AbstractQueryBuilder<HasParentQueryBu
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("query");
builder.field(HasParentQueryParser.QUERY_FIELD.getPreferredName());
query.toXContent(builder, params);
builder.field("parent_type", type);
builder.field("score", score);
builder.field(HasParentQueryParser.TYPE_FIELD.getPreferredName(), type);
builder.field(HasParentQueryParser.SCORE_FIELD.getPreferredName(), score);
printBoostAndQueryName(builder);
if (innerHit != null) {
innerHit.toXContent(builder, params);

17
core/src/main/java/org/elasticsearch/index/query/HasParentQueryParser.java
View File

@ -30,9 +30,11 @@ import java.io.IOException;
public class HasParentQueryParser implements QueryParser<HasParentQueryBuilder> {
private static final HasParentQueryBuilder PROTOTYPE = new HasParentQueryBuilder("", EmptyQueryBuilder.PROTOTYPE);
private static final ParseField QUERY_FIELD = new ParseField("query", "filter");
private static final ParseField SCORE_FIELD = new ParseField("score_mode").withAllDeprecated("score");
private static final ParseField TYPE_FIELD = new ParseField("parent_type", "type");
public static final ParseField QUERY_FIELD = new ParseField("query", "filter");
//public static final ParseField SCORE_MODE_FIELD = new ParseField("score_mode").withAllDeprecated("score");
public static final ParseField SCORE_MODE_FIELD = new ParseField("score_mode").withAllDeprecated("score");
public static final ParseField TYPE_FIELD = new ParseField("parent_type", "type");
public static final ParseField SCORE_FIELD = new ParseField("score");
@Override
public String[] names() {
@ -42,7 +44,6 @@ public class HasParentQueryParser implements QueryParser<HasParentQueryBuilder>
@Override
public HasParentQueryBuilder fromXContent(QueryParseContext parseContext) throws IOException {
XContentParser parser = parseContext.parser();
float boost = AbstractQueryBuilder.DEFAULT_BOOST;
String parentType = null;
boolean score = HasParentQueryBuilder.DEFAULT_SCORE;
@ -66,7 +67,7 @@ public class HasParentQueryParser implements QueryParser<HasParentQueryBuilder>
} else if (token.isValue()) {
if (parseContext.parseFieldMatcher().match(currentFieldName, TYPE_FIELD)) {
parentType = parser.text();
} else if (parseContext.parseFieldMatcher().match(currentFieldName, SCORE_FIELD)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, SCORE_MODE_FIELD)) {
String scoreModeValue = parser.text();
if ("score".equals(scoreModeValue)) {
score = true;
@ -75,11 +76,11 @@ public class HasParentQueryParser implements QueryParser<HasParentQueryBuilder>
} else {
throw new ParsingException(parser.getTokenLocation(), "[has_parent] query does not support [" + scoreModeValue + "] as an option for score_mode");
}
} else if ("score".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, SCORE_FIELD)) {
score = parser.booleanValue();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[has_parent] query does not support [" + currentFieldName + "]");

4
core/src/main/java/org/elasticsearch/index/query/IdsQueryBuilder.java
View File

@ -90,8 +90,8 @@ public class IdsQueryBuilder extends AbstractQueryBuilder<IdsQueryBuilder> {
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.array("types", types);
builder.startArray("values");
builder.array(IdsQueryParser.TYPE_FIELD.getPreferredName(), types);
builder.startArray(IdsQueryParser.VALUES_FIELD.getPreferredName());
for (String value : ids) {
builder.value(value);
}

15
core/src/main/java/org/elasticsearch/index/query/IdsQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.xcontent.XContentParser;
@ -32,6 +33,10 @@ import java.util.List;
*/
public class IdsQueryParser implements QueryParser<IdsQueryBuilder> {
public static final ParseField TYPE_FIELD = new ParseField("type", "types", "_type");
public static final ParseField VALUES_FIELD = new ParseField("values");
@Override
public String[] names() {
return new String[]{IdsQueryBuilder.NAME};
@ -55,7 +60,7 @@ public class IdsQueryParser implements QueryParser<IdsQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_ARRAY) {
if ("values".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, VALUES_FIELD)) {
idsProvided = true;
while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
if ((token == XContentParser.Token.VALUE_STRING) ||
@ -70,7 +75,7 @@ public class IdsQueryParser implements QueryParser<IdsQueryBuilder> {
+ token);
}
}
} else if ("types".equals(currentFieldName) || "type".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, TYPE_FIELD)) {
while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
String value = parser.textOrNull();
if (value == null) {
@ -82,11 +87,11 @@ public class IdsQueryParser implements QueryParser<IdsQueryBuilder> {
throw new ParsingException(parser.getTokenLocation(), "[" + IdsQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("type".equals(currentFieldName) || "_type".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, TYPE_FIELD)) {
types = Collections.singletonList(parser.text());
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[" + IdsQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");

6
core/src/main/java/org/elasticsearch/index/query/IndicesQueryBuilder.java
View File

@ -93,10 +93,10 @@ public class IndicesQueryBuilder extends AbstractQueryBuilder<IndicesQueryBuilde
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("indices", indices);
builder.field("query");
builder.field(IndicesQueryParser.INDICES_FIELD.getPreferredName(), indices);
builder.field(IndicesQueryParser.QUERY_FIELD.getPreferredName());
innerQuery.toXContent(builder, params);
builder.field("no_match_query");
builder.field(IndicesQueryParser.NO_MATCH_QUERY.getPreferredName());
noMatchQuery.toXContent(builder, params);
printBoostAndQueryName(builder);
builder.endObject();

15
core/src/main/java/org/elasticsearch/index/query/IndicesQueryParser.java
View File

@ -32,8 +32,11 @@ import java.util.Collection;
*/
public class IndicesQueryParser implements QueryParser {
private static final ParseField QUERY_FIELD = new ParseField("query");
private static final ParseField NO_MATCH_QUERY = new ParseField("no_match_query");
public static final ParseField QUERY_FIELD = new ParseField("query");
public static final ParseField NO_MATCH_QUERY = new ParseField("no_match_query");
public static final ParseField INDEX_FIELD = new ParseField("index");
public static final ParseField INDICES_FIELD = new ParseField("indices");
@Override
public String[] names() {
@ -65,7 +68,7 @@ public class IndicesQueryParser implements QueryParser {
throw new ParsingException(parser.getTokenLocation(), "[indices] query does not support [" + currentFieldName + "]");
}
} else if (token == XContentParser.Token.START_ARRAY) {
if ("indices".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, INDICES_FIELD)) {
if (indices.isEmpty() == false) {
throw new ParsingException(parser.getTokenLocation(), "[indices] indices or index already specified");
}
@ -80,16 +83,16 @@ public class IndicesQueryParser implements QueryParser {
throw new ParsingException(parser.getTokenLocation(), "[indices] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("index".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, INDEX_FIELD)) {
if (indices.isEmpty() == false) {
throw new ParsingException(parser.getTokenLocation(), "[indices] indices or index already specified");
}
indices.add(parser.text());
} else if (parseContext.parseFieldMatcher().match(currentFieldName, NO_MATCH_QUERY)) {
noMatchQuery = parseNoMatchQuery(parser.text());
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else {
throw new ParsingException(parser.getTokenLocation(), "[indices] query does not support [" + currentFieldName + "]");

4
core/src/main/java/org/elasticsearch/index/query/MatchAllQueryParser.java
View File

@ -47,9 +47,9 @@ public class MatchAllQueryParser implements QueryParser<MatchAllQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token.isValue()) {
if ("_name".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else {
throw new ParsingException(parser.getTokenLocation(), "[" + MatchAllQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");

4
core/src/main/java/org/elasticsearch/index/query/MatchNoneQueryParser.java
View File

@ -44,9 +44,9 @@ public class MatchNoneQueryParser implements QueryParser<MatchNoneQueryBuilder>
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token.isValue()) {
if ("_name".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else {
throw new ParsingException(parser.getTokenLocation(), "["+MatchNoneQueryBuilder.NAME+"] query does not support [" + currentFieldName + "]");

31
core/src/main/java/org/elasticsearch/index/query/MatchQueryBuilder.java
View File

@ -129,6 +129,11 @@ public class MatchQueryBuilder extends AbstractQueryBuilder<MatchQueryBuilder> {
return this;
}
/** Returns the operator to use in a boolean query.*/
public Operator operator() {
return this.operator;
}
/**
* Explicitly set the analyzer to use. Defaults to use explicit mapping config for the field, or, if not
* set, the default search analyzer.
@ -312,30 +317,30 @@ public class MatchQueryBuilder extends AbstractQueryBuilder<MatchQueryBuilder> {
builder.startObject(NAME);
builder.startObject(fieldName);
builder.field("query", value);
builder.field("type", type.toString().toLowerCase(Locale.ENGLISH));
builder.field("operator", operator.toString());
builder.field(MatchQueryParser.QUERY_FIELD.getPreferredName(), value);
builder.field(MatchQueryParser.TYPE_FIELD.getPreferredName(), type.toString().toLowerCase(Locale.ENGLISH));
builder.field(MatchQueryParser.OPERATOR_FIELD.getPreferredName(), operator.toString());
if (analyzer != null) {
builder.field("analyzer", analyzer);
builder.field(MatchQueryParser.ANALYZER_FIELD.getPreferredName(), analyzer);
}
builder.field("slop", slop);
builder.field(MatchQueryParser.SLOP_FIELD.getPreferredName(), slop);
if (fuzziness != null) {
fuzziness.toXContent(builder, params);
}
builder.field("prefix_length", prefixLength);
builder.field("max_expansions", maxExpansions);
builder.field(MatchQueryParser.PREFIX_LENGTH_FIELD.getPreferredName(), prefixLength);
builder.field(MatchQueryParser.MAX_EXPANSIONS_FIELD.getPreferredName(), maxExpansions);
if (minimumShouldMatch != null) {
builder.field("minimum_should_match", minimumShouldMatch);
builder.field(MatchQueryParser.MINIMUM_SHOULD_MATCH_FIELD.getPreferredName(), minimumShouldMatch);
}
if (fuzzyRewrite != null) {
builder.field("fuzzy_rewrite", fuzzyRewrite);
builder.field(MatchQueryParser.FUZZY_REWRITE_FIELD.getPreferredName(), fuzzyRewrite);
}
// LUCENE 4 UPGRADE we need to document this & test this
builder.field("fuzzy_transpositions", fuzzyTranspositions);
builder.field("lenient", lenient);
builder.field("zero_terms_query", zeroTermsQuery.toString());
builder.field(MatchQueryParser.FUZZY_TRANSPOSITIONS_FIELD.getPreferredName(), fuzzyTranspositions);
builder.field(MatchQueryParser.LENIENT_FIELD.getPreferredName(), lenient);
builder.field(MatchQueryParser.ZERO_TERMS_QUERY_FIELD.getPreferredName(), zeroTermsQuery.toString());
if (cutoffFrequency != null) {
builder.field("cutoff_frequency", cutoffFrequency);
builder.field(MatchQueryParser.CUTOFF_FREQUENCY_FIELD.getPreferredName(), cutoffFrequency);
}
printBoostAndQueryName(builder);
builder.endObject();

55
core/src/main/java/org/elasticsearch/index/query/MatchQueryParser.java
View File

@ -20,6 +20,7 @@
package org.elasticsearch.index.query;
import org.apache.lucene.search.FuzzyQuery;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.common.xcontent.XContentParser;
@ -33,6 +34,22 @@ import java.io.IOException;
*/
public class MatchQueryParser implements QueryParser<MatchQueryBuilder> {
public static final ParseField MATCH_PHRASE_FIELD = new ParseField("match_phrase", "text_phrase");
public static final ParseField MATCH_PHRASE_PREFIX_FIELD = new ParseField("match_phrase_prefix", "text_phrase_prefix");
public static final ParseField SLOP_FIELD = new ParseField("slop", "phrase_slop");
public static final ParseField ZERO_TERMS_QUERY_FIELD = new ParseField("zero_terms_query");
public static final ParseField CUTOFF_FREQUENCY_FIELD = new ParseField("cutoff_frequency");
public static final ParseField LENIENT_FIELD = new ParseField("lenient");
public static final ParseField FUZZY_TRANSPOSITIONS_FIELD = new ParseField("fuzzy_transpositions");
public static final ParseField FUZZY_REWRITE_FIELD = new ParseField("fuzzy_rewrite");
public static final ParseField MINIMUM_SHOULD_MATCH_FIELD = new ParseField("minimum_should_match");
public static final ParseField OPERATOR_FIELD = new ParseField("operator");
public static final ParseField MAX_EXPANSIONS_FIELD = new ParseField("max_expansions");
public static final ParseField PREFIX_LENGTH_FIELD = new ParseField("prefix_length");
public static final ParseField ANALYZER_FIELD = new ParseField("analyzer");
public static final ParseField TYPE_FIELD = new ParseField("type");
public static final ParseField QUERY_FIELD = new ParseField("query");
@Override
public String[] names() {
return new String[]{
@ -45,11 +62,9 @@ public class MatchQueryParser implements QueryParser<MatchQueryBuilder> {
XContentParser parser = parseContext.parser();
MatchQuery.Type type = MatchQuery.Type.BOOLEAN;
if ("match_phrase".equals(parser.currentName()) || "matchPhrase".equals(parser.currentName()) ||
"text_phrase".equals(parser.currentName()) || "textPhrase".equals(parser.currentName())) {
if (parseContext.parseFieldMatcher().match(parser.currentName(), MATCH_PHRASE_FIELD)) {
type = MatchQuery.Type.PHRASE;
} else if ("match_phrase_prefix".equals(parser.currentName()) || "matchPhrasePrefix".equals(parser.currentName()) ||
"text_phrase_prefix".equals(parser.currentName()) || "textPhrasePrefix".equals(parser.currentName())) {
} else if (parseContext.parseFieldMatcher().match(parser.currentName(), MATCH_PHRASE_PREFIX_FIELD)) {
type = MatchQuery.Type.PHRASE_PREFIX;
}
@ -82,44 +97,44 @@ public class MatchQueryParser implements QueryParser<MatchQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token.isValue()) {
if ("query".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, QUERY_FIELD)) {
value = parser.objectText();
} else if ("type".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, TYPE_FIELD)) {
String tStr = parser.text();
if ("boolean".equals(tStr)) {
type = MatchQuery.Type.BOOLEAN;
} else if ("phrase".equals(tStr)) {
type = MatchQuery.Type.PHRASE;
} else if ("phrase_prefix".equals(tStr) || "phrasePrefix".equals(currentFieldName)) {
} else if ("phrase_prefix".equals(tStr) || ("phrasePrefix".equals(tStr))) {
type = MatchQuery.Type.PHRASE_PREFIX;
} else {
throw new ParsingException(parser.getTokenLocation(), "[" + MatchQueryBuilder.NAME + "] query does not support type " + tStr);
}
} else if ("analyzer".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, ANALYZER_FIELD)) {
analyzer = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("slop".equals(currentFieldName) || "phrase_slop".equals(currentFieldName) || "phraseSlop".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, SLOP_FIELD)) {
slop = parser.intValue();
} else if (parseContext.parseFieldMatcher().match(currentFieldName, Fuzziness.FIELD)) {
fuzziness = Fuzziness.parse(parser);
} else if ("prefix_length".equals(currentFieldName) || "prefixLength".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, PREFIX_LENGTH_FIELD)) {
prefixLength = parser.intValue();
} else if ("max_expansions".equals(currentFieldName) || "maxExpansions".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MAX_EXPANSIONS_FIELD)) {
maxExpansion = parser.intValue();
} else if ("operator".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, OPERATOR_FIELD)) {
operator = Operator.fromString(parser.text());
} else if ("minimum_should_match".equals(currentFieldName) || "minimumShouldMatch".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MINIMUM_SHOULD_MATCH_FIELD)) {
minimumShouldMatch = parser.textOrNull();
} else if ("fuzzy_rewrite".equals(currentFieldName) || "fuzzyRewrite".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, FUZZY_REWRITE_FIELD)) {
fuzzyRewrite = parser.textOrNull();
} else if ("fuzzy_transpositions".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, FUZZY_TRANSPOSITIONS_FIELD)) {
fuzzyTranspositions = parser.booleanValue();
} else if ("lenient".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LENIENT_FIELD)) {
lenient = parser.booleanValue();
} else if ("cutoff_frequency".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, CUTOFF_FREQUENCY_FIELD)) {
cutOffFrequency = parser.floatValue();
} else if ("zero_terms_query".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, ZERO_TERMS_QUERY_FIELD)) {
String zeroTermsDocs = parser.text();
if ("none".equalsIgnoreCase(zeroTermsDocs)) {
zeroTermsQuery = MatchQuery.ZeroTermsQuery.NONE;
@ -128,7 +143,7 @@ public class MatchQueryParser implements QueryParser<MatchQueryBuilder> {
} else {
throw new ParsingException(parser.getTokenLocation(), "Unsupported zero_terms_docs value [" + zeroTermsDocs + "]");
}
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[" + MatchQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");

6
core/src/main/java/org/elasticsearch/index/query/MissingQueryBuilder.java
View File

@ -104,9 +104,9 @@ public class MissingQueryBuilder extends AbstractQueryBuilder<MissingQueryBuilde
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("field", fieldPattern);
builder.field("null_value", nullValue);
builder.field("existence", existence);
builder.field(MissingQueryParser.FIELD_FIELD.getPreferredName(), fieldPattern);
builder.field(MissingQueryParser.NULL_VALUE_FIELD.getPreferredName(), nullValue);
builder.field(MissingQueryParser.EXISTENCE_FIELD.getPreferredName(), existence);
printBoostAndQueryName(builder);
builder.endObject();
}

15
core/src/main/java/org/elasticsearch/index/query/MissingQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.xcontent.XContentParser;
@ -29,6 +30,10 @@ import java.io.IOException;
*/
public class MissingQueryParser implements QueryParser<MissingQueryBuilder> {
public static final ParseField FIELD_FIELD = new ParseField("field");
public static final ParseField NULL_VALUE_FIELD = new ParseField("null_value");
public static final ParseField EXISTENCE_FIELD = new ParseField("existence");
@Override
public String[] names() {
return new String[]{MissingQueryBuilder.NAME};
@ -50,15 +55,15 @@ public class MissingQueryParser implements QueryParser<MissingQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token.isValue()) {
if ("field".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, FIELD_FIELD)) {
fieldPattern = parser.text();
} else if ("null_value".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, NULL_VALUE_FIELD)) {
nullValue = parser.booleanValue();
} else if ("existence".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, EXISTENCE_FIELD)) {
existence = parser.booleanValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else {
throw new ParsingException(parser.getTokenLocation(), "[" + MissingQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");

30
core/src/main/java/org/elasticsearch/index/query/MultiMatchQueryBuilder.java
View File

@ -457,40 +457,40 @@ public class MultiMatchQueryBuilder extends AbstractQueryBuilder<MultiMatchQuery
@Override
public void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("query", value);
builder.startArray("fields");
builder.field(MultiMatchQueryParser.QUERY_FIELD.getPreferredName(), value);
builder.startArray(MultiMatchQueryParser.FIELDS_FIELD.getPreferredName());
for (Map.Entry<String, Float> fieldEntry : this.fieldsBoosts.entrySet()) {
builder.value(fieldEntry.getKey() + "^" + fieldEntry.getValue());
}
builder.endArray();
builder.field("type", type.toString().toLowerCase(Locale.ENGLISH));
builder.field("operator", operator.toString());
builder.field(MultiMatchQueryParser.TYPE_FIELD.getPreferredName(), type.toString().toLowerCase(Locale.ENGLISH));
builder.field(MultiMatchQueryParser.OPERATOR_FIELD.getPreferredName(), operator.toString());
if (analyzer != null) {
builder.field("analyzer", analyzer);
builder.field(MultiMatchQueryParser.ANALYZER_FIELD.getPreferredName(), analyzer);
}
builder.field("slop", slop);
builder.field(MultiMatchQueryParser.SLOP_FIELD.getPreferredName(), slop);
if (fuzziness != null) {
fuzziness.toXContent(builder, params);
}
builder.field("prefix_length", prefixLength);
builder.field("max_expansions", maxExpansions);
builder.field(MultiMatchQueryParser.PREFIX_LENGTH_FIELD.getPreferredName(), prefixLength);
builder.field(MultiMatchQueryParser.MAX_EXPANSIONS_FIELD.getPreferredName(), maxExpansions);
if (minimumShouldMatch != null) {
builder.field("minimum_should_match", minimumShouldMatch);
builder.field(MultiMatchQueryParser.MINIMUM_SHOULD_MATCH_FIELD.getPreferredName(), minimumShouldMatch);
}
if (fuzzyRewrite != null) {
builder.field("fuzzy_rewrite", fuzzyRewrite);
builder.field(MultiMatchQueryParser.FUZZY_REWRITE_FIELD.getPreferredName(), fuzzyRewrite);
}
if (useDisMax != null) {
builder.field("use_dis_max", useDisMax);
builder.field(MultiMatchQueryParser.USE_DIS_MAX_FIELD.getPreferredName(), useDisMax);
}
if (tieBreaker != null) {
builder.field("tie_breaker", tieBreaker);
builder.field(MultiMatchQueryParser.TIE_BREAKER_FIELD.getPreferredName(), tieBreaker);
}
builder.field("lenient", lenient);
builder.field(MultiMatchQueryParser.LENIENT_FIELD.getPreferredName(), lenient);
if (cutoffFrequency != null) {
builder.field("cutoff_frequency", cutoffFrequency);
builder.field(MultiMatchQueryParser.CUTOFF_FREQUENCY_FIELD.getPreferredName(), cutoffFrequency);
}
builder.field("zero_terms_query", zeroTermsQuery.toString());
builder.field(MultiMatchQueryParser.ZERO_TERMS_QUERY_FIELD.getPreferredName(), zeroTermsQuery.toString());
printBoostAndQueryName(builder);
builder.endObject();
}

52
core/src/main/java/org/elasticsearch/index/query/MultiMatchQueryParser.java
View File

@ -19,9 +19,11 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.unit.Fuzziness;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.index.query.MoreLikeThisQueryParser.Field;
import org.elasticsearch.index.search.MatchQuery;
import java.io.IOException;
@ -33,6 +35,22 @@ import java.util.Map;
*/
public class MultiMatchQueryParser implements QueryParser<MultiMatchQueryBuilder> {
public static final ParseField SLOP_FIELD = new ParseField("slop", "phrase_slop");
public static final ParseField ZERO_TERMS_QUERY_FIELD = new ParseField("zero_terms_query");
public static final ParseField LENIENT_FIELD = new ParseField("lenient");
public static final ParseField CUTOFF_FREQUENCY_FIELD = new ParseField("cutoff_frequency");
public static final ParseField TIE_BREAKER_FIELD = new ParseField("tie_breaker");
public static final ParseField USE_DIS_MAX_FIELD = new ParseField("use_dis_max");
public static final ParseField FUZZY_REWRITE_FIELD = new ParseField("fuzzy_rewrite");
public static final ParseField MINIMUM_SHOULD_MATCH_FIELD = new ParseField("minimum_should_match");
public static final ParseField OPERATOR_FIELD = new ParseField("operator");
public static final ParseField MAX_EXPANSIONS_FIELD = new ParseField("max_expansions");
public static final ParseField PREFIX_LENGTH_FIELD = new ParseField("prefix_length");
public static final ParseField ANALYZER_FIELD = new ParseField("analyzer");
public static final ParseField TYPE_FIELD = new ParseField("type");
public static final ParseField QUERY_FIELD = new ParseField("query");
public static final ParseField FIELDS_FIELD = new ParseField("fields");
@Override
public String[] names() {
return new String[]{
@ -69,7 +87,7 @@ public class MultiMatchQueryParser implements QueryParser<MultiMatchQueryBuilder
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if ("fields".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, FIELDS_FIELD)) {
if (token == XContentParser.Token.START_ARRAY) {
while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
parseFieldAndBoost(parser, fieldsBoosts);
@ -80,37 +98,37 @@ public class MultiMatchQueryParser implements QueryParser<MultiMatchQueryBuilder
throw new ParsingException(parser.getTokenLocation(), "[" + MultiMatchQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("query".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, QUERY_FIELD)) {
value = parser.objectText();
} else if ("type".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, TYPE_FIELD)) {
type = MultiMatchQueryBuilder.Type.parse(parser.text(), parseContext.parseFieldMatcher());
} else if ("analyzer".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, ANALYZER_FIELD)) {
analyzer = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("slop".equals(currentFieldName) || "phrase_slop".equals(currentFieldName) || "phraseSlop".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, SLOP_FIELD)) {
slop = parser.intValue();
} else if (parseContext.parseFieldMatcher().match(currentFieldName, Fuzziness.FIELD)) {
fuzziness = Fuzziness.parse(parser);
} else if ("prefix_length".equals(currentFieldName) || "prefixLength".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, PREFIX_LENGTH_FIELD)) {
prefixLength = parser.intValue();
} else if ("max_expansions".equals(currentFieldName) || "maxExpansions".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MAX_EXPANSIONS_FIELD)) {
maxExpansions = parser.intValue();
} else if ("operator".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, OPERATOR_FIELD)) {
operator = Operator.fromString(parser.text());
} else if ("minimum_should_match".equals(currentFieldName) || "minimumShouldMatch".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MINIMUM_SHOULD_MATCH_FIELD)) {
minimumShouldMatch = parser.textOrNull();
} else if ("fuzzy_rewrite".equals(currentFieldName) || "fuzzyRewrite".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, FUZZY_REWRITE_FIELD)) {
fuzzyRewrite = parser.textOrNull();
} else if ("use_dis_max".equals(currentFieldName) || "useDisMax".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, USE_DIS_MAX_FIELD)) {
useDisMax = parser.booleanValue();
} else if ("tie_breaker".equals(currentFieldName) || "tieBreaker".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, TIE_BREAKER_FIELD)) {
tieBreaker = parser.floatValue();
} else if ("cutoff_frequency".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, CUTOFF_FREQUENCY_FIELD)) {
cutoffFrequency = parser.floatValue();
} else if ("lenient".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LENIENT_FIELD)) {
lenient = parser.booleanValue();
} else if ("zero_terms_query".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, ZERO_TERMS_QUERY_FIELD)) {
String zeroTermsDocs = parser.text();
if ("none".equalsIgnoreCase(zeroTermsDocs)) {
zeroTermsQuery = MatchQuery.ZeroTermsQuery.NONE;
@ -119,7 +137,7 @@ public class MultiMatchQueryParser implements QueryParser<MultiMatchQueryBuilder
} else {
throw new ParsingException(parser.getTokenLocation(), "Unsupported zero_terms_docs value [" + zeroTermsDocs + "]");
}
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[" + MultiMatchQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");

6
core/src/main/java/org/elasticsearch/index/query/NestedQueryBuilder.java
View File

@ -117,11 +117,11 @@ public class NestedQueryBuilder extends AbstractQueryBuilder<NestedQueryBuilder>
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("query");
builder.field(NestedQueryParser.QUERY_FIELD.getPreferredName());
query.toXContent(builder, params);
builder.field("path", path);
builder.field(NestedQueryParser.PATH_FIELD.getPreferredName(), path);
if (scoreMode != null) {
builder.field("score_mode", scoreMode.name().toLowerCase(Locale.ROOT));
builder.field(NestedQueryParser.SCORE_MODE_FIELD.getPreferredName(), scoreMode.name().toLowerCase(Locale.ROOT));
}
printBoostAndQueryName(builder);
if (queryInnerHits != null) {

17
core/src/main/java/org/elasticsearch/index/query/NestedQueryParser.java
View File

@ -20,6 +20,7 @@
package org.elasticsearch.index.query;
import org.apache.lucene.search.join.ScoreMode;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
@ -30,6 +31,10 @@ import java.io.IOException;
public class NestedQueryParser implements QueryParser<NestedQueryBuilder> {
private static final NestedQueryBuilder PROTOTYPE = new NestedQueryBuilder("", EmptyQueryBuilder.PROTOTYPE);
public static final ParseField SCORE_MODE_FIELD = new ParseField("score_mode");
public static final ParseField PATH_FIELD = new ParseField("path");
public static final ParseField QUERY_FIELD = new ParseField("query");
public static final ParseField INNER_HITS_FIELD = new ParseField("inner_hits");
@Override
public String[] names() {
@ -51,19 +56,19 @@ public class NestedQueryParser implements QueryParser<NestedQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if ("query".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, QUERY_FIELD)) {
query = parseContext.parseInnerQueryBuilder();
} else if ("inner_hits".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, INNER_HITS_FIELD)) {
queryInnerHits = new QueryInnerHits(parser);
} else {
throw new ParsingException(parser.getTokenLocation(), "[nested] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("path".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, PATH_FIELD)) {
path = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("score_mode".equals(currentFieldName) || "scoreMode".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, SCORE_MODE_FIELD)) {
String sScoreMode = parser.text();
if ("avg".equals(sScoreMode)) {
scoreMode = ScoreMode.Avg;
@ -78,7 +83,7 @@ public class NestedQueryParser implements QueryParser<NestedQueryBuilder> {
} else {
throw new ParsingException(parser.getTokenLocation(), "illegal score_mode for nested query [" + sScoreMode + "]");
}
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[nested] query does not support [" + currentFieldName + "]");

4
core/src/main/java/org/elasticsearch/index/query/PrefixQueryBuilder.java
View File

@ -87,9 +87,9 @@ public class PrefixQueryBuilder extends AbstractQueryBuilder<PrefixQueryBuilder>
public void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.startObject(fieldName);
builder.field("prefix", this.value);
builder.field(PrefixQueryParser.PREFIX_FIELD.getPreferredName(), this.value);
if (rewrite != null) {
builder.field("rewrite", rewrite);
builder.field(PrefixQueryParser.REWRITE_FIELD.getPreferredName(), rewrite);
}
printBoostAndQueryName(builder);
builder.endObject();

15
core/src/main/java/org/elasticsearch/index/query/PrefixQueryParser.java
View File

@ -30,7 +30,8 @@ import java.io.IOException;
*/
public class PrefixQueryParser implements QueryParser<PrefixQueryBuilder> {
private static final ParseField NAME_FIELD = new ParseField("_name").withAllDeprecated("query name is not supported in short version of prefix query");
public static final ParseField PREFIX_FIELD = new ParseField("value", "prefix");
public static final ParseField REWRITE_FIELD = new ParseField("rewrite");
@Override
public String[] names() {
@ -60,13 +61,13 @@ public class PrefixQueryParser implements QueryParser<PrefixQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else {
if ("_name".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("value".equals(currentFieldName) || "prefix".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, PREFIX_FIELD)) {
value = parser.textOrNull();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("rewrite".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, REWRITE_FIELD)) {
rewrite = parser.textOrNull();
} else {
throw new ParsingException(parser.getTokenLocation(), "[regexp] query does not support [" + currentFieldName + "]");
@ -74,12 +75,8 @@ public class PrefixQueryParser implements QueryParser<PrefixQueryBuilder> {
}
}
} else {
if (parseContext.parseFieldMatcher().match(currentFieldName, NAME_FIELD)) {
queryName = parser.text();
} else {
fieldName = currentFieldName;
value = parser.textOrNull();
}
}
}

50
core/src/main/java/org/elasticsearch/index/query/QueryStringQueryBuilder.java
View File

@ -468,58 +468,58 @@ public class QueryStringQueryBuilder extends AbstractQueryBuilder<QueryStringQue
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("query", this.queryString);
builder.field(QueryStringQueryParser.QUERY_FIELD.getPreferredName(), this.queryString);
if (this.defaultField != null) {
builder.field("default_field", this.defaultField);
builder.field(QueryStringQueryParser.DEFAULT_FIELD_FIELD.getPreferredName(), this.defaultField);
}
builder.startArray("fields");
builder.startArray(QueryStringQueryParser.FIELDS_FIELD.getPreferredName());
for (Map.Entry<String, Float> fieldEntry : this.fieldsAndWeights.entrySet()) {
builder.value(fieldEntry.getKey() + "^" + fieldEntry.getValue());
}
builder.endArray();
builder.field("use_dis_max", this.useDisMax);
builder.field("tie_breaker", this.tieBreaker);
builder.field("default_operator", this.defaultOperator.name().toLowerCase(Locale.ROOT));
builder.field(QueryStringQueryParser.USE_DIS_MAX_FIELD.getPreferredName(), this.useDisMax);
builder.field(QueryStringQueryParser.TIE_BREAKER_FIELD.getPreferredName(), this.tieBreaker);
builder.field(QueryStringQueryParser.DEFAULT_OPERATOR_FIELD.getPreferredName(), this.defaultOperator.name().toLowerCase(Locale.ROOT));
if (this.analyzer != null) {
builder.field("analyzer", this.analyzer);
builder.field(QueryStringQueryParser.ANALYZER_FIELD.getPreferredName(), this.analyzer);
}
if (this.quoteAnalyzer != null) {
builder.field("quote_analyzer", this.quoteAnalyzer);
builder.field(QueryStringQueryParser.QUOTE_ANALYZER_FIELD.getPreferredName(), this.quoteAnalyzer);
}
builder.field("auto_generate_phrase_queries", this.autoGeneratePhraseQueries);
builder.field("max_determinized_states", this.maxDeterminizedStates);
builder.field(QueryStringQueryParser.AUTO_GENERATED_PHRASE_QUERIES_FIELD.getPreferredName(), this.autoGeneratePhraseQueries);
builder.field(QueryStringQueryParser.MAX_DETERMINED_STATES_FIELD.getPreferredName(), this.maxDeterminizedStates);
if (this.allowLeadingWildcard != null) {
builder.field("allow_leading_wildcard", this.allowLeadingWildcard);
builder.field(QueryStringQueryParser.ALLOW_LEADING_WILDCARD_FIELD.getPreferredName(), this.allowLeadingWildcard);
}
builder.field("lowercase_expanded_terms", this.lowercaseExpandedTerms);
builder.field("enable_position_increments", this.enablePositionIncrements);
builder.field(QueryStringQueryParser.LOWERCASE_EXPANDED_TERMS_FIELD.getPreferredName(), this.lowercaseExpandedTerms);
builder.field(QueryStringQueryParser.ENABLE_POSITION_INCREMENTS_FIELD.getPreferredName(), this.enablePositionIncrements);
this.fuzziness.toXContent(builder, params);
builder.field("fuzzy_prefix_length", this.fuzzyPrefixLength);
builder.field("fuzzy_max_expansions", this.fuzzyMaxExpansions);
builder.field(QueryStringQueryParser.FUZZY_PREFIX_LENGTH_FIELD.getPreferredName(), this.fuzzyPrefixLength);
builder.field(QueryStringQueryParser.FUZZY_MAX_EXPANSIONS_FIELD.getPreferredName(), this.fuzzyMaxExpansions);
if (this.fuzzyRewrite != null) {
builder.field("fuzzy_rewrite", this.fuzzyRewrite);
builder.field(QueryStringQueryParser.FUZZY_REWRITE_FIELD.getPreferredName(), this.fuzzyRewrite);
}
builder.field("phrase_slop", this.phraseSlop);
builder.field(QueryStringQueryParser.PHRASE_SLOP_FIELD.getPreferredName(), this.phraseSlop);
if (this.analyzeWildcard != null) {
builder.field("analyze_wildcard", this.analyzeWildcard);
builder.field(QueryStringQueryParser.ANALYZE_WILDCARD_FIELD.getPreferredName(), this.analyzeWildcard);
}
if (this.rewrite != null) {
builder.field("rewrite", this.rewrite);
builder.field(QueryStringQueryParser.REWRITE_FIELD.getPreferredName(), this.rewrite);
}
if (this.minimumShouldMatch != null) {
builder.field("minimum_should_match", this.minimumShouldMatch);
builder.field(QueryStringQueryParser.MINIMUM_SHOULD_MATCH_FIELD.getPreferredName(), this.minimumShouldMatch);
}
if (this.quoteFieldSuffix != null) {
builder.field("quote_field_suffix", this.quoteFieldSuffix);
builder.field(QueryStringQueryParser.QUOTE_FIELD_SUFFIX_FIELD.getPreferredName(), this.quoteFieldSuffix);
}
if (this.lenient != null) {
builder.field("lenient", this.lenient);
builder.field(QueryStringQueryParser.LENIENT_FIELD.getPreferredName(), this.lenient);
}
builder.field("locale", this.locale.toLanguageTag());
builder.field(QueryStringQueryParser.LOCALE_FIELD.getPreferredName(), this.locale.toLanguageTag());
if (this.timeZone != null) {
builder.field("time_zone", this.timeZone.getID());
builder.field(QueryStringQueryParser.TIME_ZONE_FIELD.getPreferredName(), this.timeZone.getID());
}
builder.field("escape", this.escape);
builder.field(QueryStringQueryParser.ESCAPE_FIELD.getPreferredName(), this.escape);
printBoostAndQueryName(builder);
builder.endObject();
}

81
core/src/main/java/org/elasticsearch/index/query/QueryStringQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.unit.Fuzziness;
@ -34,6 +35,32 @@ import java.util.Map;
*/
public class QueryStringQueryParser implements QueryParser {
public static final ParseField QUERY_FIELD = new ParseField("query");
public static final ParseField FIELDS_FIELD = new ParseField("fields");
public static final ParseField DEFAULT_FIELD_FIELD = new ParseField("default_field");
public static final ParseField DEFAULT_OPERATOR_FIELD = new ParseField("default_operator");
public static final ParseField ANALYZER_FIELD = new ParseField("analyzer");
public static final ParseField QUOTE_ANALYZER_FIELD = new ParseField("quote_analyzer");
public static final ParseField ALLOW_LEADING_WILDCARD_FIELD = new ParseField("allow_leading_wildcard");
public static final ParseField AUTO_GENERATED_PHRASE_QUERIES_FIELD = new ParseField("auto_generated_phrase_queries");
public static final ParseField MAX_DETERMINED_STATES_FIELD = new ParseField("max_determined_states");
public static final ParseField LOWERCASE_EXPANDED_TERMS_FIELD = new ParseField("lowercase_expanded_terms");
public static final ParseField ENABLE_POSITION_INCREMENTS_FIELD = new ParseField("enable_position_increment");
public static final ParseField ESCAPE_FIELD = new ParseField("escape");
public static final ParseField USE_DIS_MAX_FIELD = new ParseField("use_dis_max");
public static final ParseField FUZZY_PREFIX_LENGTH_FIELD = new ParseField("fuzzy_prefix_length");
public static final ParseField FUZZY_MAX_EXPANSIONS_FIELD = new ParseField("fuzzy_max_expansions");
public static final ParseField FUZZY_REWRITE_FIELD = new ParseField("fuzzy_rewrite");
public static final ParseField PHRASE_SLOP_FIELD = new ParseField("phrase_slop");
public static final ParseField TIE_BREAKER_FIELD = new ParseField("tie_breaker");
public static final ParseField ANALYZE_WILDCARD_FIELD = new ParseField("analyze_wildcard");
public static final ParseField REWRITE_FIELD = new ParseField("rewrite");
public static final ParseField MINIMUM_SHOULD_MATCH_FIELD = new ParseField("minimum_should_match");
public static final ParseField QUOTE_FIELD_SUFFIX_FIELD = new ParseField("quote_field_suffix");
public static final ParseField LENIENT_FIELD = new ParseField("lenient");
public static final ParseField LOCALE_FIELD = new ParseField("locale");
public static final ParseField TIME_ZONE_FIELD = new ParseField("time_zone");
@Override
public String[] names() {
return new String[]{QueryStringQueryBuilder.NAME, Strings.toCamelCase(QueryStringQueryBuilder.NAME)};
@ -76,7 +103,7 @@ public class QueryStringQueryParser implements QueryParser {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_ARRAY) {
if ("fields".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, FIELDS_FIELD)) {
while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
String fField = null;
float fBoost = AbstractQueryBuilder.DEFAULT_BOOST;
@ -99,64 +126,64 @@ public class QueryStringQueryParser implements QueryParser {
throw new ParsingException(parser.getTokenLocation(), "[" + QueryStringQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("query".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, QUERY_FIELD)) {
queryString = parser.text();
} else if ("default_field".equals(currentFieldName) || "defaultField".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, DEFAULT_FIELD_FIELD)) {
defaultField = parser.text();
} else if ("default_operator".equals(currentFieldName) || "defaultOperator".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, DEFAULT_OPERATOR_FIELD)) {
defaultOperator = Operator.fromString(parser.text());
} else if ("analyzer".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, ANALYZER_FIELD)) {
analyzer = parser.text();
} else if ("quote_analyzer".equals(currentFieldName) || "quoteAnalyzer".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, QUOTE_ANALYZER_FIELD)) {
quoteAnalyzer = parser.text();
} else if ("allow_leading_wildcard".equals(currentFieldName) || "allowLeadingWildcard".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, ALLOW_LEADING_WILDCARD_FIELD)) {
allowLeadingWildcard = parser.booleanValue();
} else if ("auto_generate_phrase_queries".equals(currentFieldName) || "autoGeneratePhraseQueries".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AUTO_GENERATED_PHRASE_QUERIES_FIELD)) {
autoGeneratePhraseQueries = parser.booleanValue();
} else if ("max_determinized_states".equals(currentFieldName) || "maxDeterminizedStates".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MAX_DETERMINED_STATES_FIELD)) {
maxDeterminizedStates = parser.intValue();
} else if ("lowercase_expanded_terms".equals(currentFieldName) || "lowercaseExpandedTerms".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LOWERCASE_EXPANDED_TERMS_FIELD)) {
lowercaseExpandedTerms = parser.booleanValue();
} else if ("enable_position_increments".equals(currentFieldName) || "enablePositionIncrements".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, ENABLE_POSITION_INCREMENTS_FIELD)) {
enablePositionIncrements = parser.booleanValue();
} else if ("escape".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, ESCAPE_FIELD)) {
escape = parser.booleanValue();
} else if ("use_dis_max".equals(currentFieldName) || "useDisMax".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, USE_DIS_MAX_FIELD)) {
useDisMax = parser.booleanValue();
} else if ("fuzzy_prefix_length".equals(currentFieldName) || "fuzzyPrefixLength".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, FUZZY_PREFIX_LENGTH_FIELD)) {
fuzzyPrefixLength = parser.intValue();
} else if ("fuzzy_max_expansions".equals(currentFieldName) || "fuzzyMaxExpansions".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, FUZZY_MAX_EXPANSIONS_FIELD)) {
fuzzyMaxExpansions = parser.intValue();
} else if ("fuzzy_rewrite".equals(currentFieldName) || "fuzzyRewrite".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, FUZZY_REWRITE_FIELD)) {
fuzzyRewrite = parser.textOrNull();
} else if ("phrase_slop".equals(currentFieldName) || "phraseSlop".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, PHRASE_SLOP_FIELD)) {
phraseSlop = parser.intValue();
} else if (parseContext.parseFieldMatcher().match(currentFieldName, Fuzziness.FIELD)) {
fuzziness = Fuzziness.parse(parser);
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("tie_breaker".equals(currentFieldName) || "tieBreaker".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, TIE_BREAKER_FIELD)) {
tieBreaker = parser.floatValue();
} else if ("analyze_wildcard".equals(currentFieldName) || "analyzeWildcard".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, ANALYZE_WILDCARD_FIELD)) {
analyzeWildcard = parser.booleanValue();
} else if ("rewrite".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, REWRITE_FIELD)) {
rewrite = parser.textOrNull();
} else if ("minimum_should_match".equals(currentFieldName) || "minimumShouldMatch".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MINIMUM_SHOULD_MATCH_FIELD)) {
minimumShouldMatch = parser.textOrNull();
} else if ("quote_field_suffix".equals(currentFieldName) || "quoteFieldSuffix".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, QUOTE_FIELD_SUFFIX_FIELD)) {
quoteFieldSuffix = parser.textOrNull();
} else if ("lenient".equalsIgnoreCase(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LENIENT_FIELD)) {
lenient = parser.booleanValue();
} else if ("locale".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LOCALE_FIELD)) {
String localeStr = parser.text();
locale = Locale.forLanguageTag(localeStr);
} else if ("time_zone".equals(currentFieldName) || "timeZone".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, TIME_ZONE_FIELD)) {
try {
timeZone = parser.text();
} catch (IllegalArgumentException e) {
throw new ParsingException(parser.getTokenLocation(), "[" + QueryStringQueryBuilder.NAME + "] time_zone [" + parser.text() + "] is unknown");
}
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[" + QueryStringQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");

12
core/src/main/java/org/elasticsearch/index/query/RangeQueryBuilder.java
View File

@ -233,15 +233,15 @@ public class RangeQueryBuilder extends AbstractQueryBuilder<RangeQueryBuilder> i
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.startObject(fieldName);
builder.field("from", convertToStringIfBytesRef(this.from));
builder.field("to", convertToStringIfBytesRef(this.to));
builder.field("include_lower", includeLower);
builder.field("include_upper", includeUpper);
builder.field(RangeQueryParser.FROM_FIELD.getPreferredName(), convertToStringIfBytesRef(this.from));
builder.field(RangeQueryParser.TO_FIELD.getPreferredName(), convertToStringIfBytesRef(this.to));
builder.field(RangeQueryParser.INCLUDE_LOWER_FIELD.getPreferredName(), includeLower);
builder.field(RangeQueryParser.INCLUDE_UPPER_FIELD.getPreferredName(), includeUpper);
if (timeZone != null) {
builder.field("time_zone", timeZone.getID());
builder.field(RangeQueryParser.TIME_ZONE_FIELD.getPreferredName(), timeZone.getID());
}
if (format != null) {
builder.field("format", format.format());
builder.field(RangeQueryParser.FORMAT_FIELD.getPreferredName(), format.format());
}
printBoostAndQueryName(builder);
builder.endObject();

38
core/src/main/java/org/elasticsearch/index/query/RangeQueryParser.java
View File

@ -30,8 +30,18 @@ import java.io.IOException;
*/
public class RangeQueryParser implements QueryParser<RangeQueryBuilder> {
private static final ParseField FIELDDATA_FIELD = new ParseField("fielddata").withAllDeprecated("[no replacement]");
private static final ParseField NAME_FIELD = new ParseField("_name").withAllDeprecated("query name is not supported in short version of range query");
public static final ParseField FIELDDATA_FIELD = new ParseField("fielddata").withAllDeprecated("[no replacement]");
public static final ParseField NAME_FIELD = new ParseField("_name").withAllDeprecated("query name is not supported in short version of range query");
public static final ParseField LTE_FIELD = new ParseField("lte", "le");
public static final ParseField GTE_FIELD = new ParseField("gte", "ge");
public static final ParseField FROM_FIELD = new ParseField("from");
public static final ParseField TO_FIELD = new ParseField("to");
public static final ParseField INCLUDE_LOWER_FIELD = new ParseField("include_lower");
public static final ParseField INCLUDE_UPPER_FIELD = new ParseField("include_upper");
public static final ParseField GT_FIELD = new ParseField("gt");
public static final ParseField LT_FIELD = new ParseField("lt");
public static final ParseField TIME_ZONE_FIELD = new ParseField("time_zone");
public static final ParseField FORMAT_FIELD = new ParseField("format");
@Override
public String[] names() {
@ -65,33 +75,33 @@ public class RangeQueryParser implements QueryParser<RangeQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else {
if ("from".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, FROM_FIELD)) {
from = parser.objectBytes();
} else if ("to".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, TO_FIELD)) {
to = parser.objectBytes();
} else if ("include_lower".equals(currentFieldName) || "includeLower".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, INCLUDE_LOWER_FIELD)) {
includeLower = parser.booleanValue();
} else if ("include_upper".equals(currentFieldName) || "includeUpper".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, INCLUDE_UPPER_FIELD)) {
includeUpper = parser.booleanValue();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("gt".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, GT_FIELD)) {
from = parser.objectBytes();
includeLower = false;
} else if ("gte".equals(currentFieldName) || "ge".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, GTE_FIELD)) {
from = parser.objectBytes();
includeLower = true;
} else if ("lt".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LT_FIELD)) {
to = parser.objectBytes();
includeUpper = false;
} else if ("lte".equals(currentFieldName) || "le".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LTE_FIELD)) {
to = parser.objectBytes();
includeUpper = true;
} else if ("time_zone".equals(currentFieldName) || "timeZone".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, TIME_ZONE_FIELD)) {
timeZone = parser.text();
} else if ("format".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, FORMAT_FIELD)) {
format = parser.text();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[range] query does not support [" + currentFieldName + "]");

20
core/src/main/java/org/elasticsearch/index/query/RegexpQueryBuilder.java
View File

@ -135,14 +135,14 @@ public class RegexpQueryBuilder extends AbstractQueryBuilder<RegexpQueryBuilder>
}
@Override
public void doXContent(XContentBuilder builder, Params params) throws IOException {
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.startObject(fieldName);
builder.field("value", this.value);
builder.field("flags_value", flagsValue);
builder.field("max_determinized_states", maxDeterminizedStates);
builder.field(RegexpQueryParser.VALUE_FIELD.getPreferredName(), this.value);
builder.field(RegexpQueryParser.FLAGS_VALUE_FIELD.getPreferredName(), flagsValue);
builder.field(RegexpQueryParser.MAX_DETERMINIZED_STATES_FIELD.getPreferredName(), maxDeterminizedStates);
if (rewrite != null) {
builder.field("rewrite", rewrite);
builder.field(RegexpQueryParser.REWRITE_FIELD.getPreferredName(), rewrite);
}
printBoostAndQueryName(builder);
builder.endObject();
@ -155,7 +155,7 @@ public class RegexpQueryBuilder extends AbstractQueryBuilder<RegexpQueryBuilder>
}
@Override
public Query doToQuery(QueryShardContext context) throws QueryShardException, IOException {
protected Query doToQuery(QueryShardContext context) throws QueryShardException, IOException {
MultiTermQuery.RewriteMethod method = QueryParsers.parseRewriteMethod(context.parseFieldMatcher(), rewrite, null);
Query query = null;
@ -174,7 +174,7 @@ public class RegexpQueryBuilder extends AbstractQueryBuilder<RegexpQueryBuilder>
}
@Override
public RegexpQueryBuilder doReadFrom(StreamInput in) throws IOException {
protected RegexpQueryBuilder doReadFrom(StreamInput in) throws IOException {
RegexpQueryBuilder regexpQueryBuilder = new RegexpQueryBuilder(in.readString(), in.readString());
regexpQueryBuilder.flagsValue = in.readVInt();
regexpQueryBuilder.maxDeterminizedStates = in.readVInt();
@ -183,7 +183,7 @@ public class RegexpQueryBuilder extends AbstractQueryBuilder<RegexpQueryBuilder>
}
@Override
public void doWriteTo(StreamOutput out) throws IOException {
protected void doWriteTo(StreamOutput out) throws IOException {
out.writeString(fieldName);
out.writeString(value);
out.writeVInt(flagsValue);
@ -192,12 +192,12 @@ public class RegexpQueryBuilder extends AbstractQueryBuilder<RegexpQueryBuilder>
}
@Override
public int doHashCode() {
protected int doHashCode() {
return Objects.hash(fieldName, value, flagsValue, maxDeterminizedStates, rewrite);
}
@Override
public boolean doEquals(RegexpQueryBuilder other) {
protected boolean doEquals(RegexpQueryBuilder other) {
return Objects.equals(fieldName, other.fieldName) &&
Objects.equals(value, other.value) &&
Objects.equals(flagsValue, other.flagsValue) &&

21
core/src/main/java/org/elasticsearch/index/query/RegexpQueryParser.java
View File

@ -30,7 +30,12 @@ import java.io.IOException;
*/
public class RegexpQueryParser implements QueryParser<RegexpQueryBuilder> {
private static final ParseField NAME_FIELD = new ParseField("_name").withAllDeprecated("query name is not supported in short version of regexp query");
public static final ParseField NAME_FIELD = new ParseField("_name").withAllDeprecated("query name is not supported in short version of regexp query");
public static final ParseField FLAGS_VALUE_FIELD = new ParseField("flags_value");
public static final ParseField MAX_DETERMINIZED_STATES_FIELD = new ParseField("max_determinized_states");
public static final ParseField FLAGS_FIELD = new ParseField("flags");
public static final ParseField REWRITE_FIELD = new ParseField("rewrite");
public static final ParseField VALUE_FIELD = new ParseField("value");
@Override
public String[] names() {
@ -62,20 +67,20 @@ public class RegexpQueryParser implements QueryParser<RegexpQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else {
if ("value".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, VALUE_FIELD)) {
value = parser.textOrNull();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("rewrite".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, REWRITE_FIELD)) {
rewrite = parser.textOrNull();
} else if ("flags".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, FLAGS_FIELD)) {
String flags = parser.textOrNull();
flagsValue = RegexpFlag.resolveValue(flags);
} else if ("max_determinized_states".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MAX_DETERMINIZED_STATES_FIELD)) {
maxDeterminizedStates = parser.intValue();
} else if ("flags_value".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, FLAGS_VALUE_FIELD)) {
flagsValue = parser.intValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[regexp] query does not support [" + currentFieldName + "]");

9
core/src/main/java/org/elasticsearch/index/query/ScriptQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.xcontent.XContentParser;
import org.elasticsearch.script.Script;
@ -35,6 +36,8 @@ import java.util.Map;
*/
public class ScriptQueryParser implements QueryParser<ScriptQueryBuilder> {
public static final ParseField PARAMS_FIELD = new ParseField("params");
@Override
public String[] names() {
return new String[]{ScriptQueryBuilder.NAME};
@ -62,15 +65,15 @@ public class ScriptQueryParser implements QueryParser<ScriptQueryBuilder> {
} else if (token == XContentParser.Token.START_OBJECT) {
if (parseContext.parseFieldMatcher().match(currentFieldName, ScriptField.SCRIPT)) {
script = Script.parse(parser, parseContext.parseFieldMatcher());
} else if ("params".equals(currentFieldName)) { // TODO remove in 3.0 (here to support old script APIs)
} else if (parseContext.parseFieldMatcher().match(currentFieldName, PARAMS_FIELD)) { // TODO remove in 3.0 (here to support old script APIs)
params = parser.map();
} else {
throw new ParsingException(parser.getTokenLocation(), "[script] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("_name".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if (!scriptParameterParser.token(currentFieldName, token, parser, parseContext.parseFieldMatcher())) {
throw new ParsingException(parser.getTokenLocation(), "[script] query does not support [" + currentFieldName + "]");

20
core/src/main/java/org/elasticsearch/index/query/SimpleQueryStringBuilder.java
View File

@ -303,10 +303,10 @@ public class SimpleQueryStringBuilder extends AbstractQueryBuilder<SimpleQuerySt
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("query", queryText);
builder.field(SimpleQueryStringParser.QUERY_FIELD.getPreferredName(), queryText);
if (fieldsAndWeights.size() > 0) {
builder.startArray("fields");
builder.startArray(SimpleQueryStringParser.FIELDS_FIELD.getPreferredName());
for (Map.Entry<String, Float> entry : fieldsAndWeights.entrySet()) {
builder.value(entry.getKey() + "^" + entry.getValue());
}
@ -314,18 +314,18 @@ public class SimpleQueryStringBuilder extends AbstractQueryBuilder<SimpleQuerySt
}
if (analyzer != null) {
builder.field("analyzer", analyzer);
builder.field(SimpleQueryStringParser.ANALYZER_FIELD.getPreferredName(), analyzer);
}
builder.field("flags", flags);
builder.field("default_operator", defaultOperator.name().toLowerCase(Locale.ROOT));
builder.field("lowercase_expanded_terms", settings.lowercaseExpandedTerms());
builder.field("lenient", settings.lenient());
builder.field("analyze_wildcard", settings.analyzeWildcard());
builder.field("locale", (settings.locale().toLanguageTag()));
builder.field(SimpleQueryStringParser.FLAGS_FIELD.getPreferredName(), flags);
builder.field(SimpleQueryStringParser.DEFAULT_OPERATOR_FIELD.getPreferredName(), defaultOperator.name().toLowerCase(Locale.ROOT));
builder.field(SimpleQueryStringParser.LOWERCASE_EXPANDED_TERMS_FIELD.getPreferredName(), settings.lowercaseExpandedTerms());
builder.field(SimpleQueryStringParser.LENIENT_FIELD.getPreferredName(), settings.lenient());
builder.field(SimpleQueryStringParser.ANALYZE_WILDCARD_FIELD.getPreferredName(), settings.analyzeWildcard());
builder.field(SimpleQueryStringParser.LOCALE_FIELD.getPreferredName(), (settings.locale().toLanguageTag()));
if (minimumShouldMatch != null) {
builder.field("minimum_should_match", minimumShouldMatch);
builder.field(SimpleQueryStringParser.MINIMUM_SHOULD_MATCH_FIELD.getPreferredName(), minimumShouldMatch);
}
printBoostAndQueryName(builder);

36
core/src/main/java/org/elasticsearch/index/query/SimpleQueryStringParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
@ -60,6 +61,17 @@ import java.util.Map;
*/
public class SimpleQueryStringParser implements QueryParser<SimpleQueryStringBuilder> {
public static final ParseField MINIMUM_SHOULD_MATCH_FIELD = new ParseField("minimum_should_match");
public static final ParseField ANALYZE_WILDCARD_FIELD = new ParseField("analyze_wildcard");
public static final ParseField LENIENT_FIELD = new ParseField("lenient");
public static final ParseField LOWERCASE_EXPANDED_TERMS_FIELD = new ParseField("lowercase_expanded_terms");
public static final ParseField LOCALE_FIELD = new ParseField("locale");
public static final ParseField FLAGS_FIELD = new ParseField("flags");
public static final ParseField DEFAULT_OPERATOR_FIELD = new ParseField("default_operator");
public static final ParseField ANALYZER_FIELD = new ParseField("analyzer");
public static final ParseField QUERY_FIELD = new ParseField("query");
public static final ParseField FIELDS_FIELD = new ParseField("fields");
@Override
public String[] names() {
return new String[]{SimpleQueryStringBuilder.NAME, Strings.toCamelCase(SimpleQueryStringBuilder.NAME)};
@ -88,7 +100,7 @@ public class SimpleQueryStringParser implements QueryParser<SimpleQueryStringBui
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_ARRAY) {
if ("fields".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, FIELDS_FIELD)) {
while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
String fField = null;
float fBoost = 1;
@ -111,15 +123,15 @@ public class SimpleQueryStringParser implements QueryParser<SimpleQueryStringBui
throw new ParsingException(parser.getTokenLocation(), "[" + SimpleQueryStringBuilder.NAME + "] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("query".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, QUERY_FIELD)) {
queryBody = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("analyzer".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, ANALYZER_FIELD)) {
analyzerName = parser.text();
} else if ("default_operator".equals(currentFieldName) || "defaultOperator".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, DEFAULT_OPERATOR_FIELD)) {
defaultOperator = Operator.fromString(parser.text());
} else if ("flags".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, FLAGS_FIELD)) {
if (parser.currentToken() != XContentParser.Token.VALUE_NUMBER) {
// Possible options are:
// ALL, NONE, AND, OR, PREFIX, PHRASE, PRECEDENCE, ESCAPE, WHITESPACE, FUZZY, NEAR, SLOP
@ -130,18 +142,18 @@ public class SimpleQueryStringParser implements QueryParser<SimpleQueryStringBui
flags = SimpleQueryStringFlag.ALL.value();
}
}
} else if ("locale".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LOCALE_FIELD)) {
String localeStr = parser.text();
locale = Locale.forLanguageTag(localeStr);
} else if ("lowercase_expanded_terms".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LOWERCASE_EXPANDED_TERMS_FIELD)) {
lowercaseExpandedTerms = parser.booleanValue();
} else if ("lenient".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LENIENT_FIELD)) {
lenient = parser.booleanValue();
} else if ("analyze_wildcard".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, ANALYZE_WILDCARD_FIELD)) {
analyzeWildcard = parser.booleanValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("minimum_should_match".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, MINIMUM_SHOULD_MATCH_FIELD)) {
minimumShouldMatch = parser.textOrNull();
} else {
throw new ParsingException(parser.getTokenLocation(), "[" + SimpleQueryStringBuilder.NAME + "] unsupported field [" + parser.currentName() + "]");

4
core/src/main/java/org/elasticsearch/index/query/SpanContainingQueryBuilder.java
View File

@ -71,9 +71,9 @@ public class SpanContainingQueryBuilder extends AbstractQueryBuilder<SpanContain
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("big");
builder.field(SpanContainingQueryParser.BIG_FIELD.getPreferredName());
big.toXContent(builder, params);
builder.field("little");
builder.field(SpanContainingQueryParser.LITTLE_FIELD.getPreferredName());
little.toXContent(builder, params);
printBoostAndQueryName(builder);
builder.endObject();

12
core/src/main/java/org/elasticsearch/index/query/SpanContainingQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
@ -30,6 +31,9 @@ import java.io.IOException;
*/
public class SpanContainingQueryParser implements QueryParser<SpanContainingQueryBuilder> {
public static final ParseField BIG_FIELD = new ParseField("big");
public static final ParseField LITTLE_FIELD = new ParseField("little");
@Override
public String[] names() {
return new String[]{SpanContainingQueryBuilder.NAME, Strings.toCamelCase(SpanContainingQueryBuilder.NAME)};
@ -49,13 +53,13 @@ public class SpanContainingQueryParser implements QueryParser<SpanContainingQuer
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if ("big".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, BIG_FIELD)) {
QueryBuilder query = parseContext.parseInnerQueryBuilder();
if (!(query instanceof SpanQueryBuilder<?>)) {
throw new ParsingException(parser.getTokenLocation(), "span_containing [big] must be of type span query");
}
big = (SpanQueryBuilder<?>) query;
} else if ("little".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LITTLE_FIELD)) {
QueryBuilder query = parseContext.parseInnerQueryBuilder();
if (!(query instanceof SpanQueryBuilder<?>)) {
throw new ParsingException(parser.getTokenLocation(), "span_containing [little] must be of type span query");
@ -64,9 +68,9 @@ public class SpanContainingQueryParser implements QueryParser<SpanContainingQuer
} else {
throw new ParsingException(parser.getTokenLocation(), "[span_containing] query does not support [" + currentFieldName + "]");
}
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[span_containing] query does not support [" + currentFieldName + "]");

4
core/src/main/java/org/elasticsearch/index/query/SpanFirstQueryBuilder.java
View File

@ -74,9 +74,9 @@ public class SpanFirstQueryBuilder extends AbstractQueryBuilder<SpanFirstQueryBu
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("match");
builder.field(SpanFirstQueryParser.MATCH_FIELD.getPreferredName());
matchBuilder.toXContent(builder, params);
builder.field("end", end);
builder.field(SpanFirstQueryParser.END_FIELD.getPreferredName(), end);
printBoostAndQueryName(builder);
builder.endObject();
}

12
core/src/main/java/org/elasticsearch/index/query/SpanFirstQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
@ -30,6 +31,9 @@ import java.io.IOException;
*/
public class SpanFirstQueryParser implements QueryParser<SpanFirstQueryBuilder> {
public static final ParseField MATCH_FIELD = new ParseField("match");
public static final ParseField END_FIELD = new ParseField("end");
@Override
public String[] names() {
return new String[]{SpanFirstQueryBuilder.NAME, Strings.toCamelCase(SpanFirstQueryBuilder.NAME)};
@ -51,7 +55,7 @@ public class SpanFirstQueryParser implements QueryParser<SpanFirstQueryBuilder>
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if ("match".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, MATCH_FIELD)) {
QueryBuilder query = parseContext.parseInnerQueryBuilder();
if (!(query instanceof SpanQueryBuilder)) {
throw new ParsingException(parser.getTokenLocation(), "spanFirst [match] must be of type span query");
@ -61,11 +65,11 @@ public class SpanFirstQueryParser implements QueryParser<SpanFirstQueryBuilder>
throw new ParsingException(parser.getTokenLocation(), "[span_first] query does not support [" + currentFieldName + "]");
}
} else {
if ("boost".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("end".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, END_FIELD)) {
end = parser.intValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[span_first] query does not support [" + currentFieldName + "]");

2
core/src/main/java/org/elasticsearch/index/query/SpanMultiTermQueryBuilder.java
View File

@ -56,7 +56,7 @@ public class SpanMultiTermQueryBuilder extends AbstractQueryBuilder<SpanMultiTer
protected void doXContent(XContentBuilder builder, Params params)
throws IOException {
builder.startObject(NAME);
builder.field(SpanMultiTermQueryParser.MATCH_NAME);
builder.field(SpanMultiTermQueryParser.MATCH_FIELD.getPreferredName());
multiTermQueryBuilder.toXContent(builder, params);
printBoostAndQueryName(builder);
builder.endObject();

13
core/src/main/java/org/elasticsearch/index/query/SpanMultiTermQueryParser.java
View File

@ -18,6 +18,7 @@
*/
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
@ -29,7 +30,7 @@ import java.io.IOException;
*/
public class SpanMultiTermQueryParser implements QueryParser<SpanMultiTermQueryBuilder> {
public static final String MATCH_NAME = "match";
public static final ParseField MATCH_FIELD = new ParseField("match");
@Override
public String[] names() {
@ -48,19 +49,19 @@ public class SpanMultiTermQueryParser implements QueryParser<SpanMultiTermQueryB
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if (MATCH_NAME.equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, MATCH_FIELD)) {
QueryBuilder innerQuery = parseContext.parseInnerQueryBuilder();
if (innerQuery instanceof MultiTermQueryBuilder == false) {
throw new ParsingException(parser.getTokenLocation(), "[span_multi] [" + MATCH_NAME + "] must be of type multi term query");
throw new ParsingException(parser.getTokenLocation(), "[span_multi] [" + MATCH_FIELD.getPreferredName() + "] must be of type multi term query");
}
subQuery = (MultiTermQueryBuilder) innerQuery;
} else {
throw new ParsingException(parser.getTokenLocation(), "[span_multi] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("_name".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else {
throw new ParsingException(parser.getTokenLocation(), "[span_multi] query does not support [" + currentFieldName + "]");
@ -69,7 +70,7 @@ public class SpanMultiTermQueryParser implements QueryParser<SpanMultiTermQueryB
}
if (subQuery == null) {
throw new ParsingException(parser.getTokenLocation(), "[span_multi] must have [" + MATCH_NAME + "] multi term query clause");
throw new ParsingException(parser.getTokenLocation(), "[span_multi] must have [" + MATCH_FIELD.getPreferredName() + "] multi term query clause");
}
return new SpanMultiTermQueryBuilder(subQuery).queryName(queryName).boost(boost);

8
core/src/main/java/org/elasticsearch/index/query/SpanNearQueryBuilder.java
View File

@ -125,14 +125,14 @@ public class SpanNearQueryBuilder extends AbstractQueryBuilder<SpanNearQueryBuil
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.startArray("clauses");
builder.startArray(SpanNearQueryParser.CLAUSES_FIELD.getPreferredName());
for (SpanQueryBuilder clause : clauses) {
clause.toXContent(builder, params);
}
builder.endArray();
builder.field("slop", slop);
builder.field("in_order", inOrder);
builder.field("collect_payloads", collectPayloads);
builder.field(SpanNearQueryParser.SLOP_FIELD.getPreferredName(), slop);
builder.field(SpanNearQueryParser.IN_ORDER_FIELD.getPreferredName(), inOrder);
builder.field(SpanNearQueryParser.COLLECT_PAYLOADS_FIELD.getPreferredName(), collectPayloads);
printBoostAndQueryName(builder);
builder.endObject();
}

18
core/src/main/java/org/elasticsearch/index/query/SpanNearQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
@ -32,6 +33,11 @@ import java.util.List;
*/
public class SpanNearQueryParser implements QueryParser<SpanNearQueryBuilder> {
public static final ParseField SLOP_FIELD = new ParseField("slop");
public static final ParseField COLLECT_PAYLOADS_FIELD = new ParseField("collect_payloads");
public static final ParseField CLAUSES_FIELD = new ParseField("clauses");
public static final ParseField IN_ORDER_FIELD = new ParseField("in_order");
@Override
public String[] names() {
return new String[]{SpanNearQueryBuilder.NAME, Strings.toCamelCase(SpanNearQueryBuilder.NAME)};
@ -55,7 +61,7 @@ public class SpanNearQueryParser implements QueryParser<SpanNearQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_ARRAY) {
if ("clauses".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, CLAUSES_FIELD)) {
while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
QueryBuilder query = parseContext.parseInnerQueryBuilder();
if (!(query instanceof SpanQueryBuilder)) {
@ -67,15 +73,15 @@ public class SpanNearQueryParser implements QueryParser<SpanNearQueryBuilder> {
throw new ParsingException(parser.getTokenLocation(), "[span_near] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("in_order".equals(currentFieldName) || "inOrder".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, IN_ORDER_FIELD)) {
inOrder = parser.booleanValue();
} else if ("collect_payloads".equals(currentFieldName) || "collectPayloads".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, COLLECT_PAYLOADS_FIELD)) {
collectPayloads = parser.booleanValue();
} else if ("slop".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, SLOP_FIELD)) {
slop = parser.intValue();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[span_near] query does not support [" + currentFieldName + "]");

8
core/src/main/java/org/elasticsearch/index/query/SpanNotQueryBuilder.java
View File

@ -125,12 +125,12 @@ public class SpanNotQueryBuilder extends AbstractQueryBuilder<SpanNotQueryBuilde
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("include");
builder.field(SpanNotQueryParser.INCLUDE_FIELD.getPreferredName());
include.toXContent(builder, params);
builder.field("exclude");
builder.field(SpanNotQueryParser.EXCLUDE_FIELD.getPreferredName());
exclude.toXContent(builder, params);
builder.field("pre", pre);
builder.field("post", post);
builder.field(SpanNotQueryParser.PRE_FIELD.getPreferredName(), pre);
builder.field(SpanNotQueryParser.POST_FIELD.getPreferredName(), post);
printBoostAndQueryName(builder);
builder.endObject();
}

21
core/src/main/java/org/elasticsearch/index/query/SpanNotQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
@ -30,6 +31,12 @@ import java.io.IOException;
*/
public class SpanNotQueryParser implements QueryParser<SpanNotQueryBuilder> {
public static final ParseField POST_FIELD = new ParseField("post");
public static final ParseField PRE_FIELD = new ParseField("pre");
public static final ParseField DIST_FIELD = new ParseField("dist");
public static final ParseField EXCLUDE_FIELD = new ParseField("exclude");
public static final ParseField INCLUDE_FIELD = new ParseField("include");
@Override
public String[] names() {
return new String[]{SpanNotQueryBuilder.NAME, Strings.toCamelCase(SpanNotQueryBuilder.NAME)};
@ -56,13 +63,13 @@ public class SpanNotQueryParser implements QueryParser<SpanNotQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if ("include".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, INCLUDE_FIELD)) {
QueryBuilder query = parseContext.parseInnerQueryBuilder();
if (!(query instanceof SpanQueryBuilder)) {
throw new ParsingException(parser.getTokenLocation(), "spanNot [include] must be of type span query");
}
include = (SpanQueryBuilder) query;
} else if ("exclude".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, EXCLUDE_FIELD)) {
QueryBuilder query = parseContext.parseInnerQueryBuilder();
if (!(query instanceof SpanQueryBuilder)) {
throw new ParsingException(parser.getTokenLocation(), "spanNot [exclude] must be of type span query");
@ -72,15 +79,15 @@ public class SpanNotQueryParser implements QueryParser<SpanNotQueryBuilder> {
throw new ParsingException(parser.getTokenLocation(), "[span_not] query does not support [" + currentFieldName + "]");
}
} else {
if ("dist".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, DIST_FIELD)) {
dist = parser.intValue();
} else if ("pre".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, PRE_FIELD)) {
pre = parser.intValue();
} else if ("post".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, POST_FIELD)) {
post = parser.intValue();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[span_not] query does not support [" + currentFieldName + "]");

2
core/src/main/java/org/elasticsearch/index/query/SpanOrQueryBuilder.java
View File

@ -67,7 +67,7 @@ public class SpanOrQueryBuilder extends AbstractQueryBuilder<SpanOrQueryBuilder>
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.startArray("clauses");
builder.startArray(SpanOrQueryParser.CLAUSES_FIELD.getPreferredName());
for (SpanQueryBuilder clause : clauses) {
clause.toXContent(builder, params);
}

9
core/src/main/java/org/elasticsearch/index/query/SpanOrQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
@ -32,6 +33,8 @@ import java.util.List;
*/
public class SpanOrQueryParser implements QueryParser<SpanOrQueryBuilder> {
public static final ParseField CLAUSES_FIELD = new ParseField("clauses");
@Override
public String[] names() {
return new String[]{SpanOrQueryBuilder.NAME, Strings.toCamelCase(SpanOrQueryBuilder.NAME)};
@ -52,7 +55,7 @@ public class SpanOrQueryParser implements QueryParser<SpanOrQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_ARRAY) {
if ("clauses".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, CLAUSES_FIELD)) {
while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
QueryBuilder query = parseContext.parseInnerQueryBuilder();
if (!(query instanceof SpanQueryBuilder)) {
@ -64,9 +67,9 @@ public class SpanOrQueryParser implements QueryParser<SpanOrQueryBuilder> {
throw new ParsingException(parser.getTokenLocation(), "[span_or] query does not support [" + currentFieldName + "]");
}
} else {
if ("boost".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[span_or] query does not support [" + currentFieldName + "]");

2
core/src/main/java/org/elasticsearch/index/query/SpanTermQueryBuilder.java
View File

@ -68,7 +68,7 @@ public class SpanTermQueryBuilder extends BaseTermQueryBuilder<SpanTermQueryBuil
}
@Override
public SpanQuery doToQuery(QueryShardContext context) throws IOException {
protected SpanQuery doToQuery(QueryShardContext context) throws IOException {
BytesRef valueBytes = null;
String fieldName = this.fieldName;
MappedFieldType mapper = context.fieldMapper(fieldName);

11
core/src/main/java/org/elasticsearch/index/query/SpanTermQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
@ -30,6 +31,8 @@ import java.io.IOException;
*/
public class SpanTermQueryParser implements QueryParser<SpanTermQueryBuilder> {
public static final ParseField TERM_FIELD = new ParseField("term");
@Override
public String[] names() {
return new String[]{SpanTermQueryBuilder.NAME, Strings.toCamelCase(SpanTermQueryBuilder.NAME)};
@ -58,13 +61,13 @@ public class SpanTermQueryParser implements QueryParser<SpanTermQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else {
if ("term".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, TERM_FIELD)) {
value = parser.objectBytes();
} else if ("value".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, BaseTermQueryBuilder.VALUE_FIELD)) {
value = parser.objectBytes();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[span_term] query does not support [" + currentFieldName + "]");

4
core/src/main/java/org/elasticsearch/index/query/SpanWithinQueryBuilder.java
View File

@ -73,10 +73,10 @@ public class SpanWithinQueryBuilder extends AbstractQueryBuilder<SpanWithinQuery
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("big");
builder.field(SpanWithinQueryParser.BIG_FIELD.getPreferredName());
big.toXContent(builder, params);
builder.field("little");
builder.field(SpanWithinQueryParser.LITTLE_FIELD.getPreferredName());
little.toXContent(builder, params);
printBoostAndQueryName(builder);

12
core/src/main/java/org/elasticsearch/index/query/SpanWithinQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.xcontent.XContentParser;
@ -30,6 +31,9 @@ import java.io.IOException;
*/
public class SpanWithinQueryParser implements QueryParser<SpanWithinQueryBuilder> {
public static final ParseField BIG_FIELD = new ParseField("big");
public static final ParseField LITTLE_FIELD = new ParseField("little");
@Override
public String[] names() {
return new String[]{SpanWithinQueryBuilder.NAME, Strings.toCamelCase(SpanWithinQueryBuilder.NAME)};
@ -50,13 +54,13 @@ public class SpanWithinQueryParser implements QueryParser<SpanWithinQueryBuilder
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if ("big".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, BIG_FIELD)) {
QueryBuilder query = parseContext.parseInnerQueryBuilder();
if (query instanceof SpanQueryBuilder == false) {
throw new ParsingException(parser.getTokenLocation(), "span_within [big] must be of type span query");
}
big = (SpanQueryBuilder) query;
} else if ("little".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, LITTLE_FIELD)) {
QueryBuilder query = parseContext.parseInnerQueryBuilder();
if (query instanceof SpanQueryBuilder == false) {
throw new ParsingException(parser.getTokenLocation(), "span_within [little] must be of type span query");
@ -65,9 +69,9 @@ public class SpanWithinQueryParser implements QueryParser<SpanWithinQueryBuilder
} else {
throw new ParsingException(parser.getTokenLocation(), "[span_within] query does not support [" + currentFieldName + "]");
}
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[span_within] query does not support [" + currentFieldName + "]");

2
core/src/main/java/org/elasticsearch/index/query/TermQueryBuilder.java
View File

@ -71,7 +71,7 @@ public class TermQueryBuilder extends BaseTermQueryBuilder<TermQueryBuilder> {
}
@Override
public Query doToQuery(QueryShardContext context) throws IOException {
protected Query doToQuery(QueryShardContext context) throws IOException {
Query query = null;
MappedFieldType mapper = context.fieldMapper(this.fieldName);
if (mapper != null) {

26
core/src/main/java/org/elasticsearch/index/query/TermQueryParser.java
View File

@ -30,8 +30,8 @@ import java.io.IOException;
*/
public class TermQueryParser implements QueryParser<TermQueryBuilder> {
private static final ParseField NAME_FIELD = new ParseField("_name").withAllDeprecated("query name is not supported in short version of term query");
private static final ParseField BOOST_FIELD = new ParseField("boost").withAllDeprecated("boost is not supported in short version of term query");
public static final ParseField TERM_FIELD = new ParseField("term");
public static final ParseField VALUE_FIELD = new ParseField("value");
@Override
public String[] names() {
@ -63,13 +63,13 @@ public class TermQueryParser implements QueryParser<TermQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else {
if ("term".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, TERM_FIELD)) {
value = parser.objectBytes();
} else if ("value".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, VALUE_FIELD)) {
value = parser.objectBytes();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else {
throw new ParsingException(parser.getTokenLocation(), "[term] query does not support [" + currentFieldName + "]");
@ -77,17 +77,11 @@ public class TermQueryParser implements QueryParser<TermQueryBuilder> {
}
}
} else if (token.isValue()) {
if (parseContext.parseFieldMatcher().match(currentFieldName, NAME_FIELD)) {
queryName = parser.text();
} else if (parseContext.parseFieldMatcher().match(currentFieldName, BOOST_FIELD)) {
boost = parser.floatValue();
} else {
if (fieldName != null) {
throw new ParsingException(parser.getTokenLocation(), "[term] query does not support different field names, use [bool] query instead");
}
fieldName = currentFieldName;
value = parser.objectBytes();
if (fieldName != null) {
throw new ParsingException(parser.getTokenLocation(), "[term] query does not support different field names, use [bool] query instead");
}
fieldName = currentFieldName;
value = parser.objectBytes();
} else if (token == XContentParser.Token.START_ARRAY) {
throw new ParsingException(parser.getTokenLocation(), "[term] query does not support array of values");
}

2
core/src/main/java/org/elasticsearch/index/query/TermsQueryBuilder.java
View File

@ -207,7 +207,7 @@ public class TermsQueryBuilder extends AbstractQueryBuilder<TermsQueryBuilder> {
}
@Override
public void doXContent(XContentBuilder builder, Params params) throws IOException {
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
if (this.termsLookup != null) {
builder.startObject(fieldName);

4
core/src/main/java/org/elasticsearch/index/query/TermsQueryParser.java
View File

@ -74,9 +74,9 @@ public class TermsQueryParser implements QueryParser {
fieldName = currentFieldName;
termsLookup = TermsLookup.parseTermsLookup(parser);
} else if (token.isValue()) {
if ("boost".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[" + TermsQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");

2
core/src/main/java/org/elasticsearch/index/query/TypeQueryBuilder.java
View File

@ -62,7 +62,7 @@ public class TypeQueryBuilder extends AbstractQueryBuilder<TypeQueryBuilder> {
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("value", type.utf8ToString());
builder.field(TypeQueryParser.VALUE_FIELD.getPreferredName(), type.utf8ToString());
printBoostAndQueryName(builder);
builder.endObject();
}

9
core/src/main/java/org/elasticsearch/index/query/TypeQueryParser.java
View File

@ -20,6 +20,7 @@
package org.elasticsearch.index.query;
import org.apache.lucene.util.BytesRef;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.xcontent.XContentParser;
@ -30,6 +31,8 @@ import java.io.IOException;
*/
public class TypeQueryParser implements QueryParser<TypeQueryBuilder> {
public static final ParseField VALUE_FIELD = new ParseField("value");
@Override
public String[] names() {
return new String[]{TypeQueryBuilder.NAME};
@ -49,11 +52,11 @@ public class TypeQueryParser implements QueryParser<TypeQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token.isValue()) {
if ("_name".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("value".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, VALUE_FIELD)) {
type = parser.utf8Bytes();
} else {
throw new ParsingException(parser.getTokenLocation(), "[" + TypeQueryBuilder.NAME + "] filter doesn't support [" + currentFieldName + "]");

6
core/src/main/java/org/elasticsearch/index/query/WildcardQueryBuilder.java
View File

@ -99,12 +99,12 @@ public class WildcardQueryBuilder extends AbstractQueryBuilder<WildcardQueryBuil
}
@Override
public void doXContent(XContentBuilder builder, Params params) throws IOException {
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.startObject(fieldName);
builder.field("wildcard", value);
builder.field(WildcardQueryParser.WILDCARD_FIELD.getPreferredName(), value);
if (rewrite != null) {
builder.field("rewrite", rewrite);
builder.field(WildcardQueryParser.REWRITE_FIELD.getPreferredName(), rewrite);
}
printBoostAndQueryName(builder);
builder.endObject();

15
core/src/main/java/org/elasticsearch/index/query/WildcardQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.xcontent.XContentParser;
@ -29,6 +30,10 @@ import java.io.IOException;
*/
public class WildcardQueryParser implements QueryParser<WildcardQueryBuilder> {
public static final ParseField WILDCARD_FIELD = new ParseField("wildcard");
public static final ParseField VALUE_FIELD = new ParseField("value");
public static final ParseField REWRITE_FIELD = new ParseField("rewrite");
@Override
public String[] names() {
return new String[]{WildcardQueryBuilder.NAME};
@ -55,15 +60,15 @@ public class WildcardQueryParser implements QueryParser<WildcardQueryBuilder> {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else {
if ("wildcard".equals(currentFieldName)) {
if (parseContext.parseFieldMatcher().match(currentFieldName, WILDCARD_FIELD)) {
value = parser.text();
} else if ("value".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, VALUE_FIELD)) {
value = parser.text();
} else if ("boost".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.BOOST_FIELD)) {
boost = parser.floatValue();
} else if ("rewrite".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, REWRITE_FIELD)) {
rewrite = parser.textOrNull();
} else if ("_name".equals(currentFieldName)) {
} else if (parseContext.parseFieldMatcher().match(currentFieldName, AbstractQueryBuilder.NAME_FIELD)) {
queryName = parser.text();
} else {
throw new ParsingException(parser.getTokenLocation(), "[wildcard] query does not support [" + currentFieldName + "]");

2
core/src/main/java/org/elasticsearch/index/query/WrapperQueryBuilder.java
View File

@ -94,7 +94,7 @@ public class WrapperQueryBuilder extends AbstractQueryBuilder<WrapperQueryBuilde
@Override
protected void doXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(NAME);
builder.field("query", source);
builder.field(WrapperQueryParser.QUERY_FIELD.getPreferredName(), source);
builder.endObject();
}

5
core/src/main/java/org/elasticsearch/index/query/WrapperQueryParser.java
View File

@ -19,6 +19,7 @@
package org.elasticsearch.index.query;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.xcontent.XContentParser;
@ -29,6 +30,8 @@ import java.io.IOException;
*/
public class WrapperQueryParser implements QueryParser {
public static final ParseField QUERY_FIELD = new ParseField("query");
@Override
public String[] names() {
return new String[]{WrapperQueryBuilder.NAME};
@ -43,7 +46,7 @@ public class WrapperQueryParser implements QueryParser {
throw new ParsingException(parser.getTokenLocation(), "[wrapper] query malformed");
}
String fieldName = parser.currentName();
if (!fieldName.equals("query")) {
if (! parseContext.parseFieldMatcher().match(fieldName, QUERY_FIELD)) {
throw new ParsingException(parser.getTokenLocation(), "[wrapper] query malformed, expected `query` but was" + fieldName);
}
parser.nextToken();

52
core/src/test/java/org/elasticsearch/index/query/AbstractQueryTestCase.java
View File

@ -349,7 +349,7 @@ public abstract class AbstractQueryTestCase<QB extends AbstractQueryBuilder<QB>>
assertParsedQuery(builder.bytes(), testQuery);
for (Map.Entry<String, QB> alternateVersion : getAlternateVersions().entrySet()) {
String queryAsString = alternateVersion.getKey();
assertParsedQuery(new BytesArray(queryAsString), alternateVersion.getValue());
assertParsedQuery(new BytesArray(queryAsString), alternateVersion.getValue(), ParseFieldMatcher.EMPTY);
}
}
}
@ -869,4 +869,54 @@ public abstract class AbstractQueryTestCase<QB extends AbstractQueryBuilder<QB>>
throw new UnsupportedOperationException("this test can't handle MultiTermVector requests");
}
/**
* Call this method to check a valid json string representing the query under test against
* it's generated json.
*
* Note: By the time of this writing (Nov 2015) all queries are taken from the query dsl
* reference docs mirroring examples there. Here's how the queries were generated:
*
* <ul>
* <li> Take a reference documentation example.
* <li> Stick it into the createParseableQueryJson method of the respective query test.
* <li> Manually check that what the QueryBuilder generates equals the input json ignoring default options.
* <li> Put the manual checks into the asserQueryParsedFromJson method.
* <li> Now copy the generated json including default options into createParseableQueryJso
* <li> By now the roundtrip check for the json should be happy.
* </ul>
**/
public static void checkGeneratedJson(String expected, QueryBuilder<?> source) throws IOException {
// now assert that we actually generate the same JSON
XContentBuilder builder = XContentFactory.jsonBuilder().prettyPrint();
source.toXContent(builder, ToXContent.EMPTY_PARAMS);
assertEquals(
msg(expected, builder.string()),
expected.replaceAll("\\s+",""),
builder.string().replaceAll("\\s+",""));
}
private static String msg(String left, String right) {
int size = Math.min(left.length(), right.length());
StringBuilder builder = new StringBuilder("size: " + left.length() + " vs. " + right.length());
builder.append(" content: <<");
for (int i = 0; i < size; i++) {
if (left.charAt(i) == right.charAt(i)) {
builder.append(left.charAt(i));
} else {
builder.append(">> ").append("until offset: ").append(i)
.append(" [").append(left.charAt(i)).append(" vs.").append(right.charAt(i))
.append("] [").append((int)left.charAt(i) ).append(" vs.").append((int)right.charAt(i)).append(']');
return builder.toString();
}
}
if (left.length() != right.length()) {
int leftEnd = Math.max(size, left.length()) - 1;
int rightEnd = Math.max(size, right.length()) - 1;
builder.append(">> ").append("until offset: ").append(size)
.append(" [").append(left.charAt(leftEnd)).append(" vs.").append(right.charAt(rightEnd))
.append("] [").append((int)left.charAt(leftEnd)).append(" vs.").append((int)right.charAt(rightEnd)).append(']');
return builder.toString();
}
return "";
}
}

62
core/src/test/java/org/elasticsearch/index/query/BoolQueryBuilderTests.java
View File

@ -24,6 +24,7 @@ import org.elasticsearch.common.bytes.BytesReference;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.common.xcontent.XContentType;
import org.hamcrest.Matchers;
import java.io.IOException;
@ -243,4 +244,65 @@ public class BoolQueryBuilderTests extends AbstractQueryTestCase<BoolQueryBuilde
assertThat(innerBooleanClause2.getOccur(), equalTo(BooleanClause.Occur.SHOULD));
assertThat(innerBooleanClause2.getQuery(), instanceOf(MatchAllDocsQuery.class));
}
public void testFromJson() throws IOException {
String query =
"{" +
"\"bool\" : {" +
" \"must\" : [ {" +
" \"term\" : {" +
" \"user\" : {" +
" \"value\" : \"kimchy\"," +
" \"boost\" : 1.0" +
" }" +
" }" +
" } ]," +
" \"filter\" : [ {" +
" \"term\" : {" +
" \"tag\" : {" +
" \"value\" : \"tech\"," +
" \"boost\" : 1.0" +
" }" +
" }" +
" } ]," +
" \"must_not\" : [ {" +
" \"range\" : {" +
" \"age\" : {" +
" \"from\" : 10," +
" \"to\" : 20," +
" \"include_lower\" : true," +
" \"include_upper\" : true," +
" \"boost\" : 1.0" +
" }" +
" }" +
" } ]," +
" \"should\" : [ {" +
" \"term\" : {" +
" \"tag\" : {" +
" \"value\" : \"wow\"," +
" \"boost\" : 1.0" +
" }" +
" }" +
" }, {" +
" \"term\" : {" +
" \"tag\" : {" +
" \"value\" : \"elasticsearch\"," +
" \"boost\" : 1.0" +
" }" +
" }" +
" } ]," +
" \"disable_coord\" : false," +
" \"adjust_pure_negative\" : true," +
" \"minimum_should_match\" : \"23\"," +
" \"boost\" : 42.0" +
"}" +
"}";
BoolQueryBuilder queryBuilder = (BoolQueryBuilder) parseQuery(query);
checkGeneratedJson(query, queryBuilder);
assertEquals(query, 42, queryBuilder.boost, 0.00001);
assertEquals(query, "23", queryBuilder.minimumShouldMatch());
assertEquals(query, "kimchy", ((TermQueryBuilder)queryBuilder.must().get(0)).value());
}
}

34
core/src/test/java/org/elasticsearch/index/query/BoostingQueryBuilderTests.java
View File

@ -69,4 +69,38 @@ public class BoostingQueryBuilderTests extends AbstractQueryTestCase<BoostingQue
//
}
}
public void testFromJson() throws IOException {
String query =
"{\n" +
" \"boosting\" : {\n" +
" \"positive\" : {\n" +
" \"term\" : {\n" +
" \"field1\" : {\n" +
" \"value\" : \"value1\",\n" +
" \"boost\" : 5.0\n" +
" }\n" +
" }\n" +
" },\n" +
" \"negative\" : {\n" +
" \"term\" : {\n" +
" \"field2\" : {\n" +
" \"value\" : \"value2\",\n" +
" \"boost\" : 8.0\n" +
" }\n" +
" }\n" +
" },\n" +
" \"negative_boost\" : 23.0,\n" +
" \"boost\" : 42.0\n" +
" }\n" +
"}";
BoostingQueryBuilder queryBuilder = (BoostingQueryBuilder) parseQuery(query);
checkGeneratedJson(query, queryBuilder);
assertEquals(query, 42, queryBuilder.boost(), 0.00001);
assertEquals(query, 23, queryBuilder.negativeBoost(), 0.00001);
assertEquals(query, 8, queryBuilder.negativeQuery().boost(), 0.00001);
assertEquals(query, 5, queryBuilder.positiveQuery().boost(), 0.00001);
}
}

29
core/src/test/java/org/elasticsearch/index/query/CommonTermsQueryBuilderTests.java
View File

@ -104,6 +104,35 @@ public class CommonTermsQueryBuilderTests extends AbstractQueryTestCase<CommonTe
}
}
public void testFromJson() throws IOException {
String query =
"{\n" +
" \"common\" : {\n" +
" \"body\" : {\n" +
" \"query\" : \"nelly the elephant not as a cartoon\",\n" +
" \"disable_coord\" : true,\n" +
" \"high_freq_operator\" : \"AND\",\n" +
" \"low_freq_operator\" : \"OR\",\n" +
" \"cutoff_frequency\" : 0.001,\n" +
" \"minimum_should_match\" : {\n" +
" \"low_freq\" : \"2\",\n" +
" \"high_freq\" : \"3\"\n" +
" },\n" +
" \"boost\" : 42.0\n" +
" }\n" +
" }\n" +
"}";
CommonTermsQueryBuilder queryBuilder = (CommonTermsQueryBuilder) parseQuery(query);
checkGeneratedJson(query, queryBuilder);
assertEquals(query, 42, queryBuilder.boost, 0.00001);
assertEquals(query, 0.001, queryBuilder.cutoffFrequency(), 0.0001);
assertEquals(query, Operator.OR, queryBuilder.lowFreqOperator());
assertEquals(query, Operator.AND, queryBuilder.highFreqOperator());
assertEquals(query, "nelly the elephant not as a cartoon", queryBuilder.value());
}
public void testNoTermsFromQueryString() throws IOException {
CommonTermsQueryBuilder builder = new CommonTermsQueryBuilder(STRING_FIELD_NAME, "");
QueryShardContext context = createShardContext();

22
core/src/test/java/org/elasticsearch/index/query/ConstantScoreQueryBuilderTests.java
View File

@ -76,4 +76,26 @@ public class ConstantScoreQueryBuilderTests extends AbstractQueryTestCase<Consta
public void testUnknownField() throws IOException {
assumeTrue("test doesn't apply for query filter queries", false);
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"constant_score\" : {\n" +
" \"filter\" : {\n" +
" \"terms\" : {\n" +
" \"user\" : [ \"kimchy\", \"elasticsearch\" ],\n" +
" \"boost\" : 42.0\n" +
" }\n" +
" },\n" +
" \"boost\" : 23.0\n" +
" }\n" +
"}";
ConstantScoreQueryBuilder parsed = (ConstantScoreQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, 23.0, parsed.boost(), 0.0001);
assertEquals(json, 42.0, parsed.innerQuery().boost(), 0.0001);
}
}

32
core/src/test/java/org/elasticsearch/index/query/DisMaxQueryBuilderTests.java
View File

@ -142,4 +142,36 @@ public class DisMaxQueryBuilderTests extends AbstractQueryTestCase<DisMaxQueryBu
assertThat(firstQ.getPrefix(), equalTo(new Term(STRING_FIELD_NAME, "sh")));
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"dis_max\" : {\n" +
" \"tie_breaker\" : 0.7,\n" +
" \"queries\" : [ {\n" +
" \"term\" : {\n" +
" \"age\" : {\n" +
" \"value\" : 34,\n" +
" \"boost\" : 1.0\n" +
" }\n" +
" }\n" +
" }, {\n" +
" \"term\" : {\n" +
" \"age\" : {\n" +
" \"value\" : 35,\n" +
" \"boost\" : 1.0\n" +
" }\n" +
" }\n" +
" } ],\n" +
" \"boost\" : 1.2\n" +
" }\n" +
"}";
DisMaxQueryBuilder parsed = (DisMaxQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, 1.2, parsed.boost(), 0.0001);
assertEquals(json, 0.7, parsed.tieBreaker(), 0.0001);
assertEquals(json, 2, parsed.innerQueries().size());
}
}

16
core/src/test/java/org/elasticsearch/index/query/ExistsQueryBuilderTests.java
View File

@ -90,4 +90,20 @@ public class ExistsQueryBuilderTests extends AbstractQueryTestCase<ExistsQueryBu
// expected
}
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"exists\" : {\n" +
" \"field\" : \"user\",\n" +
" \"boost\" : 42.0\n" +
" }\n" +
"}";
ExistsQueryBuilder parsed = (ExistsQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, 42.0, parsed.boost(), 0.0001);
assertEquals(json, "user", parsed.fieldName());
}
}

25
core/src/test/java/org/elasticsearch/index/query/FieldMaskingSpanQueryBuilderTests.java
View File

@ -74,4 +74,29 @@ public class FieldMaskingSpanQueryBuilderTests extends AbstractQueryTestCase<Fie
// okay
}
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"field_masking_span\" : {\n" +
" \"query\" : {\n" +
" \"span_term\" : {\n" +
" \"value\" : {\n" +
" \"value\" : 0.5,\n" +
" \"boost\" : 0.23\n" +
" }\n" +
" }\n" +
" },\n" +
" \"field\" : \"mapped_geo_shape\",\n" +
" \"boost\" : 42.0,\n" +
" \"_name\" : \"KPI\"\n" +
" }\n" +
"}";
FieldMaskingSpanQueryBuilder parsed = (FieldMaskingSpanQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, 42.0, parsed.boost(), 0.00001);
assertEquals(json, 0.23, parsed.innerQuery().boost(), 0.00001);
}
}

20
core/src/test/java/org/elasticsearch/index/query/FuzzyQueryBuilderTests.java
View File

@ -144,4 +144,24 @@ public class FuzzyQueryBuilderTests extends AbstractQueryTestCase<FuzzyQueryBuil
assertThat(fuzzyQuery.getMin().longValue(), equalTo(7l));
assertThat(fuzzyQuery.getMax().longValue(), equalTo(17l));
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"fuzzy\" : {\n" +
" \"user\" : {\n" +
" \"value\" : \"ki\",\n" +
" \"fuzziness\" : \"2\",\n" +
" \"prefix_length\" : 0,\n" +
" \"max_expansions\" : 100,\n" +
" \"transpositions\" : false,\n" +
" \"boost\" : 42.0\n" +
" }\n" +
" }\n" +
"}";
FuzzyQueryBuilder parsed = (FuzzyQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, 42.0, parsed.boost(), 0.00001);
assertEquals(json, 2, parsed.fuzziness().asInt());
}
}

27
core/src/test/java/org/elasticsearch/index/query/GeoBoundingBoxQueryBuilderTests.java
View File

@ -24,12 +24,9 @@ import com.spatial4j.core.shape.Rectangle;
import org.apache.lucene.search.*;
import org.elasticsearch.Version;
import org.elasticsearch.cluster.metadata.IndexMetaData;
import org.elasticsearch.common.geo.GeoPoint;
import org.elasticsearch.common.geo.GeoUtils;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.index.search.geo.InMemoryGeoBoundingBoxQuery;
import org.elasticsearch.test.VersionUtils;
import org.elasticsearch.test.geo.RandomShapeGenerator;
import java.io.IOException;
@ -443,4 +440,28 @@ public class GeoBoundingBoxQueryBuilderTests extends AbstractQueryTestCase<GeoBo
assertThat(q.getMaxLon(), closeTo(-80, 1E-5));
}
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"geo_bbox\" : {\n" +
" \"pin.location\" : {\n" +
" \"top_left\" : [ -74.1, 40.73 ],\n" +
" \"bottom_right\" : [ -71.12, 40.01 ]\n" +
" },\n" +
" \"validation_method\" : \"STRICT\",\n" +
" \"type\" : \"MEMORY\",\n" +
" \"boost\" : 1.0\n" +
" }\n" +
"}";
GeoBoundingBoxQueryBuilder parsed = (GeoBoundingBoxQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, "pin.location", parsed.fieldName());
assertEquals(json, -74.1, parsed.topLeft().getLon(), 0.0001);
assertEquals(json, 40.73, parsed.topLeft().getLat(), 0.0001);
assertEquals(json, -71.12, parsed.bottomRight().getLon(), 0.0001);
assertEquals(json, 40.01, parsed.bottomRight().getLat(), 0.0001);
assertEquals(json, 1.0, parsed.boost(), 0.0001);
assertEquals(json, GeoExecType.MEMORY, parsed.type());
}
}

19
core/src/test/java/org/elasticsearch/index/query/GeoDistanceQueryBuilderTests.java
View File

@ -384,4 +384,23 @@ public class GeoDistanceQueryBuilderTests extends AbstractQueryTestCase<GeoDista
assertThat(q.getRadiusMeters(), closeTo(distanceUnit.convert(distance, DistanceUnit.MILES), 1E-5D));
}
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"geo_distance\" : {\n" +
" \"pin.location\" : [ -70.0, 40.0 ],\n" +
" \"distance\" : 12000.0,\n" +
" \"distance_type\" : \"sloppy_arc\",\n" +
" \"optimize_bbox\" : \"memory\",\n" +
" \"validation_method\" : \"STRICT\",\n" +
" \"boost\" : 1.0\n" +
" }\n" +
"}";
GeoDistanceQueryBuilder parsed = (GeoDistanceQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, -70.0, parsed.point().getLon(), 0.0001);
assertEquals(json, 40.0, parsed.point().getLat(), 0.0001);
assertEquals(json, 12000.0, parsed.distance(), 0.0001);
}
}

21
core/src/test/java/org/elasticsearch/index/query/GeoDistanceRangeQueryTests.java
View File

@ -295,4 +295,25 @@ public class GeoDistanceRangeQueryTests extends AbstractQueryTestCase<GeoDistanc
assertThat(e.getMessage(), is("distance unit must not be null"));
}
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"geo_distance_range\" : {\n" +
" \"pin.location\" : [ -70.0, 40.0 ],\n" +
" \"from\" : \"200km\",\n" +
" \"to\" : \"400km\",\n" +
" \"include_lower\" : true,\n" +
" \"include_upper\" : true,\n" +
" \"unit\" : \"m\",\n" +
" \"distance_type\" : \"sloppy_arc\",\n" +
" \"optimize_bbox\" : \"memory\",\n" +
" \"validation_method\" : \"STRICT\",\n" +
" \"boost\" : 1.0\n" +
" }\n" +
"}";
GeoDistanceRangeQueryBuilder parsed = (GeoDistanceRangeQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, -70.0, parsed.point().lon(), 0.0001);
}
}

17
core/src/test/java/org/elasticsearch/index/query/GeoPolygonQueryBuilderTests.java
View File

@ -326,4 +326,21 @@ public class GeoPolygonQueryBuilderTests extends AbstractQueryTestCase<GeoPolygo
assertThat(lons[3], equalTo(lons[0]));
}
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"geo_polygon\" : {\n" +
" \"person.location\" : {\n" +
" \"points\" : [ [ -70.0, 40.0 ], [ -80.0, 30.0 ], [ -90.0, 20.0 ], [ -70.0, 40.0 ] ]\n" +
" },\n" +
" \"coerce\" : false,\n" +
" \"ignore_malformed\" : false,\n" +
" \"boost\" : 1.0\n" +
" }\n" +
"}";
GeoPolygonQueryBuilder parsed = (GeoPolygonQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, 4, parsed.points().size());
}
}

19
core/src/test/java/org/elasticsearch/index/query/GeoShapeQueryBuilderTests.java
View File

@ -222,4 +222,23 @@ public class GeoShapeQueryBuilderTests extends AbstractQueryTestCase<GeoShapeQue
GeoShapeQueryBuilder geoQuery = QueryBuilders.geoShapeQuery("searchGeometry", envelopeBuilder);
JsonXContent.contentBuilder().startArray().value(geoQuery).endArray();
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"geo_shape\" : {\n" +
" \"location\" : {\n" +
" \"shape\" : {\n" +
" \"type\" : \"envelope\",\n" +
" \"coordinates\" : [ [ 13.0, 53.0 ], [ 14.0, 52.0 ] ]\n" +
" },\n" +
" \"relation\" : \"intersects\"\n" +
" },\n" +
" \"boost\" : 42.0\n" +
" }\n" +
"}";
GeoShapeQueryBuilder parsed = (GeoShapeQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, 42.0, parsed.boost(), 0.0001);
}
}

15
core/src/test/java/org/elasticsearch/index/query/GeohashCellQueryBuilderTests.java
View File

@ -131,4 +131,19 @@ public class GeohashCellQueryBuilderTests extends AbstractQueryTestCase<Builder>
String pointTest3 = "{\"geohash_cell\": {\"pin\": [" + point.getX() + "," + point.getY() + "]}}";
assertParsedQuery(pointTest3, pointTestBuilder);
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"geohash_cell\" : {\n" +
" \"neighbors\" : true,\n" +
" \"precision\" : 3,\n" +
" \"pin\" : \"t4mk70fgk067\",\n" +
" \"boost\" : 1.0\n" +
" }\n" +
"}";
GeohashCellQuery.Builder parsed = (GeohashCellQuery.Builder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, 3, parsed.precision().intValue());
}
}

39
core/src/test/java/org/elasticsearch/index/query/HasChildQueryBuilderTests.java
View File

@ -28,6 +28,7 @@ import org.apache.lucene.search.join.ScoreMode;
import org.apache.lucene.util.BytesRef;
import org.elasticsearch.ElasticsearchParseException;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest;
import org.elasticsearch.common.ParseFieldMatcher;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.compress.CompressedXContent;
import org.elasticsearch.common.xcontent.ToXContent;
@ -197,8 +198,9 @@ public class HasChildQueryBuilderTests extends AbstractQueryTestCase<HasChildQue
assertEquals(positiveValue, foo.maxChildren());
}
public void testParseFromJSON() throws IOException {
String query = "{\n" +
public void testFromJson() throws IOException {
String query =
"{\n" +
" \"has_child\" : {\n" +
" \"query\" : {\n" +
" \"range\" : {\n" +
@ -211,7 +213,7 @@ public class HasChildQueryBuilderTests extends AbstractQueryTestCase<HasChildQue
" }\n" +
" }\n" +
" },\n" +
" \"child_type\" : \"child\",\n" +
" \"type\" : \"child\",\n" +
" \"score_mode\" : \"avg\",\n" +
" \"min_children\" : 883170873,\n" +
" \"max_children\" : 1217235442,\n" +
@ -229,6 +231,7 @@ public class HasChildQueryBuilderTests extends AbstractQueryTestCase<HasChildQue
" }\n" +
"}";
HasChildQueryBuilder queryBuilder = (HasChildQueryBuilder) parseQuery(query);
checkGeneratedJson(query, queryBuilder);
assertEquals(query, queryBuilder.maxChildren(), 1217235442);
assertEquals(query, queryBuilder.minChildren(), 883170873);
assertEquals(query, queryBuilder.boost(), 2.0f, 0.0f);
@ -237,38 +240,8 @@ public class HasChildQueryBuilderTests extends AbstractQueryTestCase<HasChildQue
assertEquals(query, queryBuilder.scoreMode(), ScoreMode.Avg);
assertNotNull(query, queryBuilder.innerHit());
assertEquals(query, queryBuilder.innerHit(), new QueryInnerHits("inner_hits_name", new InnerHitsBuilder.InnerHit().setSize(100).addSort("mapped_string", SortOrder.ASC)));
// now assert that we actually generate the same JSON
XContentBuilder builder = XContentFactory.jsonBuilder().prettyPrint();
queryBuilder.toXContent(builder, ToXContent.EMPTY_PARAMS);
logger.info(msg(query, builder.string()));
assertEquals(query, builder.string());
}
private String msg(String left, String right) {
int size = Math.min(left.length(), right.length());
StringBuilder builder = new StringBuilder("size: " + left.length() + " vs. " + right.length());
builder.append(" content: <<");
for (int i = 0; i < size; i++) {
if (left.charAt(i) == right.charAt(i)) {
builder.append(left.charAt(i));
} else {
builder.append(">> ").append("until offset: ").append(i)
.append(" [").append(left.charAt(i)).append(" vs.").append(right.charAt(i))
.append("] [").append((int)left.charAt(i) ).append(" vs.").append((int)right.charAt(i)).append(']');
return builder.toString();
}
}
if (left.length() != right.length()) {
int leftEnd = Math.max(size, left.length()) - 1;
int rightEnd = Math.max(size, right.length()) - 1;
builder.append(">> ").append("until offset: ").append(size)
.append(" [").append(left.charAt(leftEnd)).append(" vs.").append(right.charAt(rightEnd))
.append("] [").append((int)left.charAt(leftEnd)).append(" vs.").append((int)right.charAt(rightEnd)).append(']');
return builder.toString();
}
return "";
}
public void testToQueryInnerQueryType() throws IOException {
String[] searchTypes = new String[]{PARENT_TYPE};
QueryShardContext.setTypes(searchTypes);

23
core/src/test/java/org/elasticsearch/index/query/HasParentQueryBuilderTests.java
View File

@ -242,4 +242,27 @@ public class HasParentQueryBuilderTests extends AbstractQueryTestCase<HasParentQ
}
}
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"has_parent\" : {\n" +
" \"query\" : {\n" +
" \"term\" : {\n" +
" \"tag\" : {\n" +
" \"value\" : \"something\",\n" +
" \"boost\" : 1.0\n" +
" }\n" +
" }\n" +
" },\n" +
" \"parent_type\" : \"blog\",\n" +
" \"score\" : true,\n" +
" \"boost\" : 1.0\n" +
" }\n" +
"}";
HasParentQueryBuilder parsed = (HasParentQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, "blog", parsed.type());
assertEquals(json, "something", ((TermQueryBuilder) parsed.query()).value());
}
}

15
core/src/test/java/org/elasticsearch/index/query/IdsQueryBuilderTests.java
View File

@ -152,4 +152,19 @@ public class IdsQueryBuilderTests extends AbstractQueryTestCase<IdsQueryBuilder>
assertThat(e.getMessage(), is("Illegal value for id, expecting a string or number, got: START_ARRAY"));
}
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"ids\" : {\n" +
" \"type\" : [ \"my_type\" ],\n" +
" \"values\" : [ \"1\", \"100\", \"4\" ],\n" +
" \"boost\" : 1.0\n" +
" }\n" +
"}";
IdsQueryBuilder parsed = (IdsQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, 3, parsed.ids().size());
assertEquals(json, "my_type", parsed.types()[0]);
}
}

31
core/src/test/java/org/elasticsearch/index/query/IndicesQueryBuilderTests.java
View File

@ -96,4 +96,35 @@ public class IndicesQueryBuilderTests extends AbstractQueryTestCase<IndicesQuery
// expected
}
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"indices\" : {\n" +
" \"indices\" : [ \"index1\", \"index2\" ],\n" +
" \"query\" : {\n" +
" \"term\" : {\n" +
" \"tag\" : {\n" +
" \"value\" : \"wow\",\n" +
" \"boost\" : 1.0\n" +
" }\n" +
" }\n" +
" },\n" +
" \"no_match_query\" : {\n" +
" \"term\" : {\n" +
" \"tag\" : {\n" +
" \"value\" : \"kow\",\n" +
" \"boost\" : 1.0\n" +
" }\n" +
" }\n" +
" },\n" +
" \"boost\" : 1.0\n" +
" }\n" +
"}";
IndicesQueryBuilder parsed = (IndicesQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, 2, parsed.indices().length);
assertEquals(json, "kow", ((TermQueryBuilder) parsed.noMatchQuery()).value());
assertEquals(json, "wow", ((TermQueryBuilder) parsed.innerQuery()).value());
}
}

12
core/src/test/java/org/elasticsearch/index/query/MatchAllQueryBuilderTests.java
View File

@ -49,4 +49,16 @@ public class MatchAllQueryBuilderTests extends AbstractQueryTestCase<MatchAllQue
protected void doAssertLuceneQuery(MatchAllQueryBuilder queryBuilder, Query query, QueryShardContext context) throws IOException {
assertThat(query, instanceOf(MatchAllDocsQuery.class));
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"match_all\" : {\n" +
" \"boost\" : 1.2\n" +
" }\n" +
"}";
MatchAllQueryBuilder parsed = (MatchAllQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, 1.2, parsed.boost(), 0.0001);
}
}

12
core/src/test/java/org/elasticsearch/index/query/MatchNoneQueryBuilderTests.java
View File

@ -40,4 +40,16 @@ public class MatchNoneQueryBuilderTests extends AbstractQueryTestCase<MatchNoneQ
BooleanQuery booleanQuery = (BooleanQuery) query;
assertThat(booleanQuery.clauses().size(), equalTo(0));
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"match_none\" : {\n" +
" \"boost\" : 1.2\n" +
" }\n" +
"}";
MatchNoneQueryBuilder parsed = (MatchNoneQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, 1.2, parsed.boost(), 0.0001);
}
}

89
core/src/test/java/org/elasticsearch/index/query/MatchQueryBuilderTests.java
View File

@ -235,4 +235,93 @@ public class MatchQueryBuilderTests extends AbstractQueryTestCase<MatchQueryBuil
assertThat(e.getMessage(), containsString("analyzer [bogusAnalyzer] not found"));
}
}
public void testPhrasePrefixMatchQuery() throws IOException {
String json1 = "{\n" +
" \"match_phrase_prefix\" : {\n" +
" \"message\" : \"this is a test\"\n" +
" }\n" +
"}";
String expected = "{\n" +
" \"match\" : {\n" +
" \"message\" : {\n" +
" \"query\" : \"this is a test\",\n" +
" \"type\" : \"phrase_prefix\",\n" +
" \"operator\" : \"OR\",\n" +
" \"slop\" : 0,\n" +
" \"prefix_length\" : 0,\n" +
" \"max_expansions\" : 50,\n" +
" \"fuzzy_transpositions\" : true,\n" +
" \"lenient\" : false,\n" +
" \"zero_terms_query\" : \"NONE\",\n" +
" \"boost\" : 1.0\n" +
" }\n" +
" }\n" +
"}";
MatchQueryBuilder qb = (MatchQueryBuilder) parseQuery(json1);
checkGeneratedJson(expected, qb);
String json2 = "{\n" +
" \"match\" : {\n" +
" \"message\" : {\n" +
" \"query\" : \"this is a test\",\n" +
" \"type\" : \"phrase_prefix\"\n" +
" }\n" +
" }\n" +
"}";
qb = (MatchQueryBuilder) parseQuery(json2);
checkGeneratedJson(expected, qb);
String json3 = "{\n" +
" \"match_phrase_prefix\" : {\n" +
" \"message\" : {\n" +
" \"query\" : \"this is a test\",\n" +
" \"max_expansions\" : 10\n" +
" }\n" +
" }\n" +
"}";
expected = "{\n" +
" \"match\" : {\n" +
" \"message\" : {\n" +
" \"query\" : \"this is a test\",\n" +
" \"type\" : \"phrase_prefix\",\n" +
" \"operator\" : \"OR\",\n" +
" \"slop\" : 0,\n" +
" \"prefix_length\" : 0,\n" +
" \"max_expansions\" : 10,\n" +
" \"fuzzy_transpositions\" : true,\n" +
" \"lenient\" : false,\n" +
" \"zero_terms_query\" : \"NONE\",\n" +
" \"boost\" : 1.0\n" +
" }\n" +
" }\n" +
"}";
qb = (MatchQueryBuilder) parseQuery(json3);
checkGeneratedJson(expected, qb);
}
public void testSimpleMatchQuery() throws IOException {
String json = "{\n" +
" \"match\" : {\n" +
" \"message\" : {\n" +
" \"query\" : \"to be or not to be\",\n" +
" \"type\" : \"boolean\",\n" +
" \"operator\" : \"AND\",\n" +
" \"slop\" : 0,\n" +
" \"prefix_length\" : 0,\n" +
" \"max_expansions\" : 50,\n" +
" \"fuzzy_transpositions\" : true,\n" +
" \"lenient\" : false,\n" +
" \"zero_terms_query\" : \"ALL\",\n" +
" \"boost\" : 1.0\n" +
" }\n" +
" }\n" +
"}";
MatchQueryBuilder qb = (MatchQueryBuilder) parseQuery(json);
checkGeneratedJson(json, qb);
assertEquals(json, "to be or not to be", qb.value());
assertEquals(json, Operator.AND, qb.operator());
}
}

19
core/src/test/java/org/elasticsearch/index/query/MissingQueryBuilderTests.java
View File

@ -85,4 +85,23 @@ public class MissingQueryBuilderTests extends AbstractQueryTestCase<MissingQuery
assertThat(e.getMessage(), containsString("missing must have either existence, or null_value"));
}
}
public void testFromJson() throws IOException {
String json =
"{\n" +
" \"missing\" : {\n" +
" \"field\" : \"user\",\n" +
" \"null_value\" : false,\n" +
" \"existence\" : true,\n" +
" \"boost\" : 1.0\n" +
" }\n" +
"}";
MissingQueryBuilder parsed = (MissingQueryBuilder) parseQuery(json);
checkGeneratedJson(json, parsed);
assertEquals(json, false, parsed.nullValue());
assertEquals(json, true, parsed.existence());
assertEquals(json, "user", parsed.fieldPattern());
}
}

Some files were not shown because too many files have changed in this diff Show More