honeymoose/OpenSearch
1
0
Fork 0
mirror of https://github.com/honeymoose/OpenSearch.git synced 2025-02-17 02:14:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removing handling of null lucene query where we catch this at parse time

Browse Source
This commit is contained in:
Christoph Büscher 2016-05-25 11:18:40 +02:00
parent 359f45988f
commit cb145aec68
10 changed files with 11 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -50,7 +50,6 @@ import org.elasticsearch.index.engine.EngineFactory;
import org.elasticsearch.index.fielddata.IndexFieldDataCache;
import org.elasticsearch.index.fielddata.IndexFieldDataService;
import org.elasticsearch.index.mapper.MapperService;
import org.elasticsearch.index.query.ParsedQuery;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryShardContext;
import org.elasticsearch.index.shard.IndexEventListener;
@ -604,11 +603,10 @@ public final class IndexService extends AbstractIndexComponent implements IndexC
byte[] filterSource = alias.filter().uncompressed();
try (XContentParser parser = XContentFactory.xContent(filterSource).createParser(filterSource)) {
Optional<QueryBuilder> innerQueryBuilder = shardContext.newParseContext(parser).parseInnerQueryBuilder();
ParsedQuery parsedFilter = null;
if (innerQueryBuilder.isPresent()) {
parsedFilter = shardContext.toFilter(innerQueryBuilder.get());
return shardContext.toFilter(innerQueryBuilder.get()).query();
}
return parsedFilter == null ? null : parsedFilter.query();
return null;
}
} catch (IOException ex) {
throw new AliasFilterParsingException(shardContext.index(), alias.getAlias(), "Invalid alias filter", ex);

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

@ -441,9 +441,7 @@ public class BoolQueryBuilder extends AbstractQueryBuilder<BoolQueryBuilder> {
luceneQuery = query.toFilter(context);
break;
}
if (luceneQuery != null) {
booleanQueryBuilder.add(new BooleanClause(luceneQuery, occurs));
}
booleanQueryBuilder.add(new BooleanClause(luceneQuery, occurs));
}
}

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

@ -208,12 +208,6 @@ public class BoostingQueryBuilder extends AbstractQueryBuilder<BoostingQueryBuil
protected Query doToQuery(QueryShardContext context) throws IOException {
Query positive = positiveQuery.toQuery(context);
Query negative = negativeQuery.toQuery(context);
// make upstream queries ignore this query by returning `null`
// if either inner query builder returns null
if (positive == null || negative == null) {
return null;
}
return new BoostingQuery(positive, negative, negativeBoost);
}

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

@ -146,10 +146,6 @@ public class ConstantScoreQueryBuilder extends AbstractQueryBuilder<ConstantScor
@Override
protected Query doToQuery(QueryShardContext context) throws IOException {
Query innerFilter = filterBuilder.toFilter(context);
if (innerFilter == null ) {
// return null so that parent queries (e.g. bool) also ignore this
return null;
}
return new ConstantScoreQuery(innerFilter);
}

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

@ -168,8 +168,8 @@ public class DisMaxQueryBuilder extends AbstractQueryBuilder<DisMaxQueryBuilder>
}
}
if (!queriesFound) {
throw new ParsingException(parser.getTokenLocation(), "[dis_max] requires 'queries' field");
if (!queriesFound || queries.isEmpty()) {
throw new ParsingException(parser.getTokenLocation(), "[dis_max] requires 'queries' field with at least one clause");
}
DisMaxQueryBuilder disMaxQuery = new DisMaxQueryBuilder();
@ -186,10 +186,6 @@ public class DisMaxQueryBuilder extends AbstractQueryBuilder<DisMaxQueryBuilder>
protected Query doToQuery(QueryShardContext context) throws IOException {
// return null if there are no queries at all
Collection<Query> luceneQueries = toQueries(queries, context);
if (luceneQueries.isEmpty()) {
return null;
}
return new DisjunctionMaxQuery(luceneQueries, tieBreaker);
}

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

@ -330,9 +330,6 @@ public class HasChildQueryBuilder extends AbstractQueryBuilder<HasChildQueryBuil
context.setTypes(previousTypes);
}
if (innerQuery == null) {
return null;
}
DocumentMapper childDocMapper = context.getMapperService().documentMapper(type);
if (childDocMapper == null) {
if (ignoreUnmapped) {

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

@ -162,9 +162,6 @@ public class HasParentQueryBuilder extends AbstractQueryBuilder<HasParentQueryBu
context.setTypes(previousTypes);
}
if (innerQuery == null) {
return null;
}
DocumentMapper parentDocMapper = context.getMapperService().documentMapper(type);
if (parentDocMapper == null) {
if (ignoreUnmapped) {

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

@ -255,9 +255,6 @@ public class NestedQueryBuilder extends AbstractQueryBuilder<NestedQueryBuilder>
try {
context.nestedScope().nextLevel(nestedObjectMapper);
innerQuery = this.query.toQuery(context);
if (innerQuery == null) {
return null;
}
} finally {
context.nestedScope().previousLevel();
}

5
core/src/main/java/org/elasticsearch/search/aggregations/bucket/filter/FilterAggregationBuilder.java
View File

@ -20,10 +20,10 @@
package org.elasticsearch.search.aggregations.bucket.filter;
import org.elasticsearch.common.ParseField;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.io.stream.StreamOutput;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.index.query.MatchAllQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryParseContext;
import org.elasticsearch.search.aggregations.AbstractAggregationBuilder;
@ -84,8 +84,7 @@ public class FilterAggregationBuilder extends AbstractAggregationBuilder<FilterA
}
public static FilterAggregationBuilder parse(String aggregationName, QueryParseContext context) throws IOException {
QueryBuilder filter = context.parseInnerQueryBuilder().orElseThrow(() -> new ParsingException(context.parser().getTokenLocation(),
"filter cannot be null in filter aggregation [{}]", aggregationName));
QueryBuilder filter = context.parseInnerQueryBuilder().orElse(new MatchAllQueryBuilder());
return new FilterAggregationBuilder(aggregationName, filter);
}

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

@ -25,6 +25,7 @@ import org.apache.lucene.search.DisjunctionMaxQuery;
import org.apache.lucene.search.PrefixQuery;
import org.apache.lucene.search.Query;
import org.elasticsearch.common.ParseFieldMatcher;
import org.elasticsearch.common.ParsingException;
import org.elasticsearch.test.AbstractQueryTestCase;
import java.io.IOException;
@ -88,25 +89,17 @@ public class DisMaxQueryBuilderTests extends AbstractQueryTestCase<DisMaxQueryBu
return alternateVersions;
}
/**
* test `null`return value for missing inner queries
*/
public void testNoInnerQueries() throws IOException {
DisMaxQueryBuilder disMaxBuilder = new DisMaxQueryBuilder();
assertNull(disMaxBuilder.toQuery(createShardContext()));
}
/**
* Test with empty inner query body, this should be ignored upstream.
* To test this, we use inner {@link ConstantScoreQueryBuilder} with empty inner filter.
*/
public void testInnerQueryEmptyIgnored() throws IOException {
public void testInnerQueryEmptyException() throws IOException {
String queryString = "{ \"" + DisMaxQueryBuilder.NAME + "\" :"
+ " { \"queries\" : [ {\"" + ConstantScoreQueryBuilder.NAME + "\" : { \"filter\" : { } } } ] "
+ " }"
+ " }";
DisMaxQueryBuilder builder = (DisMaxQueryBuilder) parseQuery(queryString, ParseFieldMatcher.EMPTY);
assertTrue("the inner query has an empty body, so it should be ignored", builder.innerQueries().isEmpty());
ParsingException ex = expectThrows(ParsingException.class, () -> parseQuery(queryString, ParseFieldMatcher.EMPTY));
assertEquals("[dis_max] requires 'queries' field with at least one clause", ex.getMessage());
}
public void testIllegalArguments() {