From 904cbf53409ae62bb67cd07c31ef88121cff9361 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Christoph=20B=C3=BCscher?= Date: Mon, 27 Jul 2015 18:32:30 +0200 Subject: [PATCH] Separating QueryParseContext and QueryShardContext We are currently splitting the parse() method in the query parsers into a query parsing part (fromXContent(QueryParseContext)) and a new method that generates the lucene query (toQuery(QueryParseContext)). At some point we would like to be able to excute these two steps in different phases, one on the coordinating node and one on the shards. This PR tries to anticipate this by renaming the existing QueryParseContext to QueryShardContext to make it clearer that this context object will provide the information needed to generate the lucene queries on the shard. A new QueryParseContext is introduced and all the functionality needed for parsing the XContent in the request is moved there (parser, helper methods for parsing inner queries). While the refactoring is not finished, the new QueryShardContext will expose the QueryParseContext via the parseContext() method. Also, for the time beeing the QueryParseContext will contain a link back to the QueryShardContext it wraps, which eventually will be deleted once the refactoring is done. Closes #12527 Relates to #10217 --- .../classic/ExistsFieldQueryExtension.java | 6 +- .../classic/FieldQueryExtension.java | 4 +- .../classic/MapperQueryParser.java | 50 +-- .../classic/MissingFieldQueryExtension.java | 7 +- .../elasticsearch/ElasticsearchException.java | 1 + .../query/TransportValidateQueryAction.java | 5 +- .../action/exists/TransportExistsAction.java | 6 +- .../cluster/metadata/AliasValidator.java | 6 +- .../index/mapper/MappedFieldType.java | 12 +- .../index/mapper/internal/AllFieldMapper.java | 4 +- .../index/mapper/internal/IdFieldMapper.java | 10 +- .../mapper/internal/IndexFieldMapper.java | 6 +- .../mapper/internal/ParentFieldMapper.java | 6 +- .../mapper/internal/TypeFieldMapper.java | 4 +- .../percolator/PercolatorQueriesRegistry.java | 11 +- .../index/query/AbstractQueryBuilder.java | 18 +- .../index/query/AndQueryBuilder.java | 4 +- .../index/query/BaseQueryParser.java | 8 +- .../index/query/BaseQueryParserTemp.java | 2 +- .../index/query/BoolQueryBuilder.java | 14 +- .../index/query/BoostingQueryBuilder.java | 6 +- .../index/query/CommonTermsQueryBuilder.java | 24 +- .../index/query/CommonTermsQueryParser.java | 3 - .../query/ConstantScoreQueryBuilder.java | 6 +- .../index/query/DisMaxQueryBuilder.java | 4 +- .../index/query/EmptyQueryBuilder.java | 2 +- .../index/query/ExistsQueryBuilder.java | 16 +- .../index/query/FQueryFilterBuilder.java | 4 +- .../query/FieldMaskingSpanQueryBuilder.java | 6 +- .../index/query/FilteredQueryBuilder.java | 6 +- .../index/query/FuzzyQueryParser.java | 9 +- .../query/GeoBoundingBoxQueryParser.java | 9 +- .../index/query/GeoDistanceQueryParser.java | 9 +- .../query/GeoDistanceRangeQueryParser.java | 9 +- .../index/query/GeoPolygonQueryParser.java | 9 +- .../index/query/GeoShapeQueryParser.java | 9 +- .../index/query/GeohashCellQuery.java | 13 +- .../index/query/HasChildQueryParser.java | 26 +- .../index/query/HasParentQueryParser.java | 33 +- .../index/query/IdsQueryBuilder.java | 6 +- .../index/query/IndexQueryParserService.java | 90 +++-- .../index/query/IndicesQueryParser.java | 5 +- .../index/query/LimitQueryBuilder.java | 2 +- .../index/query/MatchAllQueryBuilder.java | 2 +- .../index/query/MatchQueryParser.java | 9 +- .../index/query/MissingQueryBuilder.java | 20 +- .../index/query/MoreLikeThisQueryParser.java | 20 +- .../index/query/MultiMatchQueryParser.java | 17 +- .../index/query/NestedQueryParser.java | 17 +- .../index/query/NotQueryBuilder.java | 4 +- .../index/query/OrQueryBuilder.java | 4 +- .../index/query/PrefixQueryBuilder.java | 18 +- .../index/query/QueryBuilder.java | 6 +- .../index/query/QueryFilterBuilder.java | 4 +- .../index/query/QueryParseContext.java | 382 ++++-------------- .../index/query/QueryParser.java | 4 +- .../index/query/QueryParsingException.java | 20 +- .../index/query/QueryShardContext.java | 327 +++++++++++++++ .../index/query/QueryShardException.java | 72 ++++ .../index/query/QueryStringQueryParser.java | 23 +- .../query/QueryWrappingQueryBuilder.java | 4 +- .../index/query/RangeQueryBuilder.java | 8 +- .../index/query/RegexpQueryBuilder.java | 8 +- .../index/query/ScriptQueryBuilder.java | 9 +- .../index/query/SimpleQueryStringBuilder.java | 32 +- .../index/query/SimpleQueryStringParser.java | 17 +- .../query/SpanContainingQueryBuilder.java | 6 +- .../index/query/SpanFirstQueryBuilder.java | 4 +- .../query/SpanMultiTermQueryBuilder.java | 4 +- .../index/query/SpanNearQueryBuilder.java | 4 +- .../index/query/SpanNotQueryBuilder.java | 6 +- .../index/query/SpanOrQueryBuilder.java | 4 +- .../index/query/SpanTermQueryBuilder.java | 2 +- .../index/query/SpanWithinQueryBuilder.java | 6 +- .../index/query/TemplateQueryParser.java | 13 +- .../index/query/TermQueryBuilder.java | 6 +- .../index/query/TermsQueryParser.java | 11 +- .../index/query/TypeQueryBuilder.java | 8 +- .../index/query/WildcardQueryBuilder.java | 8 +- .../index/query/WrapperQueryParser.java | 11 +- .../functionscore/DecayFunctionParser.java | 34 +- .../FunctionScoreQueryParser.java | 17 +- .../functionscore/ScoreFunctionParser.java | 4 +- .../functionscore/factor/FactorParser.java | 7 +- .../FieldValueFactorFunctionParser.java | 5 +- .../random/RandomScoreFunctionParser.java | 8 +- .../script/ScriptScoreFunctionParser.java | 7 +- .../support/InnerHitsQueryParserHelper.java | 3 +- .../support/NestedInnerQueryParseSupport.java | 42 +- .../query/support/XContentStructure.java | 9 +- .../index/search/MatchQuery.java | 30 +- .../index/search/MultiMatchQuery.java | 11 +- .../shard/TranslogRecoveryPerformer.java | 7 +- .../bucket/significant/heuristics/GND.java | 4 +- .../significant/heuristics/JLHScore.java | 4 +- .../heuristics/NXYSignificanceHeuristic.java | 4 +- .../heuristics/PercentageScore.java | 4 +- .../heuristics/ScriptHeuristic.java | 4 +- .../innerhits/InnerHitsParseElement.java | 40 +- .../search/internal/SearchContext.java | 6 +- .../search/sort/GeoDistanceSortParser.java | 5 +- .../search/sort/SortParseElement.java | 2 +- .../org/elasticsearch/ESExceptionTests.java | 3 +- .../ExceptionSerializationTests.java | 23 +- .../index/query/AndQueryBuilderTest.java | 10 +- .../index/query/BaseQueryTestCase.java | 34 +- .../index/query/BaseTermQueryTestCase.java | 2 +- .../index/query/BoolQueryBuilderTest.java | 6 +- .../index/query/BoostingQueryBuilderTest.java | 2 +- .../query/CommonTermsQueryBuilderTest.java | 14 +- .../query/ConstantScoreQueryBuilderTest.java | 6 +- .../index/query/DisMaxQueryBuilderTest.java | 11 +- .../index/query/ExistsQueryBuilderTest.java | 2 +- .../index/query/FQueryFilterBuilderTest.java | 10 +- .../FieldMaskingSpanQueryBuilderTest.java | 2 +- .../index/query/FilteredQueryBuilderTest.java | 2 +- .../index/query/IdsQueryBuilderTest.java | 6 +- ...eryParserFilterDateRangeTimezoneTests.java | 4 +- .../index/query/LimitQueryBuilderTest.java | 2 +- .../index/query/MatchAllQueryBuilderTest.java | 2 +- .../index/query/MissingQueryBuilderTest.java | 6 +- .../index/query/NotQueryBuilderTest.java | 6 +- .../index/query/OrQueryBuilderTest.java | 12 +- .../index/query/PrefixQueryBuilderTest.java | 2 +- .../index/query/QueryFilterBuilderTest.java | 8 +- .../index/query/RangeQueryBuilderTest.java | 16 +- .../index/query/RegexpQueryBuilderTest.java | 4 +- .../index/query/ScriptQueryBuilderTest.java | 2 +- .../query/SimpleQueryStringBuilderTest.java | 8 +- .../query/SpanContainingQueryBuilderTest.java | 2 +- .../query/SpanFirstQueryBuilderTest.java | 8 +- .../query/SpanMultiTermQueryBuilderTest.java | 8 +- .../index/query/SpanNearQueryBuilderTest.java | 2 +- .../index/query/SpanNotQueryBuilderTest.java | 10 +- .../index/query/SpanOrQueryBuilderTest.java | 2 +- .../index/query/SpanTermQueryBuilderTest.java | 2 +- .../query/SpanWithinQueryBuilderTest.java | 2 +- .../index/query/TemplateQueryParserTest.java | 4 +- .../index/query/TermQueryBuilderTest.java | 2 +- .../index/query/TypeQueryBuilderTest.java | 2 +- .../index/query/WildcardQueryBuilderTest.java | 4 +- .../query/plugin/DummyQueryParserPlugin.java | 6 +- .../search/child/AbstractChildTestCase.java | 19 +- .../index/shard/IndexShardTests.java | 4 +- .../PercolatorBackwardsCompatibilityIT.java | 4 +- .../percolator/PercolatorIT.java | 8 +- .../SignificantTermsSignificanceScoreIT.java | 4 +- .../validate/SimpleValidateQueryIT.java | 8 +- 148 files changed, 1204 insertions(+), 969 deletions(-) create mode 100644 core/src/main/java/org/elasticsearch/index/query/QueryShardContext.java create mode 100644 core/src/main/java/org/elasticsearch/index/query/QueryShardException.java diff --git a/core/src/main/java/org/apache/lucene/queryparser/classic/ExistsFieldQueryExtension.java b/core/src/main/java/org/apache/lucene/queryparser/classic/ExistsFieldQueryExtension.java index 014c2c0c7a4..cb4bee30aaa 100644 --- a/core/src/main/java/org/apache/lucene/queryparser/classic/ExistsFieldQueryExtension.java +++ b/core/src/main/java/org/apache/lucene/queryparser/classic/ExistsFieldQueryExtension.java @@ -22,7 +22,7 @@ package org.apache.lucene.queryparser.classic; import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.Query; import org.elasticsearch.index.query.ExistsQueryBuilder; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; /** * @@ -32,7 +32,7 @@ public class ExistsFieldQueryExtension implements FieldQueryExtension { public static final String NAME = "_exists_"; @Override - public Query query(QueryParseContext parseContext, String queryText) { - return new ConstantScoreQuery(ExistsQueryBuilder.newFilter(parseContext, queryText)); + public Query query(QueryShardContext context, String queryText) { + return new ConstantScoreQuery(ExistsQueryBuilder.newFilter(context, queryText)); } } diff --git a/core/src/main/java/org/apache/lucene/queryparser/classic/FieldQueryExtension.java b/core/src/main/java/org/apache/lucene/queryparser/classic/FieldQueryExtension.java index 003ff180ba3..299a37a1550 100644 --- a/core/src/main/java/org/apache/lucene/queryparser/classic/FieldQueryExtension.java +++ b/core/src/main/java/org/apache/lucene/queryparser/classic/FieldQueryExtension.java @@ -20,12 +20,12 @@ package org.apache.lucene.queryparser.classic; import org.apache.lucene.search.Query; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; /** * */ public interface FieldQueryExtension { - Query query(QueryParseContext parseContext, String queryText); + Query query(QueryShardContext context, String queryText); } diff --git a/core/src/main/java/org/apache/lucene/queryparser/classic/MapperQueryParser.java b/core/src/main/java/org/apache/lucene/queryparser/classic/MapperQueryParser.java index 4cfdc256418..6974dc0e5ae 100644 --- a/core/src/main/java/org/apache/lucene/queryparser/classic/MapperQueryParser.java +++ b/core/src/main/java/org/apache/lucene/queryparser/classic/MapperQueryParser.java @@ -39,7 +39,7 @@ import org.elasticsearch.common.unit.Fuzziness; import org.elasticsearch.index.mapper.MappedFieldType; import org.elasticsearch.index.mapper.MapperService; import org.elasticsearch.index.mapper.core.DateFieldMapper; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.index.query.support.QueryParsers; import com.google.common.base.Objects; @@ -70,7 +70,7 @@ public class MapperQueryParser extends QueryParser { .build(); } - private final QueryParseContext parseContext; + private final QueryShardContext context; private QueryParserSettings settings; @@ -85,15 +85,9 @@ public class MapperQueryParser extends QueryParser { private String quoteFieldSuffix; - public MapperQueryParser(QueryParseContext parseContext) { + public MapperQueryParser(QueryShardContext context) { super(null, null); - this.parseContext = parseContext; - } - - public MapperQueryParser(QueryParserSettings settings, QueryParseContext parseContext) { - super(settings.defaultField(), settings.defaultAnalyzer()); - this.parseContext = parseContext; - reset(settings); + this.context = context; } public void reset(QueryParserSettings settings) { @@ -168,7 +162,7 @@ public class MapperQueryParser extends QueryParser { public Query getFieldQuery(String field, String queryText, boolean quoted) throws ParseException { FieldQueryExtension fieldQueryExtension = fieldQueryExtensions.get(field); if (fieldQueryExtension != null) { - return fieldQueryExtension.query(parseContext, queryText); + return fieldQueryExtension.query(context, queryText); } Collection fields = extractMultiFields(field); if (fields != null) { @@ -232,27 +226,27 @@ public class MapperQueryParser extends QueryParser { if (quoted) { setAnalyzer(quoteAnalyzer); if (quoteFieldSuffix != null) { - currentFieldType = parseContext.fieldMapper(field + quoteFieldSuffix); + currentFieldType = context.fieldMapper(field + quoteFieldSuffix); } } if (currentFieldType == null) { - currentFieldType = parseContext.fieldMapper(field); + currentFieldType = context.fieldMapper(field); } if (currentFieldType != null) { if (quoted) { if (!forcedQuoteAnalyzer) { - setAnalyzer(parseContext.getSearchQuoteAnalyzer(currentFieldType)); + setAnalyzer(context.getSearchQuoteAnalyzer(currentFieldType)); } } else { if (!forcedAnalyzer) { - setAnalyzer(parseContext.getSearchAnalyzer(currentFieldType)); + setAnalyzer(context.getSearchAnalyzer(currentFieldType)); } } if (currentFieldType != null) { Query query = null; if (currentFieldType.useTermQueryWithQueryString()) { try { - query = currentFieldType.termQuery(queryText, parseContext); + query = currentFieldType.termQuery(queryText, context); } catch (RuntimeException e) { if (settings.lenient()) { return null; @@ -363,7 +357,7 @@ public class MapperQueryParser extends QueryParser { } private Query getRangeQuerySingle(String field, String part1, String part2, boolean startInclusive, boolean endInclusive) { - currentFieldType = parseContext.fieldMapper(field); + currentFieldType = context.fieldMapper(field); if (currentFieldType != null) { if (lowercaseExpandedTerms && !currentFieldType.isNumeric()) { part1 = part1 == null ? null : part1.toLowerCase(locale); @@ -428,7 +422,7 @@ public class MapperQueryParser extends QueryParser { } private Query getFuzzyQuerySingle(String field, String termStr, String minSimilarity) throws ParseException { - currentFieldType = parseContext.fieldMapper(field); + currentFieldType = context.fieldMapper(field); if (currentFieldType != null) { try { return currentFieldType.fuzzyQuery(termStr, Fuzziness.build(minSimilarity), fuzzyPrefixLength, settings.fuzzyMaxExpansions(), FuzzyQuery.defaultTranspositions); @@ -498,14 +492,14 @@ public class MapperQueryParser extends QueryParser { currentFieldType = null; Analyzer oldAnalyzer = getAnalyzer(); try { - currentFieldType = parseContext.fieldMapper(field); + currentFieldType = context.fieldMapper(field); if (currentFieldType != null) { if (!forcedAnalyzer) { - setAnalyzer(parseContext.getSearchAnalyzer(currentFieldType)); + setAnalyzer(context.getSearchAnalyzer(currentFieldType)); } Query query = null; if (currentFieldType.useTermQueryWithQueryString()) { - query = currentFieldType.prefixQuery(termStr, multiTermRewriteMethod, parseContext); + query = currentFieldType.prefixQuery(termStr, multiTermRewriteMethod, context); } if (query == null) { query = getPossiblyAnalyzedPrefixQuery(currentFieldType.names().indexName(), termStr); @@ -590,7 +584,7 @@ public class MapperQueryParser extends QueryParser { return newMatchAllDocsQuery(); } // effectively, we check if a field exists or not - return fieldQueryExtensions.get(ExistsFieldQueryExtension.NAME).query(parseContext, actualField); + return fieldQueryExtensions.get(ExistsFieldQueryExtension.NAME).query(context, actualField); } } if (lowercaseExpandedTerms) { @@ -639,10 +633,10 @@ public class MapperQueryParser extends QueryParser { currentFieldType = null; Analyzer oldAnalyzer = getAnalyzer(); try { - currentFieldType = parseContext.fieldMapper(field); + currentFieldType = context.fieldMapper(field); if (currentFieldType != null) { if (!forcedAnalyzer) { - setAnalyzer(parseContext.getSearchAnalyzer(currentFieldType)); + setAnalyzer(context.getSearchAnalyzer(currentFieldType)); } indexedNameField = currentFieldType.names().indexName(); return getPossiblyAnalyzedWildcardQuery(indexedNameField, termStr); @@ -780,14 +774,14 @@ public class MapperQueryParser extends QueryParser { currentFieldType = null; Analyzer oldAnalyzer = getAnalyzer(); try { - currentFieldType = parseContext.fieldMapper(field); + currentFieldType = context.fieldMapper(field); if (currentFieldType != null) { if (!forcedAnalyzer) { - setAnalyzer(parseContext.getSearchAnalyzer(currentFieldType)); + setAnalyzer(context.getSearchAnalyzer(currentFieldType)); } Query query = null; if (currentFieldType.useTermQueryWithQueryString()) { - query = currentFieldType.regexpQuery(termStr, RegExp.ALL, maxDeterminizedStates, multiTermRewriteMethod, parseContext); + query = currentFieldType.regexpQuery(termStr, RegExp.ALL, maxDeterminizedStates, multiTermRewriteMethod, context); } if (query == null) { query = super.getRegexpQuery(field, termStr); @@ -835,7 +829,7 @@ public class MapperQueryParser extends QueryParser { private Collection extractMultiFields(String field) { Collection fields = null; if (field != null) { - fields = parseContext.simpleMatchToIndexNames(field); + fields = context.simpleMatchToIndexNames(field); } else { fields = settings.fields(); } diff --git a/core/src/main/java/org/apache/lucene/queryparser/classic/MissingFieldQueryExtension.java b/core/src/main/java/org/apache/lucene/queryparser/classic/MissingFieldQueryExtension.java index 8ec3bfbe75e..f9fc8c9d5dc 100644 --- a/core/src/main/java/org/apache/lucene/queryparser/classic/MissingFieldQueryExtension.java +++ b/core/src/main/java/org/apache/lucene/queryparser/classic/MissingFieldQueryExtension.java @@ -22,8 +22,7 @@ package org.apache.lucene.queryparser.classic; import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.Query; import org.elasticsearch.index.query.MissingQueryBuilder; -import org.elasticsearch.index.query.MissingQueryParser; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; /** * @@ -33,8 +32,8 @@ public class MissingFieldQueryExtension implements FieldQueryExtension { public static final String NAME = "_missing_"; @Override - public Query query(QueryParseContext parseContext, String queryText) { - Query query = MissingQueryBuilder.newFilter(parseContext, queryText, MissingQueryBuilder.DEFAULT_EXISTENCE_VALUE, MissingQueryBuilder.DEFAULT_NULL_VALUE); + public Query query(QueryShardContext context, String queryText) { + Query query = MissingQueryBuilder.newFilter(context, queryText, MissingQueryBuilder.DEFAULT_EXISTENCE_VALUE, MissingQueryBuilder.DEFAULT_NULL_VALUE); if (query != null) { return new ConstantScoreQuery(query); } diff --git a/core/src/main/java/org/elasticsearch/ElasticsearchException.java b/core/src/main/java/org/elasticsearch/ElasticsearchException.java index 83be9f43ee6..e7fe791ff97 100644 --- a/core/src/main/java/org/elasticsearch/ElasticsearchException.java +++ b/core/src/main/java/org/elasticsearch/ElasticsearchException.java @@ -572,6 +572,7 @@ public class ElasticsearchException extends RuntimeException implements ToXConte org.elasticsearch.index.engine.RecoveryEngineException.class, org.elasticsearch.common.blobstore.BlobStoreException.class, org.elasticsearch.index.snapshots.IndexShardRestoreException.class, + org.elasticsearch.index.query.QueryShardException.class, org.elasticsearch.index.query.QueryParsingException.class, org.elasticsearch.action.support.replication.TransportReplicationAction.RetryOnPrimaryException.class, org.elasticsearch.index.engine.DeleteByQueryFailedEngineException.class, diff --git a/core/src/main/java/org/elasticsearch/action/admin/indices/validate/query/TransportValidateQueryAction.java b/core/src/main/java/org/elasticsearch/action/admin/indices/validate/query/TransportValidateQueryAction.java index 4437e80d96d..807a638c251 100644 --- a/core/src/main/java/org/elasticsearch/action/admin/indices/validate/query/TransportValidateQueryAction.java +++ b/core/src/main/java/org/elasticsearch/action/admin/indices/validate/query/TransportValidateQueryAction.java @@ -42,6 +42,7 @@ import org.elasticsearch.common.util.BigArrays; import org.elasticsearch.index.IndexService; import org.elasticsearch.index.engine.Engine; import org.elasticsearch.index.query.IndexQueryParserService; +import org.elasticsearch.index.query.QueryShardException; import org.elasticsearch.index.query.QueryParsingException; import org.elasticsearch.index.shard.IndexShard; import org.elasticsearch.indices.IndicesService; @@ -189,8 +190,8 @@ public class TransportValidateQueryAction extends TransportBroadcastAction 0) { try { - QueryParseContext.setTypes(request.types()); + QueryShardContext.setTypes(request.types()); context.parsedQuery(indexService.queryParserService().parseQuery(source)); } finally { - QueryParseContext.removeTypes(); + QueryShardContext.removeTypes(); } } context.preProcess(); diff --git a/core/src/main/java/org/elasticsearch/cluster/metadata/AliasValidator.java b/core/src/main/java/org/elasticsearch/cluster/metadata/AliasValidator.java index f12824de4ee..d5b398c048a 100644 --- a/core/src/main/java/org/elasticsearch/cluster/metadata/AliasValidator.java +++ b/core/src/main/java/org/elasticsearch/cluster/metadata/AliasValidator.java @@ -28,7 +28,7 @@ import org.elasticsearch.common.xcontent.XContentFactory; import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.index.Index; import org.elasticsearch.index.query.IndexQueryParserService; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.indices.InvalidAliasNameException; import java.io.IOException; @@ -142,10 +142,10 @@ public class AliasValidator extends AbstractComponent { } private void validateAliasFilter(XContentParser parser, IndexQueryParserService indexQueryParserService) throws IOException { - QueryParseContext context = indexQueryParserService.getParseContext(); + QueryShardContext context = indexQueryParserService.getShardContext(); try { context.reset(parser); - context.parseInnerFilter(); + context.parseContext().parseInnerFilter(); } finally { context.reset(null); parser.close(); diff --git a/core/src/main/java/org/elasticsearch/index/mapper/MappedFieldType.java b/core/src/main/java/org/elasticsearch/index/mapper/MappedFieldType.java index 7dc78ddd5e0..638cdce46d2 100644 --- a/core/src/main/java/org/elasticsearch/index/mapper/MappedFieldType.java +++ b/core/src/main/java/org/elasticsearch/index/mapper/MappedFieldType.java @@ -33,7 +33,7 @@ import org.elasticsearch.common.lucene.BytesRefs; import org.elasticsearch.common.unit.Fuzziness; import org.elasticsearch.index.analysis.NamedAnalyzer; import org.elasticsearch.index.fielddata.FieldDataType; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.index.similarity.SimilarityProvider; import java.io.IOException; @@ -425,7 +425,7 @@ public abstract class MappedFieldType extends FieldType { } /** - * Should the field query {@link #termQuery(Object, org.elasticsearch.index.query.QueryParseContext)} be used when detecting this + * Should the field query {@link #termQuery(Object, org.elasticsearch.index.query.QueryShardContext)} be used when detecting this * field in query string. */ public boolean useTermQueryWithQueryString() { @@ -437,11 +437,11 @@ public abstract class MappedFieldType extends FieldType { return new Term(names().indexName(), indexedValueForSearch(value)); } - public Query termQuery(Object value, @Nullable QueryParseContext context) { + public Query termQuery(Object value, @Nullable QueryShardContext context) { return new TermQuery(createTerm(value)); } - public Query termsQuery(List values, @Nullable QueryParseContext context) { + public Query termsQuery(List values, @Nullable QueryShardContext context) { BytesRef[] bytesRefs = new BytesRef[values.size()]; for (int i = 0; i < bytesRefs.length; i++) { bytesRefs[i] = indexedValueForSearch(values.get(i)); @@ -460,7 +460,7 @@ public abstract class MappedFieldType extends FieldType { return new FuzzyQuery(createTerm(value), fuzziness.asDistance(BytesRefs.toString(value)), prefixLength, maxExpansions, transpositions); } - public Query prefixQuery(String value, @Nullable MultiTermQuery.RewriteMethod method, @Nullable QueryParseContext context) { + public Query prefixQuery(String value, @Nullable MultiTermQuery.RewriteMethod method, @Nullable QueryShardContext context) { PrefixQuery query = new PrefixQuery(createTerm(value)); if (method != null) { query.setRewriteMethod(method); @@ -468,7 +468,7 @@ public abstract class MappedFieldType extends FieldType { return query; } - public Query regexpQuery(String value, int flags, int maxDeterminizedStates, @Nullable MultiTermQuery.RewriteMethod method, @Nullable QueryParseContext context) { + public Query regexpQuery(String value, int flags, int maxDeterminizedStates, @Nullable MultiTermQuery.RewriteMethod method, @Nullable QueryShardContext context) { RegexpQuery query = new RegexpQuery(createTerm(value), flags, maxDeterminizedStates); if (method != null) { query.setRewriteMethod(method); diff --git a/core/src/main/java/org/elasticsearch/index/mapper/internal/AllFieldMapper.java b/core/src/main/java/org/elasticsearch/index/mapper/internal/AllFieldMapper.java index f872207c686..e538a00da16 100644 --- a/core/src/main/java/org/elasticsearch/index/mapper/internal/AllFieldMapper.java +++ b/core/src/main/java/org/elasticsearch/index/mapper/internal/AllFieldMapper.java @@ -40,7 +40,7 @@ import org.elasticsearch.index.mapper.MergeMappingException; import org.elasticsearch.index.mapper.MergeResult; import org.elasticsearch.index.mapper.MetadataFieldMapper; import org.elasticsearch.index.mapper.ParseContext; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.index.similarity.SimilarityLookupService; import java.io.IOException; @@ -186,7 +186,7 @@ public class AllFieldMapper extends MetadataFieldMapper { } @Override - public Query termQuery(Object value, QueryParseContext context) { + public Query termQuery(Object value, QueryShardContext context) { return queryStringTermQuery(createTerm(value)); } } diff --git a/core/src/main/java/org/elasticsearch/index/mapper/internal/IdFieldMapper.java b/core/src/main/java/org/elasticsearch/index/mapper/internal/IdFieldMapper.java index 63fa41faea1..f6e09b20d22 100644 --- a/core/src/main/java/org/elasticsearch/index/mapper/internal/IdFieldMapper.java +++ b/core/src/main/java/org/elasticsearch/index/mapper/internal/IdFieldMapper.java @@ -49,7 +49,7 @@ import org.elasticsearch.index.mapper.MergeResult; import org.elasticsearch.index.mapper.MetadataFieldMapper; import org.elasticsearch.index.mapper.ParseContext; import org.elasticsearch.index.mapper.Uid; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import java.io.IOException; import java.util.Collection; @@ -167,7 +167,7 @@ public class IdFieldMapper extends MetadataFieldMapper { } @Override - public Query termQuery(Object value, @Nullable QueryParseContext context) { + public Query termQuery(Object value, @Nullable QueryShardContext context) { if (indexOptions() != IndexOptions.NONE || context == null) { return super.termQuery(value, context); } @@ -176,7 +176,7 @@ public class IdFieldMapper extends MetadataFieldMapper { } @Override - public Query termsQuery(List values, @Nullable QueryParseContext context) { + public Query termsQuery(List values, @Nullable QueryShardContext context) { if (indexOptions() != IndexOptions.NONE || context == null) { return super.termsQuery(values, context); } @@ -184,7 +184,7 @@ public class IdFieldMapper extends MetadataFieldMapper { } @Override - public Query prefixQuery(String value, @Nullable MultiTermQuery.RewriteMethod method, @Nullable QueryParseContext context) { + public Query prefixQuery(String value, @Nullable MultiTermQuery.RewriteMethod method, @Nullable QueryShardContext context) { if (indexOptions() != IndexOptions.NONE || context == null) { return super.prefixQuery(value, method, context); } @@ -201,7 +201,7 @@ public class IdFieldMapper extends MetadataFieldMapper { } @Override - public Query regexpQuery(String value, int flags, int maxDeterminizedStates, @Nullable MultiTermQuery.RewriteMethod method, @Nullable QueryParseContext context) { + public Query regexpQuery(String value, int flags, int maxDeterminizedStates, @Nullable MultiTermQuery.RewriteMethod method, @Nullable QueryShardContext context) { if (indexOptions() != IndexOptions.NONE || context == null) { return super.regexpQuery(value, flags, maxDeterminizedStates, method, context); } diff --git a/core/src/main/java/org/elasticsearch/index/mapper/internal/IndexFieldMapper.java b/core/src/main/java/org/elasticsearch/index/mapper/internal/IndexFieldMapper.java index 3f395a8e0d1..1b7168a2d1c 100644 --- a/core/src/main/java/org/elasticsearch/index/mapper/internal/IndexFieldMapper.java +++ b/core/src/main/java/org/elasticsearch/index/mapper/internal/IndexFieldMapper.java @@ -38,7 +38,7 @@ import org.elasticsearch.index.mapper.MergeMappingException; import org.elasticsearch.index.mapper.MergeResult; import org.elasticsearch.index.mapper.MetadataFieldMapper; import org.elasticsearch.index.mapper.ParseContext; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import java.io.IOException; import java.util.Iterator; @@ -157,7 +157,7 @@ public class IndexFieldMapper extends MetadataFieldMapper { * indices */ @Override - public Query termQuery(Object value, @Nullable QueryParseContext context) { + public Query termQuery(Object value, @Nullable QueryShardContext context) { if (context == null) { return super.termQuery(value, context); } @@ -171,7 +171,7 @@ public class IndexFieldMapper extends MetadataFieldMapper { @Override - public Query termsQuery(List values, QueryParseContext context) { + public Query termsQuery(List values, QueryShardContext context) { if (context == null) { return super.termsQuery(values, context); } diff --git a/core/src/main/java/org/elasticsearch/index/mapper/internal/ParentFieldMapper.java b/core/src/main/java/org/elasticsearch/index/mapper/internal/ParentFieldMapper.java index 5fcd10c0842..7cd4ac06820 100644 --- a/core/src/main/java/org/elasticsearch/index/mapper/internal/ParentFieldMapper.java +++ b/core/src/main/java/org/elasticsearch/index/mapper/internal/ParentFieldMapper.java @@ -43,7 +43,7 @@ import org.elasticsearch.index.mapper.MergeResult; import org.elasticsearch.index.mapper.MetadataFieldMapper; import org.elasticsearch.index.mapper.ParseContext; import org.elasticsearch.index.mapper.Uid; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import java.io.IOException; import java.util.ArrayList; @@ -189,12 +189,12 @@ public class ParentFieldMapper extends MetadataFieldMapper { } @Override - public Query termQuery(Object value, @Nullable QueryParseContext context) { + public Query termQuery(Object value, @Nullable QueryShardContext context) { return termsQuery(Collections.singletonList(value), context); } @Override - public Query termsQuery(List values, @Nullable QueryParseContext context) { + public Query termsQuery(List values, @Nullable QueryShardContext context) { if (context == null) { return super.termsQuery(values, context); } diff --git a/core/src/main/java/org/elasticsearch/index/mapper/internal/TypeFieldMapper.java b/core/src/main/java/org/elasticsearch/index/mapper/internal/TypeFieldMapper.java index 480d2a41818..12e40dec47a 100644 --- a/core/src/main/java/org/elasticsearch/index/mapper/internal/TypeFieldMapper.java +++ b/core/src/main/java/org/elasticsearch/index/mapper/internal/TypeFieldMapper.java @@ -43,7 +43,7 @@ import org.elasticsearch.index.mapper.MergeResult; import org.elasticsearch.index.mapper.MetadataFieldMapper; import org.elasticsearch.index.mapper.ParseContext; import org.elasticsearch.index.mapper.Uid; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import java.io.IOException; import java.util.List; @@ -137,7 +137,7 @@ public class TypeFieldMapper extends MetadataFieldMapper { } @Override - public Query termQuery(Object value, @Nullable QueryParseContext context) { + public Query termQuery(Object value, @Nullable QueryShardContext context) { if (indexOptions() == IndexOptions.NONE) { return new ConstantScoreQuery(new PrefixQuery(new Term(UidFieldMapper.NAME, Uid.typePrefixAsBytes(BytesRefs.toBytesRef(value))))); } diff --git a/core/src/main/java/org/elasticsearch/index/percolator/PercolatorQueriesRegistry.java b/core/src/main/java/org/elasticsearch/index/percolator/PercolatorQueriesRegistry.java index 3a230d1267f..29e83f69272 100644 --- a/core/src/main/java/org/elasticsearch/index/percolator/PercolatorQueriesRegistry.java +++ b/core/src/main/java/org/elasticsearch/index/percolator/PercolatorQueriesRegistry.java @@ -41,7 +41,7 @@ import org.elasticsearch.index.mapper.MapperService; import org.elasticsearch.index.mapper.internal.TypeFieldMapper; import org.elasticsearch.index.percolator.stats.ShardPercolateService; import org.elasticsearch.index.query.IndexQueryParserService; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.index.query.QueryParsingException; import org.elasticsearch.index.settings.IndexSettings; import org.elasticsearch.index.shard.AbstractIndexShardComponent; @@ -184,12 +184,13 @@ public class PercolatorQueriesRegistry extends AbstractIndexShardComponent imple } } + //norelease this method parses from xcontent to lucene query, need to re-investigate how to split context here private Query parseQuery(String type, XContentParser parser) { String[] previousTypes = null; if (type != null) { - QueryParseContext.setTypesWithPrevious(new String[]{type}); + QueryShardContext.setTypesWithPrevious(new String[]{type}); } - QueryParseContext context = queryParserService.getParseContext(); + QueryShardContext context = queryParserService.getShardContext(); try { context.reset(parser); // This means that fields in the query need to exist in the mapping prior to registering this query @@ -208,10 +209,10 @@ public class PercolatorQueriesRegistry extends AbstractIndexShardComponent imple context.setMapUnmappedFieldAsString(mapUnmappedFieldsAsString ? true : false); return queryParserService.parseInnerQuery(context); } catch (IOException e) { - throw new QueryParsingException(context, "Failed to parse", e); + throw new QueryParsingException(context.parseContext(), "Failed to parse", e); } finally { if (type != null) { - QueryParseContext.setTypes(previousTypes); + QueryShardContext.setTypes(previousTypes); } context.reset(null); } diff --git a/core/src/main/java/org/elasticsearch/index/query/AbstractQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/AbstractQueryBuilder.java index e674a8f1cd1..9e3628fb51f 100644 --- a/core/src/main/java/org/elasticsearch/index/query/AbstractQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/AbstractQueryBuilder.java @@ -68,20 +68,20 @@ public abstract class AbstractQueryBuilder exte } @Override - public final Query toQuery(QueryParseContext parseContext) throws IOException { - Query query = doToQuery(parseContext); + public final Query toQuery(QueryShardContext context) throws IOException { + Query query = doToQuery(context); if (query != null) { query.setBoost(boost); if (queryName != null) { - parseContext.addNamedQuery(queryName, query); + context.addNamedQuery(queryName, query); } } return query; } //norelease to be made abstract once all query builders override doToQuery providing their own specific implementation. - protected Query doToQuery(QueryParseContext parseContext) throws IOException { - return parseContext.indexQueryParserService().queryParser(getName()).parse(parseContext); + protected Query doToQuery(QueryShardContext context) throws IOException { + return context.indexQueryParserService().queryParser(getName()).parse(context); } @Override @@ -219,17 +219,17 @@ public abstract class AbstractQueryBuilder exte /** * Helper method to convert collection of {@link QueryBuilder} instances to lucene * {@link Query} instances. {@link QueryBuilder} that return null calling - * their {@link QueryBuilder#toQuery(QueryParseContext)} method are not added to the + * their {@link QueryBuilder#toQuery(QueryShardContext)} method are not added to the * resulting collection. * * @throws IOException - * @throws QueryParsingException + * @throws QueryShardException */ - protected static Collection toQueries(Collection queryBuilders, QueryParseContext parseContext) throws QueryParsingException, + protected static Collection toQueries(Collection queryBuilders, QueryShardContext context) throws QueryShardException, IOException { List queries = new ArrayList<>(queryBuilders.size()); for (QueryBuilder queryBuilder : queryBuilders) { - Query query = queryBuilder.toQuery(parseContext); + Query query = queryBuilder.toQuery(context); if (query != null) { queries.add(query); } diff --git a/core/src/main/java/org/elasticsearch/index/query/AndQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/AndQueryBuilder.java index 0bf145de14b..90879401fea 100644 --- a/core/src/main/java/org/elasticsearch/index/query/AndQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/AndQueryBuilder.java @@ -84,7 +84,7 @@ public class AndQueryBuilder extends AbstractQueryBuilder { } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { + protected Query doToQuery(QueryShardContext context) throws IOException { if (filters.isEmpty()) { // no filters provided, this should be ignored upstream return null; @@ -92,7 +92,7 @@ public class AndQueryBuilder extends AbstractQueryBuilder { BooleanQuery query = new BooleanQuery(); for (QueryBuilder f : filters) { - Query innerQuery = f.toQuery(parseContext); + Query innerQuery = f.toQuery(context); // ignore queries that are null if (innerQuery != null) { query.add(innerQuery, Occur.MUST); diff --git a/core/src/main/java/org/elasticsearch/index/query/BaseQueryParser.java b/core/src/main/java/org/elasticsearch/index/query/BaseQueryParser.java index 05626a59273..c3f04402ae6 100644 --- a/core/src/main/java/org/elasticsearch/index/query/BaseQueryParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/BaseQueryParser.java @@ -26,14 +26,14 @@ import java.io.IOException; /** * Class used during the query parsers refactoring. Will be removed once we can parse search requests on the coordinating node. * All query parsers that have a refactored "fromXContent" method can be changed to extend this instead of {@link BaseQueryParserTemp}. - * Keeps old {@link QueryParser#parse(QueryParseContext)} method as a stub delegating to - * {@link QueryParser#fromXContent(QueryParseContext)} and {@link QueryBuilder#toQuery(QueryParseContext)}} + * Keeps old {@link QueryParser#parse(QueryShardContext)} method as a stub delegating to + * {@link QueryParser#fromXContent(QueryShardContext)} and {@link QueryBuilder#toQuery(QueryShardContext)}} */ //norelease needs to be removed once we parse search requests on the coordinating node, as the parse method is not needed anymore at that point. public abstract class BaseQueryParser implements QueryParser { @Override - public final Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException { - return fromXContent(parseContext).toQuery(parseContext); + public final Query parse(QueryShardContext context) throws IOException, QueryParsingException { + return fromXContent(context.parseContext()).toQuery(context); } } diff --git a/core/src/main/java/org/elasticsearch/index/query/BaseQueryParserTemp.java b/core/src/main/java/org/elasticsearch/index/query/BaseQueryParserTemp.java index 38f1316d541..4dc3eae6034 100644 --- a/core/src/main/java/org/elasticsearch/index/query/BaseQueryParserTemp.java +++ b/core/src/main/java/org/elasticsearch/index/query/BaseQueryParserTemp.java @@ -33,7 +33,7 @@ public abstract class BaseQueryParserTemp implements QueryParser { @Override public QueryBuilder fromXContent(QueryParseContext parseContext) throws IOException, QueryParsingException { - Query query = parse(parseContext); + Query query = parse(parseContext.shardContext()); return new QueryWrappingQueryBuilder(query); } } diff --git a/core/src/main/java/org/elasticsearch/index/query/BoolQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/BoolQueryBuilder.java index 99db83bd976..f0076e4c6fd 100644 --- a/core/src/main/java/org/elasticsearch/index/query/BoolQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/BoolQueryBuilder.java @@ -254,12 +254,12 @@ public class BoolQueryBuilder extends AbstractQueryBuilder { } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { + protected Query doToQuery(QueryShardContext context) throws IOException { BooleanQuery booleanQuery = new BooleanQuery(disableCoord); - addBooleanClauses(parseContext, booleanQuery, mustClauses, BooleanClause.Occur.MUST); - addBooleanClauses(parseContext, booleanQuery, mustNotClauses, BooleanClause.Occur.MUST_NOT); - addBooleanClauses(parseContext, booleanQuery, shouldClauses, BooleanClause.Occur.SHOULD); - addBooleanClauses(parseContext, booleanQuery, filterClauses, BooleanClause.Occur.FILTER); + addBooleanClauses(context, booleanQuery, mustClauses, BooleanClause.Occur.MUST); + addBooleanClauses(context, booleanQuery, mustNotClauses, BooleanClause.Occur.MUST_NOT); + addBooleanClauses(context, booleanQuery, shouldClauses, BooleanClause.Occur.SHOULD); + addBooleanClauses(context, booleanQuery, filterClauses, BooleanClause.Occur.FILTER); if (booleanQuery.clauses().isEmpty()) { return new MatchAllDocsQuery(); @@ -279,9 +279,9 @@ public class BoolQueryBuilder extends AbstractQueryBuilder { return validationException; } - private static void addBooleanClauses(QueryParseContext parseContext, BooleanQuery booleanQuery, List clauses, Occur occurs) throws IOException { + private static void addBooleanClauses(QueryShardContext context, BooleanQuery booleanQuery, List clauses, Occur occurs) throws IOException { for (QueryBuilder query : clauses) { - Query luceneQuery = query.toQuery(parseContext); + Query luceneQuery = query.toQuery(context); if (luceneQuery != null) { booleanQuery.add(new BooleanClause(luceneQuery, occurs)); } diff --git a/core/src/main/java/org/elasticsearch/index/query/BoostingQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/BoostingQueryBuilder.java index 4e543506840..561b81a5e6f 100644 --- a/core/src/main/java/org/elasticsearch/index/query/BoostingQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/BoostingQueryBuilder.java @@ -129,9 +129,9 @@ public class BoostingQueryBuilder extends AbstractQueryBuilder } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { + protected Query doToQuery(QueryShardContext context) throws IOException { // return null if there are no queries at all - Collection luceneQueries = toQueries(queries, parseContext); + Collection luceneQueries = toQueries(queries, context); if (luceneQueries.isEmpty()) { return null; } diff --git a/core/src/main/java/org/elasticsearch/index/query/EmptyQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/EmptyQueryBuilder.java index 64b84bbe1b8..901584173d5 100644 --- a/core/src/main/java/org/elasticsearch/index/query/EmptyQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/EmptyQueryBuilder.java @@ -62,7 +62,7 @@ public class EmptyQueryBuilder extends ToXContentToBytes implements QueryBuilder } @Override - public Query toQuery(QueryParseContext parseContext) throws IOException { + public Query toQuery(QueryShardContext context) throws IOException { // empty return null; } diff --git a/core/src/main/java/org/elasticsearch/index/query/ExistsQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/ExistsQueryBuilder.java index 74aef8d9356..0ef9bfb35cf 100644 --- a/core/src/main/java/org/elasticsearch/index/query/ExistsQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/ExistsQueryBuilder.java @@ -63,8 +63,8 @@ public class ExistsQueryBuilder extends AbstractQueryBuilder } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { - return newFilter(parseContext, name); + protected Query doToQuery(QueryShardContext context) throws IOException { + return newFilter(context, name); } @Override @@ -73,20 +73,20 @@ public class ExistsQueryBuilder extends AbstractQueryBuilder return null; } - public static Query newFilter(QueryParseContext parseContext, String fieldPattern) { - final FieldNamesFieldMapper.FieldNamesFieldType fieldNamesFieldType = (FieldNamesFieldMapper.FieldNamesFieldType)parseContext.mapperService().fullName(FieldNamesFieldMapper.NAME); + public static Query newFilter(QueryShardContext context, String fieldPattern) { + final FieldNamesFieldMapper.FieldNamesFieldType fieldNamesFieldType = (FieldNamesFieldMapper.FieldNamesFieldType)context.mapperService().fullName(FieldNamesFieldMapper.NAME); if (fieldNamesFieldType == null) { // can only happen when no types exist, so no docs exist either return Queries.newMatchNoDocsQuery(); } - ObjectMapper objectMapper = parseContext.getObjectMapper(fieldPattern); + ObjectMapper objectMapper = context.getObjectMapper(fieldPattern); if (objectMapper != null) { // automatic make the object mapper pattern fieldPattern = fieldPattern + ".*"; } - Collection fields = parseContext.simpleMatchToIndexNames(fieldPattern); + Collection fields = context.simpleMatchToIndexNames(fieldPattern); if (fields.isEmpty()) { // no fields exists, so we should not match anything return Queries.newMatchNoDocsQuery(); @@ -94,7 +94,7 @@ public class ExistsQueryBuilder extends AbstractQueryBuilder BooleanQuery boolFilter = new BooleanQuery(); for (String field : fields) { - MappedFieldType fieldType = parseContext.fieldMapper(field); + MappedFieldType fieldType = context.fieldMapper(field); Query filter = null; if (fieldNamesFieldType.isEnabled()) { final String f; @@ -103,7 +103,7 @@ public class ExistsQueryBuilder extends AbstractQueryBuilder } else { f = field; } - filter = fieldNamesFieldType.termQuery(f, parseContext); + filter = fieldNamesFieldType.termQuery(f, context); } // if _field_names are not indexed, we need to go the slow way if (filter == null && fieldType != null) { diff --git a/core/src/main/java/org/elasticsearch/index/query/FQueryFilterBuilder.java b/core/src/main/java/org/elasticsearch/index/query/FQueryFilterBuilder.java index c9467cb9a29..5ec6318baa7 100644 --- a/core/src/main/java/org/elasticsearch/index/query/FQueryFilterBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/FQueryFilterBuilder.java @@ -69,9 +69,9 @@ public class FQueryFilterBuilder extends AbstractQueryBuilder geohashes) { + public static Query create(QueryShardContext context, GeoPointFieldMapper.GeoPointFieldType fieldType, String geohash, @Nullable List geohashes) { MappedFieldType geoHashMapper = fieldType.geohashFieldType(); if (geoHashMapper == null) { throw new IllegalArgumentException("geohash filter needs geohash_prefix to be enabled"); @@ -186,7 +186,8 @@ public class GeohashCellQuery { } @Override - public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException { + public Query parse(QueryShardContext context) throws IOException, QueryParsingException { + QueryParseContext parseContext = context.parseContext(); XContentParser parser = parseContext.parser(); String fieldName = null; @@ -248,7 +249,7 @@ public class GeohashCellQuery { throw new QueryParsingException(parseContext, "failed to parse [{}] query. missing geohash value", NAME); } - MappedFieldType fieldType = parseContext.fieldMapper(fieldName); + MappedFieldType fieldType = context.fieldMapper(fieldName); if (fieldType == null) { throw new QueryParsingException(parseContext, "failed to parse [{}] query. missing [{}] field [{}]", NAME, GeoPointFieldMapper.CONTENT_TYPE, fieldName); } @@ -269,12 +270,12 @@ public class GeohashCellQuery { Query filter; if (neighbors) { - filter = create(parseContext, geoFieldType, geohash, GeoHashUtils.addNeighbors(geohash, new ArrayList(8))); + filter = create(context, geoFieldType, geohash, GeoHashUtils.addNeighbors(geohash, new ArrayList(8))); } else { - filter = create(parseContext, geoFieldType, geohash, null); + filter = create(context, geoFieldType, geohash, null); } if (queryName != null) { - parseContext.addNamedQuery(queryName, filter); + context.addNamedQuery(queryName, filter); } if (filter != null) { filter.setBoost(boost); diff --git a/core/src/main/java/org/elasticsearch/index/query/HasChildQueryParser.java b/core/src/main/java/org/elasticsearch/index/query/HasChildQueryParser.java index 9e379978e38..ba2ef65309b 100644 --- a/core/src/main/java/org/elasticsearch/index/query/HasChildQueryParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/HasChildQueryParser.java @@ -22,9 +22,6 @@ package org.elasticsearch.index.query; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.MultiDocValues; import org.apache.lucene.search.*; -import org.apache.lucene.search.Filter; -import org.apache.lucene.search.Query; -import org.apache.lucene.search.QueryWrapperFilter; import org.apache.lucene.search.join.BitDocIdSetFilter; import org.elasticsearch.common.ParseField; import org.apache.lucene.search.join.JoinUtil; @@ -70,7 +67,8 @@ public class HasChildQueryParser extends BaseQueryParserTemp { } @Override - public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException { + public Query parse(QueryShardContext context) throws IOException, QueryParsingException { + QueryParseContext parseContext = context.parseContext(); XContentParser parser = parseContext.parser(); boolean queryFound = false; @@ -140,7 +138,7 @@ public class HasChildQueryParser extends BaseQueryParserTemp { } innerQuery.setBoost(boost); - DocumentMapper childDocMapper = parseContext.mapperService().documentMapper(childType); + DocumentMapper childDocMapper = context.mapperService().documentMapper(childType); if (childDocMapper == null) { throw new QueryParsingException(parseContext, "[has_child] No mapping for for type [" + childType + "]"); } @@ -150,14 +148,14 @@ public class HasChildQueryParser extends BaseQueryParserTemp { } if (innerHits != null) { - ParsedQuery parsedQuery = new ParsedQuery(innerQuery, parseContext.copyNamedQueries()); - InnerHitsContext.ParentChildInnerHits parentChildInnerHits = new InnerHitsContext.ParentChildInnerHits(innerHits.v2(), parsedQuery, null, parseContext.mapperService(), childDocMapper); + ParsedQuery parsedQuery = new ParsedQuery(innerQuery, context.copyNamedQueries()); + InnerHitsContext.ParentChildInnerHits parentChildInnerHits = new InnerHitsContext.ParentChildInnerHits(innerHits.v2(), parsedQuery, null, context.mapperService(), childDocMapper); String name = innerHits.v1() != null ? innerHits.v1() : childType; - parseContext.addInnerHits(name, parentChildInnerHits); + context.addInnerHits(name, parentChildInnerHits); } String parentType = parentFieldMapper.type(); - DocumentMapper parentDocMapper = parseContext.mapperService().documentMapper(parentType); + DocumentMapper parentDocMapper = context.mapperService().documentMapper(parentType); if (parentDocMapper == null) { throw new QueryParsingException(parseContext, "[has_child] Type [" + childType + "] points to a non existent parent type [" + parentType + "]"); @@ -169,15 +167,15 @@ public class HasChildQueryParser extends BaseQueryParserTemp { BitDocIdSetFilter nonNestedDocsFilter = null; if (parentDocMapper.hasNestedObjects()) { - nonNestedDocsFilter = parseContext.bitsetFilter(Queries.newNonNestedFilter()); + nonNestedDocsFilter = context.bitsetFilter(Queries.newNonNestedFilter()); } // wrap the query with type query innerQuery = Queries.filtered(innerQuery, childDocMapper.typeFilter()); final Query query; - final ParentChildIndexFieldData parentChildIndexFieldData = parseContext.getForField(parentFieldMapper.fieldType()); - if (parseContext.indexVersionCreated().onOrAfter(Version.V_2_0_0_beta1)) { + final ParentChildIndexFieldData parentChildIndexFieldData = context.getForField(parentFieldMapper.fieldType()); + if (context.indexVersionCreated().onOrAfter(Version.V_2_0_0_beta1)) { query = joinUtilHelper(parentType, parentChildIndexFieldData, parentDocMapper.typeFilter(), scoreType, innerQuery, minChildren, maxChildren); } else { // TODO: use the query API @@ -191,7 +189,7 @@ public class HasChildQueryParser extends BaseQueryParserTemp { } } if (queryName != null) { - parseContext.addNamedQuery(queryName, query); + context.addNamedQuery(queryName, query); } query.setBoost(boost); return query; @@ -288,7 +286,7 @@ public class HasChildQueryParser extends BaseQueryParserTemp { return "LateParsingQuery {parentType=" + parentType + "}"; } } - + @Override public HasChildQueryBuilder getBuilderPrototype() { return HasChildQueryBuilder.PROTOTYPE; diff --git a/core/src/main/java/org/elasticsearch/index/query/HasParentQueryParser.java b/core/src/main/java/org/elasticsearch/index/query/HasParentQueryParser.java index 5b69eec9de3..00f8884530c 100644 --- a/core/src/main/java/org/elasticsearch/index/query/HasParentQueryParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/HasParentQueryParser.java @@ -64,7 +64,8 @@ public class HasParentQueryParser extends BaseQueryParserTemp { } @Override - public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException { + public Query parse(QueryShardContext context) throws IOException, QueryParsingException { + QueryParseContext parseContext = context.parseContext(); XContentParser parser = parseContext.parser(); boolean queryFound = false; @@ -133,40 +134,40 @@ public class HasParentQueryParser extends BaseQueryParserTemp { } innerQuery.setBoost(boost); - Query query = createParentQuery(innerQuery, parentType, score, parseContext, innerHits); + Query query = createParentQuery(innerQuery, parentType, score, context, innerHits); if (query == null) { return null; } query.setBoost(boost); if (queryName != null) { - parseContext.addNamedQuery(queryName, query); + context.addNamedQuery(queryName, query); } return query; } - static Query createParentQuery(Query innerQuery, String parentType, boolean score, QueryParseContext parseContext, Tuple innerHits) throws IOException { - DocumentMapper parentDocMapper = parseContext.mapperService().documentMapper(parentType); + static Query createParentQuery(Query innerQuery, String parentType, boolean score, QueryShardContext context, Tuple innerHits) throws IOException { + DocumentMapper parentDocMapper = context.mapperService().documentMapper(parentType); if (parentDocMapper == null) { - throw new QueryParsingException(parseContext, "[has_parent] query configured 'parent_type' [" + parentType + throw new QueryParsingException(context.parseContext(), "[has_parent] query configured 'parent_type' [" + parentType + "] is not a valid type"); } if (innerHits != null) { - ParsedQuery parsedQuery = new ParsedQuery(innerQuery, parseContext.copyNamedQueries()); - InnerHitsContext.ParentChildInnerHits parentChildInnerHits = new InnerHitsContext.ParentChildInnerHits(innerHits.v2(), parsedQuery, null, parseContext.mapperService(), parentDocMapper); + ParsedQuery parsedQuery = new ParsedQuery(innerQuery, context.copyNamedQueries()); + InnerHitsContext.ParentChildInnerHits parentChildInnerHits = new InnerHitsContext.ParentChildInnerHits(innerHits.v2(), parsedQuery, null, context.mapperService(), parentDocMapper); String name = innerHits.v1() != null ? innerHits.v1() : parentType; - parseContext.addInnerHits(name, parentChildInnerHits); + context.addInnerHits(name, parentChildInnerHits); } Set parentTypes = new HashSet<>(5); parentTypes.add(parentDocMapper.type()); ParentChildIndexFieldData parentChildIndexFieldData = null; - for (DocumentMapper documentMapper : parseContext.mapperService().docMappers(false)) { + for (DocumentMapper documentMapper : context.mapperService().docMappers(false)) { ParentFieldMapper parentFieldMapper = documentMapper.parentFieldMapper(); if (parentFieldMapper.active()) { - DocumentMapper parentTypeDocumentMapper = parseContext.mapperService().documentMapper(parentFieldMapper.type()); - parentChildIndexFieldData = parseContext.getForField(parentFieldMapper.fieldType()); + DocumentMapper parentTypeDocumentMapper = context.mapperService().documentMapper(parentFieldMapper.type()); + parentChildIndexFieldData = context.getForField(parentFieldMapper.fieldType()); if (parentTypeDocumentMapper == null) { // Only add this, if this parentFieldMapper (also a parent) isn't a child of another parent. parentTypes.add(parentFieldMapper.type()); @@ -174,19 +175,19 @@ public class HasParentQueryParser extends BaseQueryParserTemp { } } if (parentChildIndexFieldData == null) { - throw new QueryParsingException(parseContext, "[has_parent] no _parent field configured"); + throw new QueryParsingException(context.parseContext(), "[has_parent] no _parent field configured"); } Query parentFilter = null; if (parentTypes.size() == 1) { - DocumentMapper documentMapper = parseContext.mapperService().documentMapper(parentTypes.iterator().next()); + DocumentMapper documentMapper = context.mapperService().documentMapper(parentTypes.iterator().next()); if (documentMapper != null) { parentFilter = documentMapper.typeFilter(); } } else { BooleanQuery parentsFilter = new BooleanQuery(); for (String parentTypeStr : parentTypes) { - DocumentMapper documentMapper = parseContext.mapperService().documentMapper(parentTypeStr); + DocumentMapper documentMapper = context.mapperService().documentMapper(parentTypeStr); if (documentMapper != null) { parentsFilter.add(documentMapper.typeFilter(), BooleanClause.Occur.SHOULD); } @@ -201,7 +202,7 @@ public class HasParentQueryParser extends BaseQueryParserTemp { // wrap the query with type query innerQuery = Queries.filtered(innerQuery, parentDocMapper.typeFilter()); Filter childrenFilter = new QueryWrapperFilter(Queries.not(parentFilter)); - if (parseContext.indexVersionCreated().onOrAfter(Version.V_2_0_0_beta1)) { + if (context.indexVersionCreated().onOrAfter(Version.V_2_0_0_beta1)) { ScoreType scoreMode = score ? ScoreType.MAX : ScoreType.NONE; return joinUtilHelper(parentType, parentChildIndexFieldData, childrenFilter, scoreMode, innerQuery, 0, Integer.MAX_VALUE); } else { diff --git a/core/src/main/java/org/elasticsearch/index/query/IdsQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/IdsQueryBuilder.java index 9699bc431a1..3649a676087 100644 --- a/core/src/main/java/org/elasticsearch/index/query/IdsQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/IdsQueryBuilder.java @@ -124,16 +124,16 @@ public class IdsQueryBuilder extends AbstractQueryBuilder { } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { + protected Query doToQuery(QueryShardContext context) throws IOException { Query query; if (this.ids.isEmpty()) { query = Queries.newMatchNoDocsQuery(); } else { Collection typesForQuery; if (types == null || types.length == 0) { - typesForQuery = parseContext.queryTypes(); + typesForQuery = context.queryTypes(); } else if (types.length == 1 && MetaData.ALL.equals(types[0])) { - typesForQuery = parseContext.mapperService().types(); + typesForQuery = context.mapperService().types(); } else { typesForQuery = Sets.newHashSet(types); } diff --git a/core/src/main/java/org/elasticsearch/index/query/IndexQueryParserService.java b/core/src/main/java/org/elasticsearch/index/query/IndexQueryParserService.java index 810504aefd7..5be792bba5f 100644 --- a/core/src/main/java/org/elasticsearch/index/query/IndexQueryParserService.java +++ b/core/src/main/java/org/elasticsearch/index/query/IndexQueryParserService.java @@ -53,10 +53,10 @@ public class IndexQueryParserService extends AbstractIndexComponent { public static final String PARSE_STRICT = "index.query.parse.strict"; public static final String ALLOW_UNMAPPED = "index.query.parse.allow_unmapped_fields"; - private CloseableThreadLocal cache = new CloseableThreadLocal() { + private CloseableThreadLocal cache = new CloseableThreadLocal() { @Override - protected QueryParseContext initialValue() { - return new QueryParseContext(index, IndexQueryParserService.this); + protected QueryShardContext initialValue() { + return new QueryShardContext(index, IndexQueryParserService.this); } }; @@ -120,16 +120,20 @@ public class IndexQueryParserService extends AbstractIndexComponent { return indicesQueriesRegistry.queryParsers().get(name); } + public IndicesQueriesRegistry indicesQueriesRegistry() { + return indicesQueriesRegistry; + } + public ParsedQuery parse(QueryBuilder queryBuilder) { XContentParser parser = null; try { BytesReference bytes = queryBuilder.buildAsBytes(); parser = XContentFactory.xContent(bytes).createParser(bytes); return parse(cache.get(), parser); - } catch (QueryParsingException e) { + } catch (QueryShardException e) { throw e; } catch (Exception e) { - throw new QueryParsingException(getParseContext(), "Failed to parse", e); + throw new QueryParsingException(getShardContext().parseContext(), "Failed to parse", e); } finally { if (parser != null) { parser.close(); @@ -146,10 +150,10 @@ public class IndexQueryParserService extends AbstractIndexComponent { try { parser = XContentFactory.xContent(source, offset, length).createParser(source, offset, length); return parse(cache.get(), parser); - } catch (QueryParsingException e) { + } catch (QueryShardException e) { throw e; } catch (Exception e) { - throw new QueryParsingException(getParseContext(), "Failed to parse", e); + throw new QueryParsingException(getShardContext().parseContext(), "Failed to parse", e); } finally { if (parser != null) { parser.close(); @@ -161,7 +165,8 @@ public class IndexQueryParserService extends AbstractIndexComponent { return parse(cache.get(), source); } - public ParsedQuery parse(QueryParseContext context, BytesReference source) { + //norelease + public ParsedQuery parse(QueryShardContext context, BytesReference source) { XContentParser parser = null; try { parser = XContentFactory.xContent(source).createParser(source); @@ -169,7 +174,7 @@ public class IndexQueryParserService extends AbstractIndexComponent { } catch (QueryParsingException e) { throw e; } catch (Exception e) { - throw new QueryParsingException(context, "Failed to parse", e); + throw new QueryParsingException(context.parseContext(), "Failed to parse", e); } finally { if (parser != null) { parser.close(); @@ -177,15 +182,15 @@ public class IndexQueryParserService extends AbstractIndexComponent { } } - public ParsedQuery parse(String source) throws QueryParsingException { + public ParsedQuery parse(String source) throws QueryParsingException, QueryShardException { XContentParser parser = null; try { parser = XContentFactory.xContent(source).createParser(source); return innerParse(cache.get(), parser); - } catch (QueryParsingException e) { + } catch (QueryShardException|QueryParsingException e) { throw e; } catch (Exception e) { - throw new QueryParsingException(getParseContext(), "Failed to parse [" + source + "]", e); + throw new QueryParsingException(getShardContext().parseContext(), "Failed to parse [" + source + "]", e); } finally { if (parser != null) { parser.close(); @@ -197,11 +202,12 @@ public class IndexQueryParserService extends AbstractIndexComponent { return parse(cache.get(), parser); } - public ParsedQuery parse(QueryParseContext context, XContentParser parser) { + //norelease + public ParsedQuery parse(QueryShardContext context, XContentParser parser) { try { return innerParse(context, parser); } catch (IOException e) { - throw new QueryParsingException(context, "Failed to parse", e); + throw new QueryParsingException(context.parseContext(), "Failed to parse", e); } } @@ -209,11 +215,12 @@ public class IndexQueryParserService extends AbstractIndexComponent { * Parses an inner filter, returning null if the filter should be ignored. */ @Nullable + //norelease public ParsedQuery parseInnerFilter(XContentParser parser) throws IOException { - QueryParseContext context = cache.get(); + QueryShardContext context = cache.get(); context.reset(parser); try { - Query filter = context.parseInnerFilter(); + Query filter = context.parseContext().parseInnerFilter(); if (filter == null) { return null; } @@ -224,27 +231,23 @@ public class IndexQueryParserService extends AbstractIndexComponent { } @Nullable - public Query parseInnerQuery(XContentParser parser) throws IOException { - QueryParseContext context = cache.get(); - context.reset(parser); - try { - return context.parseInnerQuery(); - } finally { - context.reset(null); - } + public QueryBuilder parseInnerQueryBuilder(QueryParseContext parseContext) throws IOException { + parseContext.parseFieldMatcher(parseFieldMatcher); + QueryBuilder query = parseContext.parseInnerQueryBuilder(); + return query; } @Nullable - public Query parseInnerQuery(QueryParseContext parseContext) throws IOException { - parseContext.parseFieldMatcher(parseFieldMatcher); - Query query = parseContext.parseInnerQuery(); + //norelease + public Query parseInnerQuery(QueryShardContext context) throws IOException { + Query query = context.parseContext().parseInnerQueryBuilder().toQuery(context); if (query == null) { query = Queries.newMatchNoDocsQuery(); } return query; } - public QueryParseContext getParseContext() { + public QueryShardContext getShardContext() { return cache.get(); } @@ -276,36 +279,41 @@ public class IndexQueryParserService extends AbstractIndexComponent { XContentParser qSourceParser = XContentFactory.xContent(querySource).createParser(querySource); parsedQuery = parse(qSourceParser); } else { - throw new QueryParsingException(getParseContext(), "request does not support [" + fieldName + "]"); + throw new QueryParsingException(getShardContext().parseContext(), "request does not support [" + fieldName + "]"); } } } if (parsedQuery != null) { return parsedQuery; } - } catch (QueryParsingException e) { + } catch (QueryShardException e) { throw e; } catch (Throwable e) { - throw new QueryParsingException(getParseContext(), "Failed to parse", e); + throw new QueryParsingException(getShardContext().parseContext(), "Failed to parse", e); } - throw new QueryParsingException(getParseContext(), "Required query is missing"); + throw new QueryParsingException(getShardContext().parseContext(), "Required query is missing"); } - private ParsedQuery innerParse(QueryParseContext parseContext, XContentParser parser) throws IOException, QueryParsingException { - parseContext.reset(parser); + //norelease + private ParsedQuery innerParse(QueryShardContext context, XContentParser parser) throws IOException, QueryShardException { + context.reset(parser); try { - parseContext.parseFieldMatcher(parseFieldMatcher); - Query query = parseContext.parseInnerQuery(); - if (query == null) { - query = Queries.newMatchNoDocsQuery(); - } - return new ParsedQuery(query, parseContext.copyNamedQueries()); + context.parseFieldMatcher(parseFieldMatcher); + return innerParse(context, context.parseContext().parseInnerQueryBuilder()); } finally { - parseContext.reset(null); + context.reset(null); } } + private static ParsedQuery innerParse(QueryShardContext context, QueryBuilder queryBuilder) throws IOException, QueryShardException { + Query query = queryBuilder.toQuery(context); + if (query == null) { + query = Queries.newMatchNoDocsQuery(); + } + return new ParsedQuery(query, context.copyNamedQueries()); + } + public ParseFieldMatcher parseFieldMatcher() { return parseFieldMatcher; } diff --git a/core/src/main/java/org/elasticsearch/index/query/IndicesQueryParser.java b/core/src/main/java/org/elasticsearch/index/query/IndicesQueryParser.java index 54e09f49478..d368d6b4586 100644 --- a/core/src/main/java/org/elasticsearch/index/query/IndicesQueryParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/IndicesQueryParser.java @@ -58,7 +58,8 @@ public class IndicesQueryParser extends BaseQueryParserTemp { } @Override - public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException { + public Query parse(QueryShardContext context) throws IOException, QueryParsingException { + QueryParseContext parseContext = context.parseContext(); XContentParser parser = parseContext.parser(); Query noMatchQuery = null; @@ -149,7 +150,7 @@ public class IndicesQueryParser extends BaseQueryParserTemp { } } if (queryName != null) { - parseContext.addNamedQuery(queryName, chosenQuery); + context.addNamedQuery(queryName, chosenQuery); } chosenQuery.setBoost(boost); return chosenQuery; diff --git a/core/src/main/java/org/elasticsearch/index/query/LimitQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/LimitQueryBuilder.java index f3731509789..ad246c7fc81 100644 --- a/core/src/main/java/org/elasticsearch/index/query/LimitQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/LimitQueryBuilder.java @@ -55,7 +55,7 @@ public class LimitQueryBuilder extends AbstractQueryBuilder { } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { + protected Query doToQuery(QueryShardContext context) throws IOException { // this filter is deprecated and parses to a filter that matches everything return Queries.newMatchAllQuery(); } diff --git a/core/src/main/java/org/elasticsearch/index/query/MatchAllQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/MatchAllQueryBuilder.java index fb33209066c..bb6b666b904 100644 --- a/core/src/main/java/org/elasticsearch/index/query/MatchAllQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/MatchAllQueryBuilder.java @@ -44,7 +44,7 @@ public class MatchAllQueryBuilder extends AbstractQueryBuilder fields = parseContext.simpleMatchToIndexNames(fieldPattern); + Collection fields = context.simpleMatchToIndexNames(fieldPattern); if (fields.isEmpty()) { if (existence) { // if we ask for existence of fields, and we found none, then we should match on all @@ -146,7 +146,7 @@ public class MissingQueryBuilder extends AbstractQueryBuilder moreLikeFields = null; boolean failOnUnsupportedField = true; @@ -142,7 +144,7 @@ public class MoreLikeThisQueryParser extends BaseQueryParserTemp { } else if (parseContext.parseFieldMatcher().match(currentFieldName, Fields.MINIMUM_SHOULD_MATCH)) { mltQuery.setMinimumShouldMatch(parser.text()); } else if ("analyzer".equals(currentFieldName)) { - analyzer = parseContext.analysisService().analyzer(parser.text()); + analyzer = context.analysisService().analyzer(parser.text()); } else if ("boost".equals(currentFieldName)) { mltQuery.setBoost(parser.floatValue()); } else if (parseContext.parseFieldMatcher().match(currentFieldName, Fields.FAIL_ON_UNSUPPORTED_FIELD)) { @@ -165,7 +167,7 @@ public class MoreLikeThisQueryParser extends BaseQueryParserTemp { moreLikeFields = Lists.newLinkedList(); while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) { String field = parser.text(); - MappedFieldType fieldType = parseContext.fieldMapper(field); + MappedFieldType fieldType = context.fieldMapper(field); moreLikeFields.add(fieldType == null ? field : fieldType.names().indexName()); } } else if (parseContext.parseFieldMatcher().match(currentFieldName, Fields.DOCUMENT_IDS)) { @@ -214,14 +216,14 @@ public class MoreLikeThisQueryParser extends BaseQueryParserTemp { // set analyzer if (analyzer == null) { - analyzer = parseContext.mapperService().searchAnalyzer(); + analyzer = context.mapperService().searchAnalyzer(); } mltQuery.setAnalyzer(analyzer); // set like text fields boolean useDefaultField = (moreLikeFields == null); if (useDefaultField) { - moreLikeFields = Lists.newArrayList(parseContext.defaultField()); + moreLikeFields = Lists.newArrayList(context.defaultField()); } // possibly remove unsupported fields removeUnsupportedFields(moreLikeFields, analyzer, failOnUnsupportedField); @@ -232,7 +234,7 @@ public class MoreLikeThisQueryParser extends BaseQueryParserTemp { // support for named query if (queryName != null) { - parseContext.addNamedQuery(queryName, mltQuery); + context.addNamedQuery(queryName, mltQuery); } // handle like texts @@ -256,12 +258,12 @@ public class MoreLikeThisQueryParser extends BaseQueryParserTemp { item.index(parseContext.index().name()); } if (item.type() == null) { - if (parseContext.queryTypes().size() > 1) { + if (context.queryTypes().size() > 1) { throw new QueryParsingException(parseContext, "ambiguous type for item with id: " + item.id() + " and index: " + item.index()); } else { - item.type(parseContext.queryTypes().iterator().next()); + item.type(context.queryTypes().iterator().next()); } } // default fields if not present but don't override for artificial docs diff --git a/core/src/main/java/org/elasticsearch/index/query/MultiMatchQueryParser.java b/core/src/main/java/org/elasticsearch/index/query/MultiMatchQueryParser.java index e352db13375..fcd79d81015 100644 --- a/core/src/main/java/org/elasticsearch/index/query/MultiMatchQueryParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/MultiMatchQueryParser.java @@ -50,14 +50,15 @@ public class MultiMatchQueryParser extends BaseQueryParserTemp { } @Override - public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException { + public Query parse(QueryShardContext context) throws IOException, QueryParsingException { + QueryParseContext parseContext = context.parseContext(); XContentParser parser = parseContext.parser(); Object value = null; float boost = AbstractQueryBuilder.DEFAULT_BOOST; Float tieBreaker = null; MultiMatchQueryBuilder.Type type = null; - MultiMatchQuery multiMatchQuery = new MultiMatchQuery(parseContext); + MultiMatchQuery multiMatchQuery = new MultiMatchQuery(context); String minimumShouldMatch = null; Map fieldNameWithBoosts = Maps.newHashMap(); String queryName = null; @@ -70,10 +71,10 @@ public class MultiMatchQueryParser extends BaseQueryParserTemp { } else if ("fields".equals(currentFieldName)) { if (token == XContentParser.Token.START_ARRAY) { while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) { - extractFieldAndBoost(parseContext, parser, fieldNameWithBoosts); + extractFieldAndBoost(context, parser, fieldNameWithBoosts); } } else if (token.isValue()) { - extractFieldAndBoost(parseContext, parser, fieldNameWithBoosts); + extractFieldAndBoost(context, parser, fieldNameWithBoosts); } else { throw new QueryParsingException(parseContext, "[" + MultiMatchQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]"); } @@ -84,7 +85,7 @@ public class MultiMatchQueryParser extends BaseQueryParserTemp { type = MultiMatchQueryBuilder.Type.parse(parser.text(), parseContext.parseFieldMatcher()); } else if ("analyzer".equals(currentFieldName)) { String analyzer = parser.text(); - if (parseContext.analysisService().analyzer(analyzer) == null) { + if (context.analysisService().analyzer(analyzer) == null) { throw new QueryParsingException(parseContext, "[" + MultiMatchQueryBuilder.NAME + "] analyzer [" + parser.text() + "] not found"); } multiMatchQuery.setAnalyzer(analyzer); @@ -156,12 +157,12 @@ public class MultiMatchQueryParser extends BaseQueryParserTemp { query.setBoost(boost); if (queryName != null) { - parseContext.addNamedQuery(queryName, query); + context.addNamedQuery(queryName, query); } return query; } - private void extractFieldAndBoost(QueryParseContext parseContext, XContentParser parser, Map fieldNameWithBoosts) throws IOException { + private void extractFieldAndBoost(QueryShardContext context, XContentParser parser, Map fieldNameWithBoosts) throws IOException { String fField = null; Float fBoost = null; char[] fieldText = parser.textCharacters(); @@ -179,7 +180,7 @@ public class MultiMatchQueryParser extends BaseQueryParserTemp { } if (Regex.isSimpleMatchPattern(fField)) { - for (String field : parseContext.mapperService().simpleMatchToIndexNames(fField)) { + for (String field : context.mapperService().simpleMatchToIndexNames(fField)) { fieldNameWithBoosts.put(field, fBoost); } } else { diff --git a/core/src/main/java/org/elasticsearch/index/query/NestedQueryParser.java b/core/src/main/java/org/elasticsearch/index/query/NestedQueryParser.java index 75227795392..7e4b3765578 100644 --- a/core/src/main/java/org/elasticsearch/index/query/NestedQueryParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/NestedQueryParser.java @@ -54,9 +54,10 @@ public class NestedQueryParser extends BaseQueryParserTemp { } @Override - public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException { + public Query parse(QueryShardContext context) throws IOException, QueryParsingException { + QueryParseContext parseContext = context.parseContext(); XContentParser parser = parseContext.parser(); - final ToBlockJoinQueryBuilder builder = new ToBlockJoinQueryBuilder(parseContext); + final ToBlockJoinQueryBuilder builder = new ToBlockJoinQueryBuilder(context); float boost = AbstractQueryBuilder.DEFAULT_BOOST; ScoreMode scoreMode = ScoreMode.Avg; @@ -110,7 +111,7 @@ public class NestedQueryParser extends BaseQueryParserTemp { if (joinQuery != null) { joinQuery.setBoost(boost); if (queryName != null) { - parseContext.addNamedQuery(queryName, joinQuery); + context.addNamedQuery(queryName, joinQuery); } } return joinQuery; @@ -121,8 +122,8 @@ public class NestedQueryParser extends BaseQueryParserTemp { private ScoreMode scoreMode; private Tuple innerHits; - public ToBlockJoinQueryBuilder(QueryParseContext parseContext) throws IOException { - super(parseContext); + public ToBlockJoinQueryBuilder(QueryShardContext context) throws IOException { + super(context); } public void setScoreMode(ScoreMode scoreMode) { @@ -146,14 +147,14 @@ public class NestedQueryParser extends BaseQueryParserTemp { innerQuery = null; } } else { - throw new QueryParsingException(parseContext, "[nested] requires either 'query' or 'filter' field"); + throw new QueryShardException(shardContext, "[nested] requires either 'query' or 'filter' field"); } if (innerHits != null) { - ParsedQuery parsedQuery = new ParsedQuery(innerQuery, parseContext.copyNamedQueries()); + ParsedQuery parsedQuery = new ParsedQuery(innerQuery, shardContext.copyNamedQueries()); InnerHitsContext.NestedInnerHits nestedInnerHits = new InnerHitsContext.NestedInnerHits(innerHits.v2(), parsedQuery, null, getParentObjectMapper(), nestedObjectMapper); String name = innerHits.v1() != null ? innerHits.v1() : path; - parseContext.addInnerHits(name, nestedInnerHits); + shardContext.addInnerHits(name, nestedInnerHits); } if (innerQuery != null) { diff --git a/core/src/main/java/org/elasticsearch/index/query/NotQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/NotQueryBuilder.java index e3ec58b4601..7f3fa0dd2e9 100644 --- a/core/src/main/java/org/elasticsearch/index/query/NotQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/NotQueryBuilder.java @@ -60,8 +60,8 @@ public class NotQueryBuilder extends AbstractQueryBuilder { } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { - Query luceneQuery = filter.toQuery(parseContext); + protected Query doToQuery(QueryShardContext context) throws IOException { + Query luceneQuery = filter.toQuery(context); if (luceneQuery == null) { return null; } diff --git a/core/src/main/java/org/elasticsearch/index/query/OrQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/OrQueryBuilder.java index 7594822d133..600b622c5eb 100644 --- a/core/src/main/java/org/elasticsearch/index/query/OrQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/OrQueryBuilder.java @@ -81,7 +81,7 @@ public class OrQueryBuilder extends AbstractQueryBuilder { } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { + protected Query doToQuery(QueryShardContext context) throws IOException { if (filters.isEmpty()) { // no filters provided, this should be ignored upstream return null; @@ -89,7 +89,7 @@ public class OrQueryBuilder extends AbstractQueryBuilder { BooleanQuery query = new BooleanQuery(); for (QueryBuilder f : filters) { - Query innerQuery = f.toQuery(parseContext); + Query innerQuery = f.toQuery(context); // ignore queries that are null if (innerQuery != null) { query.add(innerQuery, Occur.SHOULD); diff --git a/core/src/main/java/org/elasticsearch/index/query/PrefixQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/PrefixQueryBuilder.java index 65c608a63dd..cf5c0084086 100644 --- a/core/src/main/java/org/elasticsearch/index/query/PrefixQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/PrefixQueryBuilder.java @@ -42,9 +42,9 @@ public class PrefixQueryBuilder extends AbstractQueryBuilder public static final String NAME = "prefix"; private final String fieldName; - + private final String value; - + private String rewrite; static final PrefixQueryBuilder PROTOTYPE = new PrefixQueryBuilder(null, null); @@ -59,7 +59,7 @@ public class PrefixQueryBuilder extends AbstractQueryBuilder this.fieldName = fieldName; this.value = value; } - + public String fieldName() { return this.fieldName; } @@ -96,13 +96,13 @@ public class PrefixQueryBuilder extends AbstractQueryBuilder } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { - MultiTermQuery.RewriteMethod method = QueryParsers.parseRewriteMethod(parseContext.parseFieldMatcher(), rewrite, null); + protected Query doToQuery(QueryShardContext context) throws IOException { + MultiTermQuery.RewriteMethod method = QueryParsers.parseRewriteMethod(context.parseFieldMatcher(), rewrite, null); Query query = null; - MappedFieldType fieldType = parseContext.fieldMapper(fieldName); + MappedFieldType fieldType = context.fieldMapper(fieldName); if (fieldType != null) { - query = fieldType.prefixQuery(value, method, parseContext); + query = fieldType.prefixQuery(value, method, context); } if (query == null) { PrefixQuery prefixQuery = new PrefixQuery(new Term(fieldName, BytesRefs.toBytesRef(value))); @@ -111,7 +111,7 @@ public class PrefixQueryBuilder extends AbstractQueryBuilder } query = prefixQuery; } - + return query; } @@ -148,7 +148,7 @@ public class PrefixQueryBuilder extends AbstractQueryBuilder @Override protected boolean doEquals(PrefixQueryBuilder other) { - return Objects.equals(fieldName, other.fieldName) && + return Objects.equals(fieldName, other.fieldName) && Objects.equals(value, other.value) && Objects.equals(rewrite, other.rewrite); } diff --git a/core/src/main/java/org/elasticsearch/index/query/QueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/QueryBuilder.java index e13337d7107..cb4933c1cd3 100644 --- a/core/src/main/java/org/elasticsearch/index/query/QueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/QueryBuilder.java @@ -42,12 +42,12 @@ public interface QueryBuilder extends NamedWriteablenull if this query should be ignored in the context of * parent queries. * - * @param parseContext additional information needed to construct the queries + * @param context additional information needed to construct the queries * @return the {@link Query} or null if this query should be ignored upstream - * @throws QueryParsingException + * @throws QueryShardException * @throws IOException */ - Query toQuery(QueryParseContext parseContext) throws IOException; + Query toQuery(QueryShardContext context) throws IOException; /** * Returns a {@link org.elasticsearch.common.bytes.BytesReference} diff --git a/core/src/main/java/org/elasticsearch/index/query/QueryFilterBuilder.java b/core/src/main/java/org/elasticsearch/index/query/QueryFilterBuilder.java index 7121b5d8ba5..1af19cfcf51 100644 --- a/core/src/main/java/org/elasticsearch/index/query/QueryFilterBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/QueryFilterBuilder.java @@ -65,9 +65,9 @@ public class QueryFilterBuilder extends AbstractQueryBuilder } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { + protected Query doToQuery(QueryShardContext context) throws IOException { // inner query builder can potentially be `null`, in that case we ignore it - Query innerQuery = this.queryBuilder.toQuery(parseContext); + Query innerQuery = this.queryBuilder.toQuery(context); if (innerQuery == null) { return null; } diff --git a/core/src/main/java/org/elasticsearch/index/query/QueryParseContext.java b/core/src/main/java/org/elasticsearch/index/query/QueryParseContext.java index 678e1eb3eb9..de108778d7d 100644 --- a/core/src/main/java/org/elasticsearch/index/query/QueryParseContext.java +++ b/core/src/main/java/org/elasticsearch/index/query/QueryParseContext.java @@ -19,201 +19,111 @@ package org.elasticsearch.index.query; -import com.google.common.collect.ImmutableMap; -import com.google.common.collect.Maps; - -import org.apache.lucene.analysis.Analyzer; -import org.apache.lucene.queryparser.classic.MapperQueryParser; -import org.apache.lucene.queryparser.classic.QueryParserSettings; -import org.apache.lucene.search.Filter; import org.apache.lucene.search.Query; -import org.apache.lucene.search.join.BitDocIdSetFilter; -import org.apache.lucene.search.similarities.Similarity; -import org.elasticsearch.Version; -import org.elasticsearch.cluster.metadata.IndexMetaData; import org.elasticsearch.common.Nullable; import org.elasticsearch.common.ParseField; import org.elasticsearch.common.ParseFieldMatcher; -import org.elasticsearch.common.settings.Settings; import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.index.Index; -import org.elasticsearch.index.analysis.AnalysisService; -import org.elasticsearch.index.fielddata.IndexFieldData; -import org.elasticsearch.index.mapper.*; -import org.elasticsearch.index.mapper.core.StringFieldMapper; -import org.elasticsearch.index.mapper.object.ObjectMapper; -import org.elasticsearch.index.query.support.NestedScope; -import org.elasticsearch.index.similarity.SimilarityService; -import org.elasticsearch.script.ScriptService; -import org.elasticsearch.search.fetch.innerhits.InnerHitsContext; -import org.elasticsearch.search.internal.SearchContext; -import org.elasticsearch.search.lookup.SearchLookup; +import org.elasticsearch.indices.query.IndicesQueriesRegistry; import java.io.IOException; -import java.util.*; public class QueryParseContext { private static final ParseField CACHE = new ParseField("_cache").withAllDeprecated("Elasticsearch makes its own caching decisions"); private static final ParseField CACHE_KEY = new ParseField("_cache_key").withAllDeprecated("Filters are always used as cache keys"); - private static ThreadLocal typesContext = new ThreadLocal<>(); - - public static void setTypes(String[] types) { - typesContext.set(types); - } - - public static String[] getTypes() { - return typesContext.get(); - } - - public static String[] setTypesWithPrevious(String[] types) { - String[] old = typesContext.get(); - setTypes(types); - return old; - } - - public static void removeTypes() { - typesContext.remove(); - } - - private final Index index; - - private final Version indexVersionCreated; - - private final IndexQueryParserService indexQueryParser; - - private final Map namedQueries = Maps.newHashMap(); - - private final MapperQueryParser queryParser = new MapperQueryParser(this); - private XContentParser parser; - + private final Index index; + //norelease this flag is also used in the QueryShardContext, we need to make sure we set it there correctly in doToQuery() + private boolean isFilter; private ParseFieldMatcher parseFieldMatcher; - private boolean allowUnmappedFields; + //norelease this can eventually be deleted when context() method goes away + private final QueryShardContext shardContext; + private IndicesQueriesRegistry indicesQueriesRegistry; - private boolean mapUnmappedFieldAsString; - - private NestedScope nestedScope; - - private boolean isFilter; - - public QueryParseContext(Index index, IndexQueryParserService indexQueryParser) { + public QueryParseContext(Index index, IndicesQueriesRegistry registry) { this.index = index; - this.indexVersionCreated = Version.indexCreated(indexQueryParser.indexSettings()); - this.indexQueryParser = indexQueryParser; + this.indicesQueriesRegistry = registry; + this.shardContext = null; + } + + QueryParseContext(QueryShardContext context) { + this.shardContext = context; + this.index = context.index(); + this.indicesQueriesRegistry = context.indexQueryParserService().indicesQueriesRegistry(); + } + + public void reset(XContentParser jp) { + this.parseFieldMatcher = ParseFieldMatcher.EMPTY; + this.parser = jp; + } + + //norelease this is still used in BaseQueryParserTemp and FunctionScoreQueryParse, remove if not needed there anymore + @Deprecated + public QueryShardContext shardContext() { + return this.shardContext; + } + + public XContentParser parser() { + return this.parser; } public void parseFieldMatcher(ParseFieldMatcher parseFieldMatcher) { this.parseFieldMatcher = parseFieldMatcher; } - public ParseFieldMatcher parseFieldMatcher() { - return parseFieldMatcher; - } - - public void reset(XContentParser jp) { - allowUnmappedFields = indexQueryParser.defaultAllowUnmappedFields(); - this.parseFieldMatcher = ParseFieldMatcher.EMPTY; - this.lookup = null; - this.parser = jp; - this.namedQueries.clear(); - this.nestedScope = new NestedScope(); - this.isFilter = false; + public boolean isDeprecatedSetting(String setting) { + return parseFieldMatcher.match(setting, CACHE) || parseFieldMatcher.match(setting, CACHE_KEY); } public Index index() { return this.index; } - public void parser(XContentParser parser) { - this.parser = parser; - } - - public XContentParser parser() { - return parser; - } - - public IndexQueryParserService indexQueryParserService() { - return indexQueryParser; - } - - public AnalysisService analysisService() { - return indexQueryParser.analysisService; - } - - public ScriptService scriptService() { - return indexQueryParser.scriptService; - } - - public MapperService mapperService() { - return indexQueryParser.mapperService; - } - + /** + * @deprecated replaced by calls to parseInnerFilterToQueryBuilder(String queryName) for the resulting queries + */ @Nullable - public SimilarityService similarityService() { - return indexQueryParser.similarityService; - } - - public Similarity searchSimilarity() { - return indexQueryParser.similarityService != null ? indexQueryParser.similarityService.similarity() : null; - } - - public String defaultField() { - return indexQueryParser.defaultField(); - } - - public boolean queryStringLenient() { - return indexQueryParser.queryStringLenient(); - } - - public MapperQueryParser queryParser(QueryParserSettings settings) { - queryParser.reset(settings); - return queryParser; - } - - public BitDocIdSetFilter bitsetFilter(Filter filter) { - return indexQueryParser.bitsetFilterCache.getBitDocIdSetFilter(filter); - } - - public > IFD getForField(MappedFieldType mapper) { - return indexQueryParser.fieldDataService.getForField(mapper); - } - - public void addNamedQuery(String name, Query query) { - namedQueries.put(name, query); - } - - public ImmutableMap copyNamedQueries() { - return ImmutableMap.copyOf(namedQueries); - } - - public void combineNamedQueries(QueryParseContext context) { - namedQueries.putAll(context.namedQueries); + @Deprecated + //norelease should be possible to remove after refactoring all queries + public Query parseInnerFilter(String queryName) throws IOException, QueryShardException { + assert this.shardContext != null; + QueryBuilder builder = parseInnerFilterToQueryBuilder(queryName); + return (builder != null) ? builder.toQuery(this.shardContext) : null; } /** - * Return whether we are currently parsing a filter or a query. + * @deprecated replaced by calls to parseInnerFilterToQueryBuilder() for the resulting queries */ - public boolean isFilter() { - return isFilter; + @Nullable + @Deprecated + //norelease should be possible to remove after refactoring all queries + public Query parseInnerFilter() throws QueryShardException, IOException { + assert this.shardContext != null; + QueryBuilder builder = parseInnerFilterToQueryBuilder(); + Query result = null; + if (builder != null) { + result = builder.toQuery(this.shardContext); + } + return result; } - public void addInnerHits(String name, InnerHitsContext.BaseInnerHits context) { - SearchContext sc = SearchContext.current(); - if (sc == null) { - throw new QueryParsingException(this, "inner_hits unsupported"); + /** + * @deprecated replaced by calls to parseInnerQueryBuilder() for the resulting queries + */ + @Nullable + @Deprecated + //norelease should be possible to remove after refactoring all queries + public Query parseInnerQuery() throws IOException, QueryShardException { + QueryBuilder builder = parseInnerQueryBuilder(); + Query result = null; + if (builder != null) { + result = builder.toQuery(this.shardContext); } - - InnerHitsContext innerHitsContext; - if (sc.innerHits() == null) { - innerHitsContext = new InnerHitsContext(new HashMap()); - sc.innerHits(innerHitsContext); - } else { - innerHitsContext = sc.innerHits(); - } - innerHitsContext.addInnerHitDefinition(name, context); + return result; } /** @@ -244,7 +154,7 @@ public class QueryParseContext { throw new QueryParsingException(this, "[_na] query malformed, no field after start_object"); } - QueryParser queryParser = indexQueryParser.queryParser(queryName); + QueryParser queryParser = queryParser(queryName); if (queryParser == null) { throw new QueryParsingException(this, "No query registered for [" + queryName + "]"); } @@ -257,40 +167,12 @@ public class QueryParseContext { } /** - * @deprecated replaced by calls to parseInnerQueryBuilder() for the resulting queries - */ - @Nullable - @Deprecated - public Query parseInnerQuery() throws IOException, QueryParsingException { - QueryBuilder builder = parseInnerQueryBuilder(); - Query result = null; - if (builder != null) { - result = builder.toQuery(this); - } - return result; - } - - /** - * @deprecated replaced by calls to parseInnerFilterToQueryBuilder() for the resulting queries - */ - @Nullable - @Deprecated - public Query parseInnerFilter() throws QueryParsingException, IOException { - QueryBuilder builder = parseInnerFilterToQueryBuilder(); - Query result = null; - if (builder != null) { - result = builder.toQuery(this); - } - return result; - } - - /** - * @return - * @throws QueryParsingException + * @return a new QueryBuilder based on the current state of the parser, but does so that the inner query + * is parsed to a filter * @throws IOException */ @Nullable - public QueryBuilder parseInnerFilterToQueryBuilder() throws QueryParsingException, IOException { + public QueryBuilder parseInnerFilterToQueryBuilder() throws IOException { final boolean originalIsFilter = isFilter; try { isFilter = true; @@ -300,11 +182,11 @@ public class QueryParseContext { } } - public QueryBuilder parseInnerFilterToQueryBuilder(String queryName) throws IOException, QueryParsingException { + QueryBuilder parseInnerFilterToQueryBuilder(String queryName) throws IOException, QueryParsingException { final boolean originalIsFilter = isFilter; try { isFilter = true; - QueryParser queryParser = indexQueryParser.queryParser(queryName); + QueryParser queryParser = queryParser(queryName); if (queryParser == null) { throw new QueryParsingException(this, "No query registered for [" + queryName + "]"); } @@ -314,123 +196,19 @@ public class QueryParseContext { } } - /** - * @deprecated replaced by calls to parseInnerFilterToQueryBuilder(String queryName) for the resulting queries - */ - @Nullable - @Deprecated - public Query parseInnerFilter(String queryName) throws IOException, QueryParsingException { - QueryBuilder builder = parseInnerFilterToQueryBuilder(queryName); - return (builder != null) ? builder.toQuery(this) : null; + public boolean isFilter() { + return this.isFilter; } - public Collection simpleMatchToIndexNames(String pattern) { - return indexQueryParser.mapperService.simpleMatchToIndexNames(pattern, getTypes()); + public ParseFieldMatcher parseFieldMatcher() { + return parseFieldMatcher; } - public MappedFieldType fieldMapper(String name) { - return failIfFieldMappingNotFound(name, indexQueryParser.mapperService.smartNameFieldType(name, getTypes())); + public void parser(XContentParser innerParser) { + this.parser = innerParser; } - public ObjectMapper getObjectMapper(String name) { - return indexQueryParser.mapperService.getObjectMapper(name, getTypes()); + QueryParser queryParser(String name) { + return indicesQueriesRegistry.queryParsers().get(name); } - - /** Gets the search analyzer for the given field, or the default if there is none present for the field - * TODO: remove this by moving defaults into mappers themselves - */ - public Analyzer getSearchAnalyzer(MappedFieldType fieldType) { - if (fieldType.searchAnalyzer() != null) { - return fieldType.searchAnalyzer(); - } - return mapperService().searchAnalyzer(); - } - - /** Gets the search quote nalyzer for the given field, or the default if there is none present for the field - * TODO: remove this by moving defaults into mappers themselves - */ - public Analyzer getSearchQuoteAnalyzer(MappedFieldType fieldType) { - if (fieldType.searchQuoteAnalyzer() != null) { - return fieldType.searchQuoteAnalyzer(); - } - return mapperService().searchQuoteAnalyzer(); - } - - public void setAllowUnmappedFields(boolean allowUnmappedFields) { - this.allowUnmappedFields = allowUnmappedFields; - } - - public void setMapUnmappedFieldAsString(boolean mapUnmappedFieldAsString) { - this.mapUnmappedFieldAsString = mapUnmappedFieldAsString; - } - - private MappedFieldType failIfFieldMappingNotFound(String name, MappedFieldType fieldMapping) { - if (allowUnmappedFields) { - return fieldMapping; - } else if (mapUnmappedFieldAsString){ - StringFieldMapper.Builder builder = MapperBuilders.stringField(name); - // it would be better to pass the real index settings, but they are not easily accessible from here... - Settings settings = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, indexQueryParser.getIndexCreatedVersion()).build(); - return builder.build(new Mapper.BuilderContext(settings, new ContentPath(1))).fieldType(); - } else { - Version indexCreatedVersion = indexQueryParser.getIndexCreatedVersion(); - if (fieldMapping == null && indexCreatedVersion.onOrAfter(Version.V_1_4_0_Beta1)) { - throw new QueryParsingException(this, "Strict field resolution and no field mapping can be found for the field with name [" - + name + "]"); - } else { - return fieldMapping; - } - } - } - - /** - * Returns the narrowed down explicit types, or, if not set, all types. - */ - public Collection queryTypes() { - String[] types = getTypes(); - if (types == null || types.length == 0) { - return mapperService().types(); - } - if (types.length == 1 && types[0].equals("_all")) { - return mapperService().types(); - } - return Arrays.asList(types); - } - - private SearchLookup lookup = null; - - public SearchLookup lookup() { - SearchContext current = SearchContext.current(); - if (current != null) { - return current.lookup(); - } - if (lookup == null) { - lookup = new SearchLookup(mapperService(), indexQueryParser.fieldDataService, null); - } - return lookup; - } - - public long nowInMillis() { - SearchContext current = SearchContext.current(); - if (current != null) { - return current.nowInMillis(); - } - return System.currentTimeMillis(); - } - - public NestedScope nestedScope() { - return nestedScope; - } - - /** - * Return whether the setting is deprecated. - */ - public boolean isDeprecatedSetting(String setting) { - return parseFieldMatcher.match(setting, CACHE) || parseFieldMatcher.match(setting, CACHE_KEY); - } - - public Version indexVersionCreated() { - return indexVersionCreated; - } - } diff --git a/core/src/main/java/org/elasticsearch/index/query/QueryParser.java b/core/src/main/java/org/elasticsearch/index/query/QueryParser.java index 0002e709dd5..f6a019a908e 100644 --- a/core/src/main/java/org/elasticsearch/index/query/QueryParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/QueryParser.java @@ -44,10 +44,10 @@ public interface QueryParser { */ //norelease can be removed in favour of fromXContent once search requests can be parsed on the coordinating node @Nullable - Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException; + Query parse(QueryShardContext context) throws IOException, QueryParsingException; /** - * Creates a new {@link QueryBuilder} from the query held by the {@link QueryParseContext} + * Creates a new {@link QueryBuilder} from the query held by the {@link QueryShardContext} * in {@link org.elasticsearch.common.xcontent.XContent} format * * @param parseContext diff --git a/core/src/main/java/org/elasticsearch/index/query/QueryParsingException.java b/core/src/main/java/org/elasticsearch/index/query/QueryParsingException.java index c606953bca8..80acae774fe 100644 --- a/core/src/main/java/org/elasticsearch/index/query/QueryParsingException.java +++ b/core/src/main/java/org/elasticsearch/index/query/QueryParsingException.java @@ -31,7 +31,8 @@ import org.elasticsearch.rest.RestStatus; import java.io.IOException; /** - * + * Exception that can be used when parsing queries with a given {@link QueryParseContext}. + * Can contain information about location of the error. */ public class QueryParsingException extends ElasticsearchException { @@ -71,9 +72,15 @@ public class QueryParsingException extends ElasticsearchException { this.columnNumber = col; } + public QueryParsingException(StreamInput in) throws IOException{ + super(in); + lineNumber = in.readInt(); + columnNumber = in.readInt(); + } + /** * Line number of the location of the error - * + * * @return the line number or -1 if unknown */ public int getLineNumber() { @@ -82,7 +89,7 @@ public class QueryParsingException extends ElasticsearchException { /** * Column number of the location of the error - * + * * @return the column number or -1 if unknown */ public int getColumnNumber() { @@ -109,11 +116,4 @@ public class QueryParsingException extends ElasticsearchException { out.writeInt(lineNumber); out.writeInt(columnNumber); } - - public QueryParsingException(StreamInput in) throws IOException{ - super(in); - lineNumber = in.readInt(); - columnNumber = in.readInt(); - } - } diff --git a/core/src/main/java/org/elasticsearch/index/query/QueryShardContext.java b/core/src/main/java/org/elasticsearch/index/query/QueryShardContext.java new file mode 100644 index 00000000000..abaf9a7fa66 --- /dev/null +++ b/core/src/main/java/org/elasticsearch/index/query/QueryShardContext.java @@ -0,0 +1,327 @@ +/* + * Licensed to Elasticsearch under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.elasticsearch.index.query; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Maps; + +import org.apache.lucene.analysis.Analyzer; +import org.apache.lucene.queryparser.classic.MapperQueryParser; +import org.apache.lucene.queryparser.classic.QueryParserSettings; +import org.apache.lucene.search.Filter; +import org.apache.lucene.search.Query; +import org.apache.lucene.search.join.BitDocIdSetFilter; +import org.apache.lucene.search.similarities.Similarity; +import org.elasticsearch.Version; +import org.elasticsearch.cluster.metadata.IndexMetaData; +import org.elasticsearch.common.Nullable; +import org.elasticsearch.common.ParseFieldMatcher; +import org.elasticsearch.common.settings.Settings; +import org.elasticsearch.common.xcontent.XContentParser; +import org.elasticsearch.index.Index; +import org.elasticsearch.index.analysis.AnalysisService; +import org.elasticsearch.index.fielddata.IndexFieldData; +import org.elasticsearch.index.mapper.ContentPath; +import org.elasticsearch.index.mapper.MappedFieldType; +import org.elasticsearch.index.mapper.Mapper; +import org.elasticsearch.index.mapper.MapperBuilders; +import org.elasticsearch.index.mapper.MapperService; +import org.elasticsearch.index.mapper.core.StringFieldMapper; +import org.elasticsearch.index.mapper.object.ObjectMapper; +import org.elasticsearch.index.query.support.NestedScope; +import org.elasticsearch.index.similarity.SimilarityService; +import org.elasticsearch.script.ScriptService; +import org.elasticsearch.search.fetch.innerhits.InnerHitsContext; +import org.elasticsearch.search.internal.SearchContext; +import org.elasticsearch.search.lookup.SearchLookup; + +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +/** + * Context object used to create lucene queries on the shard level. + */ +public class QueryShardContext { + + private static ThreadLocal typesContext = new ThreadLocal<>(); + + public static void setTypes(String[] types) { + typesContext.set(types); + } + + public static String[] getTypes() { + return typesContext.get(); + } + + public static String[] setTypesWithPrevious(String[] types) { + String[] old = typesContext.get(); + setTypes(types); + return old; + } + + public static void removeTypes() { + typesContext.remove(); + } + + private final Index index; + + private final Version indexVersionCreated; + + private final IndexQueryParserService indexQueryParser; + + private final Map namedQueries = Maps.newHashMap(); + + private final MapperQueryParser queryParser = new MapperQueryParser(this); + + private ParseFieldMatcher parseFieldMatcher; + + private boolean allowUnmappedFields; + + private boolean mapUnmappedFieldAsString; + + private NestedScope nestedScope; + + //norelease this should be possible to remove once query context are completely separated + private QueryParseContext parseContext; + + private boolean isFilter; + + public QueryShardContext(Index index, IndexQueryParserService indexQueryParser) { + this.index = index; + this.indexVersionCreated = Version.indexCreated(indexQueryParser.indexSettings()); + this.indexQueryParser = indexQueryParser; + this.parseContext = new QueryParseContext(this); + } + + public void parseFieldMatcher(ParseFieldMatcher parseFieldMatcher) { + this.parseFieldMatcher = parseFieldMatcher; + } + + public ParseFieldMatcher parseFieldMatcher() { + return parseFieldMatcher; + } + + private void reset() { + allowUnmappedFields = indexQueryParser.defaultAllowUnmappedFields(); + this.parseFieldMatcher = ParseFieldMatcher.EMPTY; + this.lookup = null; + this.namedQueries.clear(); + this.nestedScope = new NestedScope(); + } + + //norelease remove parser argument once query contexts are separated + public void reset(XContentParser jp) { + this.reset(); + this.parseContext.reset(jp); + } + + public Index index() { + return this.index; + } + + public IndexQueryParserService indexQueryParserService() { + return indexQueryParser; + } + + public AnalysisService analysisService() { + return indexQueryParser.analysisService; + } + + public ScriptService scriptService() { + return indexQueryParser.scriptService; + } + + public MapperService mapperService() { + return indexQueryParser.mapperService; + } + + @Nullable + public SimilarityService similarityService() { + return indexQueryParser.similarityService; + } + + public Similarity searchSimilarity() { + return indexQueryParser.similarityService != null ? indexQueryParser.similarityService.similarity() : null; + } + + public String defaultField() { + return indexQueryParser.defaultField(); + } + + public boolean queryStringLenient() { + return indexQueryParser.queryStringLenient(); + } + + public MapperQueryParser queryParser(QueryParserSettings settings) { + queryParser.reset(settings); + return queryParser; + } + + public BitDocIdSetFilter bitsetFilter(Filter filter) { + return indexQueryParser.bitsetFilterCache.getBitDocIdSetFilter(filter); + } + + public > IFD getForField(MappedFieldType mapper) { + return indexQueryParser.fieldDataService.getForField(mapper); + } + + public void addNamedQuery(String name, Query query) { + namedQueries.put(name, query); + } + + public ImmutableMap copyNamedQueries() { + return ImmutableMap.copyOf(namedQueries); + } + + public void combineNamedQueries(QueryShardContext context) { + namedQueries.putAll(context.namedQueries); + } + + /** + * Return whether we are currently parsing a filter or a query. + */ + public boolean isFilter() { + return isFilter; + } + + public void addInnerHits(String name, InnerHitsContext.BaseInnerHits context) { + SearchContext sc = SearchContext.current(); + if (sc == null) { + throw new QueryShardException(this, "inner_hits unsupported"); + } + + InnerHitsContext innerHitsContext; + if (sc.innerHits() == null) { + innerHitsContext = new InnerHitsContext(new HashMap()); + sc.innerHits(innerHitsContext); + } else { + innerHitsContext = sc.innerHits(); + } + innerHitsContext.addInnerHitDefinition(name, context); + } + + public Collection simpleMatchToIndexNames(String pattern) { + return indexQueryParser.mapperService.simpleMatchToIndexNames(pattern, getTypes()); + } + + public MappedFieldType fieldMapper(String name) { + return failIfFieldMappingNotFound(name, indexQueryParser.mapperService.smartNameFieldType(name, getTypes())); + } + + public ObjectMapper getObjectMapper(String name) { + return indexQueryParser.mapperService.getObjectMapper(name, getTypes()); + } + + /** Gets the search analyzer for the given field, or the default if there is none present for the field + * TODO: remove this by moving defaults into mappers themselves + */ + public Analyzer getSearchAnalyzer(MappedFieldType fieldType) { + if (fieldType.searchAnalyzer() != null) { + return fieldType.searchAnalyzer(); + } + return mapperService().searchAnalyzer(); + } + + /** Gets the search quote nalyzer for the given field, or the default if there is none present for the field + * TODO: remove this by moving defaults into mappers themselves + */ + public Analyzer getSearchQuoteAnalyzer(MappedFieldType fieldType) { + if (fieldType.searchQuoteAnalyzer() != null) { + return fieldType.searchQuoteAnalyzer(); + } + return mapperService().searchQuoteAnalyzer(); + } + + public void setAllowUnmappedFields(boolean allowUnmappedFields) { + this.allowUnmappedFields = allowUnmappedFields; + } + + public void setMapUnmappedFieldAsString(boolean mapUnmappedFieldAsString) { + this.mapUnmappedFieldAsString = mapUnmappedFieldAsString; + } + + private MappedFieldType failIfFieldMappingNotFound(String name, MappedFieldType fieldMapping) { + if (allowUnmappedFields) { + return fieldMapping; + } else if (mapUnmappedFieldAsString){ + StringFieldMapper.Builder builder = MapperBuilders.stringField(name); + // it would be better to pass the real index settings, but they are not easily accessible from here... + Settings settings = Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, indexQueryParser.getIndexCreatedVersion()).build(); + return builder.build(new Mapper.BuilderContext(settings, new ContentPath(1))).fieldType(); + } else { + Version indexCreatedVersion = indexQueryParser.getIndexCreatedVersion(); + if (fieldMapping == null && indexCreatedVersion.onOrAfter(Version.V_1_4_0_Beta1)) { + throw new QueryShardException(this, "Strict field resolution and no field mapping can be found for the field with name [" + + name + "]"); + } else { + return fieldMapping; + } + } + } + + /** + * Returns the narrowed down explicit types, or, if not set, all types. + */ + public Collection queryTypes() { + String[] types = getTypes(); + if (types == null || types.length == 0) { + return mapperService().types(); + } + if (types.length == 1 && types[0].equals("_all")) { + return mapperService().types(); + } + return Arrays.asList(types); + } + + private SearchLookup lookup = null; + + public SearchLookup lookup() { + SearchContext current = SearchContext.current(); + if (current != null) { + return current.lookup(); + } + if (lookup == null) { + lookup = new SearchLookup(mapperService(), indexQueryParser.fieldDataService, null); + } + return lookup; + } + + public long nowInMillis() { + SearchContext current = SearchContext.current(); + if (current != null) { + return current.nowInMillis(); + } + return System.currentTimeMillis(); + } + + public NestedScope nestedScope() { + return nestedScope; + } + + public Version indexVersionCreated() { + return indexVersionCreated; + } + + public QueryParseContext parseContext() { + return this.parseContext; + } +} diff --git a/core/src/main/java/org/elasticsearch/index/query/QueryShardException.java b/core/src/main/java/org/elasticsearch/index/query/QueryShardException.java new file mode 100644 index 00000000000..da4c8c62a81 --- /dev/null +++ b/core/src/main/java/org/elasticsearch/index/query/QueryShardException.java @@ -0,0 +1,72 @@ +/* + * Licensed to Elasticsearch under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.elasticsearch.index.query; + +import org.elasticsearch.ElasticsearchException; +import org.elasticsearch.common.io.stream.StreamInput; +import org.elasticsearch.common.io.stream.StreamOutput; +import org.elasticsearch.common.xcontent.XContentBuilder; +import org.elasticsearch.index.Index; +import org.elasticsearch.rest.RestStatus; + +import java.io.IOException; + +/** + * Exception that is thrown when creating lucene queries on the shard + */ +public class QueryShardException extends ElasticsearchException { + + public QueryShardException(QueryShardContext context, String msg, Object... args) { + this(context, msg, null, args); + } + + public QueryShardException(QueryShardContext context, String msg, Throwable cause, Object... args) { + super(msg, cause, args); + setIndex(context.index()); + } + + /** + * This constructor is provided for use in unit tests where a + * {@link QueryShardContext} may not be available + */ + public QueryShardException(Index index, int line, int col, String msg, Throwable cause) { + super(msg, cause); + setIndex(index); + } + + public QueryShardException(StreamInput in) throws IOException{ + super(in); + } + + @Override + public RestStatus status() { + return RestStatus.BAD_REQUEST; + } + + @Override + protected void innerToXContent(XContentBuilder builder, Params params) throws IOException { + super.innerToXContent(builder, params); + } + + @Override + public void writeTo(StreamOutput out) throws IOException { + super.writeTo(out); + } +} diff --git a/core/src/main/java/org/elasticsearch/index/query/QueryStringQueryParser.java b/core/src/main/java/org/elasticsearch/index/query/QueryStringQueryParser.java index 4b2f93fb7c9..20ab0784637 100644 --- a/core/src/main/java/org/elasticsearch/index/query/QueryStringQueryParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/QueryStringQueryParser.java @@ -66,13 +66,14 @@ public class QueryStringQueryParser extends BaseQueryParserTemp { } @Override - public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException { + public Query parse(QueryShardContext context) throws IOException, QueryParsingException { + QueryParseContext parseContext = context.parseContext(); XContentParser parser = parseContext.parser(); String queryName = null; QueryParserSettings qpSettings = new QueryParserSettings(); - qpSettings.defaultField(parseContext.defaultField()); - qpSettings.lenient(parseContext.queryStringLenient()); + qpSettings.defaultField(context.defaultField()); + qpSettings.lenient(context.queryStringLenient()); qpSettings.analyzeWildcard(defaultAnalyzeWildcard); qpSettings.allowLeadingWildcard(defaultAllowLeadingWildcard); qpSettings.locale(Locale.ROOT); @@ -105,7 +106,7 @@ public class QueryStringQueryParser extends BaseQueryParserTemp { } if (Regex.isSimpleMatchPattern(fField)) { - for (String field : parseContext.mapperService().simpleMatchToIndexNames(fField)) { + for (String field : context.mapperService().simpleMatchToIndexNames(fField)) { qpSettings.fields().add(field); if (fBoost != -1) { if (qpSettings.boosts() == null) { @@ -143,13 +144,13 @@ public class QueryStringQueryParser extends BaseQueryParserTemp { throw new QueryParsingException(parseContext, "Query default operator [" + op + "] is not allowed"); } } else if ("analyzer".equals(currentFieldName)) { - NamedAnalyzer analyzer = parseContext.analysisService().analyzer(parser.text()); + NamedAnalyzer analyzer = context.analysisService().analyzer(parser.text()); if (analyzer == null) { throw new QueryParsingException(parseContext, "[query_string] analyzer [" + parser.text() + "] not found"); } qpSettings.forcedAnalyzer(analyzer); } else if ("quote_analyzer".equals(currentFieldName) || "quoteAnalyzer".equals(currentFieldName)) { - NamedAnalyzer analyzer = parseContext.analysisService().analyzer(parser.text()); + NamedAnalyzer analyzer = context.analysisService().analyzer(parser.text()); if (analyzer == null) { throw new QueryParsingException(parseContext, "[query_string] quote_analyzer [" + parser.text() + "] not found"); @@ -214,16 +215,16 @@ public class QueryStringQueryParser extends BaseQueryParserTemp { if (qpSettings.queryString() == null) { throw new QueryParsingException(parseContext, "query_string must be provided with a [query]"); } - qpSettings.defaultAnalyzer(parseContext.mapperService().searchAnalyzer()); - qpSettings.defaultQuoteAnalyzer(parseContext.mapperService().searchQuoteAnalyzer()); + qpSettings.defaultAnalyzer(context.mapperService().searchAnalyzer()); + qpSettings.defaultQuoteAnalyzer(context.mapperService().searchQuoteAnalyzer()); if (qpSettings.escape()) { qpSettings.queryString(org.apache.lucene.queryparser.classic.QueryParser.escape(qpSettings.queryString())); } - qpSettings.queryTypes(parseContext.queryTypes()); + qpSettings.queryTypes(context.queryTypes()); - MapperQueryParser queryParser = parseContext.queryParser(qpSettings); + MapperQueryParser queryParser = context.queryParser(qpSettings); try { Query query = queryParser.parse(qpSettings.queryString()); @@ -238,7 +239,7 @@ public class QueryStringQueryParser extends BaseQueryParserTemp { Queries.applyMinimumShouldMatch((BooleanQuery) query, qpSettings.minimumShouldMatch()); } if (queryName != null) { - parseContext.addNamedQuery(queryName, query); + context.addNamedQuery(queryName, query); } return query; } catch (org.apache.lucene.queryparser.classic.ParseException e) { diff --git a/core/src/main/java/org/elasticsearch/index/query/QueryWrappingQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/QueryWrappingQueryBuilder.java index 471c22a2d45..7230fd1592c 100644 --- a/core/src/main/java/org/elasticsearch/index/query/QueryWrappingQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/QueryWrappingQueryBuilder.java @@ -25,7 +25,7 @@ import org.elasticsearch.common.xcontent.XContentBuilder; import java.io.IOException; /** - * QueryBuilder implementation that holds a lucene query, which can be returned by {@link QueryBuilder#toQuery(QueryParseContext)}. + * QueryBuilder implementation that holds a lucene query, which can be returned by {@link QueryBuilder#toQuery(QueryShardContext)}. * Doesn't support conversion to {@link org.elasticsearch.common.xcontent.XContent} via {@link #doXContent(XContentBuilder, Params)}. */ //norelease to be removed once all queries support separate fromXContent and toQuery methods. Make AbstractQueryBuilder#toQuery final as well then. @@ -47,7 +47,7 @@ public class QueryWrappingQueryBuilder extends AbstractQueryBuilder i } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { + protected Query doToQuery(QueryShardContext context) throws IOException { Query query = null; - MappedFieldType mapper = parseContext.fieldMapper(this.fieldName); + MappedFieldType mapper = context.fieldMapper(this.fieldName); if (mapper != null) { if (mapper instanceof DateFieldMapper.DateFieldType) { DateMathParser forcedDateParser = null; @@ -259,7 +259,7 @@ public class RangeQueryBuilder extends AbstractQueryBuilder i query = ((DateFieldMapper.DateFieldType) mapper).rangeQuery(from, to, includeLower, includeUpper, dateTimeZone, forcedDateParser); } else { if (timeZone != null) { - throw new QueryParsingException(parseContext, "[range] time_zone can not be applied to non date field [" + throw new QueryShardException(context, "[range] time_zone can not be applied to non date field [" + fieldName + "]"); } //LUCENE 4 UPGRADE Mapper#rangeQuery should use bytesref as well? @@ -267,7 +267,7 @@ public class RangeQueryBuilder extends AbstractQueryBuilder i } } else { if (timeZone != null) { - throw new QueryParsingException(parseContext, "[range] time_zone can not be applied to non unmapped field [" + throw new QueryShardException(context, "[range] time_zone can not be applied to non unmapped field [" + fieldName + "]"); } } diff --git a/core/src/main/java/org/elasticsearch/index/query/RegexpQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/RegexpQueryBuilder.java index 40b368f7055..cc3f40bdccf 100644 --- a/core/src/main/java/org/elasticsearch/index/query/RegexpQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/RegexpQueryBuilder.java @@ -149,13 +149,13 @@ public class RegexpQueryBuilder extends AbstractQueryBuilder } @Override - public Query doToQuery(QueryParseContext parseContext) throws QueryParsingException, IOException { - MultiTermQuery.RewriteMethod method = QueryParsers.parseRewriteMethod(parseContext.parseFieldMatcher(), rewrite, null); + public Query doToQuery(QueryShardContext context) throws QueryShardException, IOException { + MultiTermQuery.RewriteMethod method = QueryParsers.parseRewriteMethod(context.parseFieldMatcher(), rewrite, null); Query query = null; - MappedFieldType fieldType = parseContext.fieldMapper(fieldName); + MappedFieldType fieldType = context.fieldMapper(fieldName); if (fieldType != null) { - query = fieldType.regexpQuery(value, flagsValue, maxDeterminizedStates, method, parseContext); + query = fieldType.regexpQuery(value, flagsValue, maxDeterminizedStates, method, context); } if (query == null) { RegexpQuery regexpQuery = new RegexpQuery(new Term(fieldName, BytesRefs.toBytesRef(value)), flagsValue, maxDeterminizedStates); diff --git a/core/src/main/java/org/elasticsearch/index/query/ScriptQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/ScriptQueryBuilder.java index 1f6119eaf7c..b2f4375bccc 100644 --- a/core/src/main/java/org/elasticsearch/index/query/ScriptQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/ScriptQueryBuilder.java @@ -25,7 +25,6 @@ import org.apache.lucene.search.Query; import org.apache.lucene.search.RandomAccessWeight; import org.apache.lucene.search.Weight; import org.apache.lucene.util.Bits; -import org.elasticsearch.common.Strings; import org.elasticsearch.common.io.stream.StreamInput; import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.xcontent.XContentBuilder; @@ -43,7 +42,7 @@ public class ScriptQueryBuilder extends AbstractQueryBuilder static final ScriptQueryBuilder PROTOTYPE = new ScriptQueryBuilder(null); private final Script script; - + public ScriptQueryBuilder(Script script) { this.script = script; } @@ -66,8 +65,8 @@ public class ScriptQueryBuilder extends AbstractQueryBuilder } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { - return new ScriptQuery(script, parseContext.scriptService(), parseContext.lookup()); + protected Query doToQuery(QueryShardContext context) throws IOException { + return new ScriptQuery(script, context.scriptService(), context.lookup()); } @Override @@ -151,7 +150,7 @@ public class ScriptQueryBuilder extends AbstractQueryBuilder }; } } - + @Override protected ScriptQueryBuilder doReadFrom(StreamInput in) throws IOException { return new ScriptQueryBuilder(Script.readScript(in)); diff --git a/core/src/main/java/org/elasticsearch/index/query/SimpleQueryStringBuilder.java b/core/src/main/java/org/elasticsearch/index/query/SimpleQueryStringBuilder.java index a93a4b78190..4adb967cbfa 100644 --- a/core/src/main/java/org/elasticsearch/index/query/SimpleQueryStringBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/SimpleQueryStringBuilder.java @@ -26,7 +26,9 @@ import org.elasticsearch.common.Strings; import org.elasticsearch.common.io.stream.StreamInput; import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.lucene.search.Queries; +import org.elasticsearch.common.regex.Regex; import org.elasticsearch.common.xcontent.XContentBuilder; +import org.elasticsearch.index.mapper.MappedFieldType; import org.elasticsearch.index.query.SimpleQueryParser.Settings; import java.io.IOException; @@ -260,26 +262,44 @@ public class SimpleQueryStringBuilder extends AbstractQueryBuilder resolvedFieldsAndWeights = new TreeMap<>(); + for (String fField : fieldsAndWeights.keySet()) { + if (Regex.isSimpleMatchPattern(fField)) { + for (String fieldName : context.mapperService().simpleMatchToIndexNames(fField)) { + resolvedFieldsAndWeights.put(fieldName, fieldsAndWeights.get(fField)); + } + } else { + MappedFieldType fieldType = context.fieldMapper(fField); + if (fieldType != null) { + resolvedFieldsAndWeights.put(fieldType.names().indexName(), fieldsAndWeights.get(fField)); + } else { + resolvedFieldsAndWeights.put(fField, fieldsAndWeights.get(fField)); + } + } + } + // Use standard analyzer by default if none specified Analyzer luceneAnalyzer; if (analyzer == null) { - luceneAnalyzer = parseContext.mapperService().searchAnalyzer(); + luceneAnalyzer = context.mapperService().searchAnalyzer(); } else { - luceneAnalyzer = parseContext.analysisService().analyzer(analyzer); + luceneAnalyzer = context.analysisService().analyzer(analyzer); if (luceneAnalyzer == null) { - throw new QueryParsingException(parseContext, "[" + SimpleQueryStringBuilder.NAME + "] analyzer [" + analyzer + throw new QueryShardException(context, "[" + SimpleQueryStringBuilder.NAME + "] analyzer [" + analyzer + "] not found"); } } - SimpleQueryParser sqp = new SimpleQueryParser(luceneAnalyzer, fieldsAndWeights, flags, settings); + + SimpleQueryParser sqp = new SimpleQueryParser(luceneAnalyzer, resolvedFieldsAndWeights, flags, settings); sqp.setDefaultOperator(defaultOperator.toBooleanClauseOccur()); Query query = sqp.parse(queryText); diff --git a/core/src/main/java/org/elasticsearch/index/query/SimpleQueryStringParser.java b/core/src/main/java/org/elasticsearch/index/query/SimpleQueryStringParser.java index 8ee5196811c..58bf7bc70a3 100644 --- a/core/src/main/java/org/elasticsearch/index/query/SimpleQueryStringParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/SimpleQueryStringParser.java @@ -20,10 +20,7 @@ package org.elasticsearch.index.query; import org.elasticsearch.common.Strings; -import org.elasticsearch.common.regex.Regex; import org.elasticsearch.common.xcontent.XContentParser; -import org.elasticsearch.index.mapper.MappedFieldType; - import java.io.IOException; import java.util.HashMap; import java.util.Locale; @@ -108,19 +105,7 @@ public class SimpleQueryStringParser extends BaseQueryParser { if (fField == null) { fField = parser.text(); } - - if (Regex.isSimpleMatchPattern(fField)) { - for (String fieldName : parseContext.mapperService().simpleMatchToIndexNames(fField)) { - fieldsAndWeights.put(fieldName, fBoost); - } - } else { - MappedFieldType fieldType = parseContext.fieldMapper(fField); - if (fieldType != null) { - fieldsAndWeights.put(fieldType.names().indexName(), fBoost); - } else { - fieldsAndWeights.put(fField, fBoost); - } - } + fieldsAndWeights.put(fField, fBoost); } } else { throw new QueryParsingException(parseContext, diff --git a/core/src/main/java/org/elasticsearch/index/query/SpanContainingQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/SpanContainingQueryBuilder.java index 7b4bf3e2d08..8b7ed0f9365 100644 --- a/core/src/main/java/org/elasticsearch/index/query/SpanContainingQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/SpanContainingQueryBuilder.java @@ -74,10 +74,10 @@ public class SpanContainingQueryBuilder extends AbstractQueryBuilder } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { + protected Query doToQuery(QueryShardContext context) throws IOException { SpanQuery[] spanQueries = new SpanQuery[clauses.size()]; for (int i = 0; i < clauses.size(); i++) { - Query query = clauses.get(i).toQuery(parseContext); + Query query = clauses.get(i).toQuery(context); assert query instanceof SpanQuery; spanQueries[i] = (SpanQuery) query; } diff --git a/core/src/main/java/org/elasticsearch/index/query/SpanTermQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/SpanTermQueryBuilder.java index 54305ec90d9..787926221b6 100644 --- a/core/src/main/java/org/elasticsearch/index/query/SpanTermQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/SpanTermQueryBuilder.java @@ -68,7 +68,7 @@ public class SpanTermQueryBuilder extends BaseTermQueryBuilder { } @Override - public Query doToQuery(QueryParseContext parseContext) throws IOException { + public Query doToQuery(QueryShardContext context) throws IOException { Query query = null; - MappedFieldType mapper = parseContext.fieldMapper(this.fieldName); + MappedFieldType mapper = context.fieldMapper(this.fieldName); if (mapper != null) { - query = mapper.termQuery(this.value, parseContext); + query = mapper.termQuery(this.value, context); } if (query == null) { query = new TermQuery(new Term(this.fieldName, BytesRefs.toBytesRef(this.value))); diff --git a/core/src/main/java/org/elasticsearch/index/query/TermsQueryParser.java b/core/src/main/java/org/elasticsearch/index/query/TermsQueryParser.java index 8879434581a..fec398f298e 100644 --- a/core/src/main/java/org/elasticsearch/index/query/TermsQueryParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/TermsQueryParser.java @@ -70,7 +70,8 @@ public class TermsQueryParser extends BaseQueryParserTemp { } @Override - public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException { + public Query parse(QueryShardContext context) throws IOException, QueryParsingException { + QueryParseContext parseContext = context.parseContext(); XContentParser parser = parseContext.parser(); String queryName = null; @@ -158,7 +159,7 @@ public class TermsQueryParser extends BaseQueryParserTemp { throw new QueryParsingException(parseContext, "terms query requires a field name, followed by array of terms"); } - MappedFieldType fieldType = parseContext.fieldMapper(fieldName); + MappedFieldType fieldType = context.fieldMapper(fieldName); if (fieldType != null) { fieldName = fieldType.names().indexName(); } @@ -181,7 +182,7 @@ public class TermsQueryParser extends BaseQueryParserTemp { Query query; if (parseContext.isFilter()) { if (fieldType != null) { - query = fieldType.termsQuery(terms, parseContext); + query = fieldType.termsQuery(terms, context); } else { BytesRef[] filterValues = new BytesRef[terms.size()]; for (int i = 0; i < filterValues.length; i++) { @@ -193,7 +194,7 @@ public class TermsQueryParser extends BaseQueryParserTemp { BooleanQuery bq = new BooleanQuery(); for (Object term : terms) { if (fieldType != null) { - bq.add(fieldType.termQuery(term, parseContext), Occur.SHOULD); + bq.add(fieldType.termQuery(term, context), Occur.SHOULD); } else { bq.add(new TermQuery(new Term(fieldName, BytesRefs.toBytesRef(term))), Occur.SHOULD); } @@ -204,7 +205,7 @@ public class TermsQueryParser extends BaseQueryParserTemp { query.setBoost(boost); if (queryName != null) { - parseContext.addNamedQuery(queryName, query); + context.addNamedQuery(queryName, query); } return query; } diff --git a/core/src/main/java/org/elasticsearch/index/query/TypeQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/TypeQueryBuilder.java index 0dcaffa3858..c441f438588 100644 --- a/core/src/main/java/org/elasticsearch/index/query/TypeQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/TypeQueryBuilder.java @@ -48,10 +48,10 @@ public class TypeQueryBuilder extends AbstractQueryBuilder { TypeQueryBuilder(BytesRef type) { this.type = type; } - + public BytesRef type() { return this.type; - } + } @Override protected void doXContent(XContentBuilder builder, Params params) throws IOException { @@ -67,10 +67,10 @@ public class TypeQueryBuilder extends AbstractQueryBuilder { } @Override - protected Query doToQuery(QueryParseContext parseContext) throws IOException { + protected Query doToQuery(QueryShardContext context) throws IOException { Query filter; //LUCENE 4 UPGRADE document mapper should use bytesref as well? - DocumentMapper documentMapper = parseContext.mapperService().documentMapper(type.utf8ToString()); + DocumentMapper documentMapper = context.mapperService().documentMapper(type.utf8ToString()); if (documentMapper == null) { filter = new TermQuery(new Term(TypeFieldMapper.NAME, type)); } else { diff --git a/core/src/main/java/org/elasticsearch/index/query/WildcardQueryBuilder.java b/core/src/main/java/org/elasticsearch/index/query/WildcardQueryBuilder.java index 1320fe9c1a0..d337c7af936 100644 --- a/core/src/main/java/org/elasticsearch/index/query/WildcardQueryBuilder.java +++ b/core/src/main/java/org/elasticsearch/index/query/WildcardQueryBuilder.java @@ -106,11 +106,11 @@ public class WildcardQueryBuilder extends AbstractQueryBuilder filterFunctions, String currentFieldName) throws IOException { + QueryParseContext parseContext = context.parseContext(); XContentParser.Token token; while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) { Query filter = null; @@ -227,7 +229,7 @@ public class FunctionScoreQueryParser implements QueryParser { // functionParserMapper throws exception if parser // non-existent ScoreFunctionParser functionParser = functionParserMapper.get(parseContext, currentFieldName); - scoreFunction = functionParser.parse(parseContext, parser); + scoreFunction = functionParser.parse(context, parser); } } } @@ -275,9 +277,10 @@ public class FunctionScoreQueryParser implements QueryParser { return cf; } + //norelease to be removed once all queries are moved over to extend BaseQueryParser @Override public QueryBuilder fromXContent(QueryParseContext parseContext) throws IOException, QueryParsingException { - Query query = parse(parseContext); + Query query = parse(parseContext.shardContext()); return new QueryWrappingQueryBuilder(query); } diff --git a/core/src/main/java/org/elasticsearch/index/query/functionscore/ScoreFunctionParser.java b/core/src/main/java/org/elasticsearch/index/query/functionscore/ScoreFunctionParser.java index 74c3d08bd4f..4065f083b91 100644 --- a/core/src/main/java/org/elasticsearch/index/query/functionscore/ScoreFunctionParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/functionscore/ScoreFunctionParser.java @@ -21,14 +21,14 @@ package org.elasticsearch.index.query.functionscore; import org.elasticsearch.common.lucene.search.function.ScoreFunction; import org.elasticsearch.common.xcontent.XContentParser; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.index.query.QueryParsingException; import java.io.IOException; public interface ScoreFunctionParser { - ScoreFunction parse(QueryParseContext parseContext, XContentParser parser) throws IOException, QueryParsingException; + ScoreFunction parse(QueryShardContext context, XContentParser parser) throws IOException, QueryParsingException; /** * Returns the name of the function, for example "linear", "gauss" etc. This diff --git a/core/src/main/java/org/elasticsearch/index/query/functionscore/factor/FactorParser.java b/core/src/main/java/org/elasticsearch/index/query/functionscore/factor/FactorParser.java index a1c8d20350d..2635c2bbf44 100644 --- a/core/src/main/java/org/elasticsearch/index/query/functionscore/factor/FactorParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/functionscore/factor/FactorParser.java @@ -19,14 +19,13 @@ package org.elasticsearch.index.query.functionscore.factor; -import org.elasticsearch.index.query.functionscore.ScoreFunctionParser; - import org.elasticsearch.common.inject.Inject; import org.elasticsearch.common.lucene.search.function.BoostScoreFunction; import org.elasticsearch.common.lucene.search.function.ScoreFunction; import org.elasticsearch.common.xcontent.XContentParser; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.index.query.QueryParsingException; +import org.elasticsearch.index.query.functionscore.ScoreFunctionParser; import java.io.IOException; @@ -43,7 +42,7 @@ public class FactorParser implements ScoreFunctionParser { } @Override - public ScoreFunction parse(QueryParseContext parseContext, XContentParser parser) throws IOException, QueryParsingException { + public ScoreFunction parse(QueryShardContext context, XContentParser parser) throws IOException, QueryParsingException { float boostFactor = parser.floatValue(); return new BoostScoreFunction(boostFactor); } diff --git a/core/src/main/java/org/elasticsearch/index/query/functionscore/fieldvaluefactor/FieldValueFactorFunctionParser.java b/core/src/main/java/org/elasticsearch/index/query/functionscore/fieldvaluefactor/FieldValueFactorFunctionParser.java index e6a8f2dabcc..a91d954c8f0 100644 --- a/core/src/main/java/org/elasticsearch/index/query/functionscore/fieldvaluefactor/FieldValueFactorFunctionParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/functionscore/fieldvaluefactor/FieldValueFactorFunctionParser.java @@ -24,8 +24,8 @@ import org.elasticsearch.common.lucene.search.function.FieldValueFactorFunction; import org.elasticsearch.common.lucene.search.function.ScoreFunction; import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.index.fielddata.IndexNumericFieldData; -import org.elasticsearch.index.mapper.FieldMapper; import org.elasticsearch.index.mapper.MappedFieldType; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.index.query.QueryParseContext; import org.elasticsearch.index.query.QueryParsingException; import org.elasticsearch.index.query.functionscore.ScoreFunctionParser; @@ -52,7 +52,8 @@ public class FieldValueFactorFunctionParser implements ScoreFunctionParser { public static String[] NAMES = { "field_value_factor", "fieldValueFactor" }; @Override - public ScoreFunction parse(QueryParseContext parseContext, XContentParser parser) throws IOException, QueryParsingException { + public ScoreFunction parse(QueryShardContext context, XContentParser parser) throws IOException, QueryParsingException { + QueryParseContext parseContext = context.parseContext(); String currentFieldName = null; String field = null; diff --git a/core/src/main/java/org/elasticsearch/index/query/functionscore/random/RandomScoreFunctionParser.java b/core/src/main/java/org/elasticsearch/index/query/functionscore/random/RandomScoreFunctionParser.java index 124336c5bbe..20c2f55990b 100644 --- a/core/src/main/java/org/elasticsearch/index/query/functionscore/random/RandomScoreFunctionParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/functionscore/random/RandomScoreFunctionParser.java @@ -27,8 +27,8 @@ import org.elasticsearch.common.lucene.search.function.RandomScoreFunction; import org.elasticsearch.common.lucene.search.function.ScoreFunction; import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.index.fielddata.IndexFieldData; -import org.elasticsearch.index.mapper.FieldMapper; import org.elasticsearch.index.mapper.MappedFieldType; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.index.query.QueryParseContext; import org.elasticsearch.index.query.QueryParsingException; import org.elasticsearch.index.query.functionscore.ScoreFunctionParser; @@ -51,8 +51,8 @@ public class RandomScoreFunctionParser implements ScoreFunctionParser { } @Override - public ScoreFunction parse(QueryParseContext parseContext, XContentParser parser) throws IOException, QueryParsingException { - + public ScoreFunction parse(QueryShardContext context, XContentParser parser) throws IOException, QueryParsingException { + QueryParseContext parseContext = context.parseContext(); int seed = -1; String currentFieldName = null; @@ -90,7 +90,7 @@ public class RandomScoreFunctionParser implements ScoreFunctionParser { } if (seed == -1) { - seed = Longs.hashCode(parseContext.nowInMillis()); + seed = Longs.hashCode(context.nowInMillis()); } final ShardId shardId = SearchContext.current().indexShard().shardId(); final int salt = (shardId.index().name().hashCode() << 10) | shardId.id(); diff --git a/core/src/main/java/org/elasticsearch/index/query/functionscore/script/ScriptScoreFunctionParser.java b/core/src/main/java/org/elasticsearch/index/query/functionscore/script/ScriptScoreFunctionParser.java index 2cf066fd918..38a29f38644 100644 --- a/core/src/main/java/org/elasticsearch/index/query/functionscore/script/ScriptScoreFunctionParser.java +++ b/core/src/main/java/org/elasticsearch/index/query/functionscore/script/ScriptScoreFunctionParser.java @@ -21,11 +21,11 @@ package org.elasticsearch.index.query.functionscore.script; -import org.elasticsearch.common.ParseField; import org.elasticsearch.common.inject.Inject; import org.elasticsearch.common.lucene.search.function.ScoreFunction; import org.elasticsearch.common.lucene.search.function.ScriptScoreFunction; import org.elasticsearch.common.xcontent.XContentParser; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.index.query.QueryParseContext; import org.elasticsearch.index.query.QueryParsingException; import org.elasticsearch.index.query.functionscore.ScoreFunctionParser; @@ -58,7 +58,8 @@ public class ScriptScoreFunctionParser implements ScoreFunctionParser { } @Override - public ScoreFunction parse(QueryParseContext parseContext, XContentParser parser) throws IOException, QueryParsingException { + public ScoreFunction parse(QueryShardContext context, XContentParser parser) throws IOException, QueryParsingException { + QueryParseContext parseContext = context.parseContext(); ScriptParameterParser scriptParameterParser = new ScriptParameterParser(); Script script = null; Map vars = null; @@ -100,7 +101,7 @@ public class ScriptScoreFunctionParser implements ScoreFunctionParser { SearchScript searchScript; try { - searchScript = parseContext.scriptService().search(parseContext.lookup(), script, ScriptContext.Standard.SEARCH); + searchScript = context.scriptService().search(context.lookup(), script, ScriptContext.Standard.SEARCH); return new ScriptScoreFunction(script, searchScript); } catch (Exception e) { throw new QueryParsingException(parseContext, NAMES[0] + " the script could not be loaded", e); diff --git a/core/src/main/java/org/elasticsearch/index/query/support/InnerHitsQueryParserHelper.java b/core/src/main/java/org/elasticsearch/index/query/support/InnerHitsQueryParserHelper.java index ae839c41d1c..6e59d01a42a 100644 --- a/core/src/main/java/org/elasticsearch/index/query/support/InnerHitsQueryParserHelper.java +++ b/core/src/main/java/org/elasticsearch/index/query/support/InnerHitsQueryParserHelper.java @@ -22,6 +22,7 @@ package org.elasticsearch.index.query.support; import org.elasticsearch.common.collect.Tuple; import org.elasticsearch.common.inject.Inject; import org.elasticsearch.common.xcontent.XContentParser; +import org.elasticsearch.index.query.QueryShardException; import org.elasticsearch.index.query.QueryParseContext; import org.elasticsearch.index.query.QueryParsingException; import org.elasticsearch.search.fetch.fielddata.FieldDataFieldsParseElement; @@ -51,7 +52,7 @@ public class InnerHitsQueryParserHelper { this.fieldDataFieldsParseElement = fieldDataFieldsParseElement; } - public Tuple parse(QueryParseContext parserContext) throws IOException, QueryParsingException { + public Tuple parse(QueryParseContext parserContext) throws IOException, QueryShardException { String fieldName = null; XContentParser.Token token; String innerHitName = null; diff --git a/core/src/main/java/org/elasticsearch/index/query/support/NestedInnerQueryParseSupport.java b/core/src/main/java/org/elasticsearch/index/query/support/NestedInnerQueryParseSupport.java index 63da8a1b217..1e941bb662e 100644 --- a/core/src/main/java/org/elasticsearch/index/query/support/NestedInnerQueryParseSupport.java +++ b/core/src/main/java/org/elasticsearch/index/query/support/NestedInnerQueryParseSupport.java @@ -26,10 +26,10 @@ import org.elasticsearch.common.lucene.search.Queries; import org.elasticsearch.common.xcontent.XContentFactory; import org.elasticsearch.common.xcontent.XContentHelper; import org.elasticsearch.common.xcontent.XContentParser; -import org.elasticsearch.index.mapper.MapperService; import org.elasticsearch.index.mapper.object.ObjectMapper; +import org.elasticsearch.index.query.QueryShardContext; +import org.elasticsearch.index.query.QueryShardException; import org.elasticsearch.index.query.QueryParseContext; -import org.elasticsearch.index.query.QueryParsingException; import org.elasticsearch.search.internal.SearchContext; import java.io.IOException; @@ -41,6 +41,7 @@ import java.io.IOException; */ public class NestedInnerQueryParseSupport { + protected final QueryShardContext shardContext; protected final QueryParseContext parseContext; private BytesReference source; @@ -60,12 +61,15 @@ public class NestedInnerQueryParseSupport { private ObjectMapper parentObjectMapper; public NestedInnerQueryParseSupport(XContentParser parser, SearchContext searchContext) { - parseContext = searchContext.queryParserService().getParseContext(); - parseContext.reset(parser); + parseContext = searchContext.queryParserService().getShardContext().parseContext(); + shardContext = searchContext.queryParserService().getShardContext(); + shardContext.reset(parser); + } - public NestedInnerQueryParseSupport(QueryParseContext parseContext) { - this.parseContext = parseContext; + public NestedInnerQueryParseSupport(QueryShardContext context) { + this.parseContext = context.parseContext(); + this.shardContext = context; } public void query() throws IOException { @@ -103,10 +107,10 @@ public class NestedInnerQueryParseSupport { return innerQuery; } else { if (path == null) { - throw new QueryParsingException(parseContext, "[nested] requires 'path' field"); + throw new QueryShardException(shardContext, "[nested] requires 'path' field"); } if (!queryFound) { - throw new QueryParsingException(parseContext, "[nested] requires either 'query' or 'filter' field"); + throw new QueryShardException(shardContext, "[nested] requires either 'query' or 'filter' field"); } XContentParser old = parseContext.parser(); @@ -132,10 +136,10 @@ public class NestedInnerQueryParseSupport { return innerFilter; } else { if (path == null) { - throw new QueryParsingException(parseContext, "[nested] requires 'path' field"); + throw new QueryShardException(shardContext, "[nested] requires 'path' field"); } if (!filterFound) { - throw new QueryParsingException(parseContext, "[nested] requires either 'query' or 'filter' field"); + throw new QueryShardException(shardContext, "[nested] requires either 'query' or 'filter' field"); } setPathLevel(); @@ -155,12 +159,12 @@ public class NestedInnerQueryParseSupport { public void setPath(String path) { this.path = path; - nestedObjectMapper = parseContext.getObjectMapper(path); + nestedObjectMapper = shardContext.getObjectMapper(path); if (nestedObjectMapper == null) { - throw new QueryParsingException(parseContext, "[nested] failed to find nested object under path [" + path + "]"); + throw new QueryShardException(shardContext, "[nested] failed to find nested object under path [" + path + "]"); } if (!nestedObjectMapper.nested().isNested()) { - throw new QueryParsingException(parseContext, "[nested] nested object under path [" + path + "] is not of nested type"); + throw new QueryShardException(shardContext, "[nested] nested object under path [" + path + "] is not of nested type"); } } @@ -185,18 +189,18 @@ public class NestedInnerQueryParseSupport { } private void setPathLevel() { - ObjectMapper objectMapper = parseContext.nestedScope().getObjectMapper(); + ObjectMapper objectMapper = shardContext.nestedScope().getObjectMapper(); if (objectMapper == null) { - parentFilter = parseContext.bitsetFilter(Queries.newNonNestedFilter()); + parentFilter = shardContext.bitsetFilter(Queries.newNonNestedFilter()); } else { - parentFilter = parseContext.bitsetFilter(objectMapper.nestedTypeFilter()); + parentFilter = shardContext.bitsetFilter(objectMapper.nestedTypeFilter()); } - childFilter = parseContext.bitsetFilter(nestedObjectMapper.nestedTypeFilter()); - parentObjectMapper = parseContext.nestedScope().nextLevel(nestedObjectMapper); + childFilter = shardContext.bitsetFilter(nestedObjectMapper.nestedTypeFilter()); + parentObjectMapper = shardContext.nestedScope().nextLevel(nestedObjectMapper); } private void resetPathLevel() { - parseContext.nestedScope().previousLevel(); + shardContext.nestedScope().previousLevel(); } } diff --git a/core/src/main/java/org/elasticsearch/index/query/support/XContentStructure.java b/core/src/main/java/org/elasticsearch/index/query/support/XContentStructure.java index 37716d12154..cd8fd27c5d3 100644 --- a/core/src/main/java/org/elasticsearch/index/query/support/XContentStructure.java +++ b/core/src/main/java/org/elasticsearch/index/query/support/XContentStructure.java @@ -25,6 +25,7 @@ import org.elasticsearch.common.bytes.BytesReference; import org.elasticsearch.common.xcontent.XContentFactory; import org.elasticsearch.common.xcontent.XContentHelper; import org.elasticsearch.common.xcontent.XContentParser; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.index.query.QueryParseContext; import java.io.IOException; @@ -84,14 +85,14 @@ public abstract class XContentStructure { BytesReference br = this.bytes(); assert br != null : "innerBytes must be set with .bytes(bytes) or .freeze() before parsing"; XContentParser innerParser = XContentHelper.createParser(br); - String[] origTypes = QueryParseContext.setTypesWithPrevious(types); + String[] origTypes = QueryShardContext.setTypesWithPrevious(types); XContentParser old = parseContext.parser(); parseContext.parser(innerParser); try { return parseContext.parseInnerQuery(); } finally { parseContext.parser(old); - QueryParseContext.setTypes(origTypes); + QueryShardContext.setTypes(origTypes); } } @@ -106,12 +107,12 @@ public abstract class XContentStructure { public InnerQuery(QueryParseContext parseContext1, @Nullable String... types) throws IOException { super(parseContext1); if (types != null) { - String[] origTypes = QueryParseContext.setTypesWithPrevious(types); + String[] origTypes = QueryShardContext.setTypesWithPrevious(types); try { query = parseContext1.parseInnerQuery(); queryParsed = true; } finally { - QueryParseContext.setTypes(origTypes); + QueryShardContext.setTypes(origTypes); } } else { BytesReference innerBytes = XContentFactory.smileBuilder().copyCurrentStructure(parseContext1.parser()).bytes(); diff --git a/core/src/main/java/org/elasticsearch/index/search/MatchQuery.java b/core/src/main/java/org/elasticsearch/index/search/MatchQuery.java index fb5fff837a8..0b5dae6f3c2 100644 --- a/core/src/main/java/org/elasticsearch/index/search/MatchQuery.java +++ b/core/src/main/java/org/elasticsearch/index/search/MatchQuery.java @@ -30,7 +30,7 @@ import org.elasticsearch.common.lucene.search.MultiPhrasePrefixQuery; import org.elasticsearch.common.lucene.search.Queries; import org.elasticsearch.common.unit.Fuzziness; import org.elasticsearch.index.mapper.MappedFieldType; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.index.query.support.QueryParsers; import java.io.IOException; @@ -49,7 +49,7 @@ public class MatchQuery { ALL } - protected final QueryParseContext parseContext; + protected final QueryShardContext context; protected String analyzer; @@ -60,9 +60,9 @@ public class MatchQuery { protected int phraseSlop = 0; protected Fuzziness fuzziness = null; - + protected int fuzzyPrefixLength = FuzzyQuery.defaultPrefixLength; - + protected int maxExpansions = FuzzyQuery.defaultMaxExpansions; protected boolean transpositions = FuzzyQuery.defaultTranspositions; @@ -72,11 +72,11 @@ public class MatchQuery { protected boolean lenient; protected ZeroTermsQuery zeroTermsQuery = ZeroTermsQuery.NONE; - + protected Float commonTermsCutoff = null; - - public MatchQuery(QueryParseContext parseContext) { - this.parseContext = parseContext; + + public MatchQuery(QueryShardContext context) { + this.context = context; } public void setAnalyzer(String analyzer) { @@ -86,7 +86,7 @@ public class MatchQuery { public void setOccur(BooleanClause.Occur occur) { this.occur = occur; } - + public void setCommonTermsCutoff(float cutoff) { this.commonTermsCutoff = Float.valueOf(cutoff); } @@ -134,11 +134,11 @@ public class MatchQuery { protected Analyzer getAnalyzer(MappedFieldType fieldType) { if (this.analyzer == null) { if (fieldType != null) { - return parseContext.getSearchAnalyzer(fieldType); + return context.getSearchAnalyzer(fieldType); } - return parseContext.mapperService().searchAnalyzer(); + return context.mapperService().searchAnalyzer(); } else { - Analyzer analyzer = parseContext.mapperService().analysisService().analyzer(this.analyzer); + Analyzer analyzer = context.mapperService().analysisService().analyzer(this.analyzer); if (analyzer == null) { throw new IllegalArgumentException("No analyzer found for [" + this.analyzer + "]"); } @@ -148,7 +148,7 @@ public class MatchQuery { public Query parse(Type type, String fieldName, Object value) throws IOException { final String field; - MappedFieldType fieldType = parseContext.fieldMapper(fieldName); + MappedFieldType fieldType = context.fieldMapper(fieldName); if (fieldType != null) { field = fieldType.names().indexName(); } else { @@ -157,14 +157,14 @@ public class MatchQuery { if (fieldType != null && fieldType.useTermQueryWithQueryString() && !forceAnalyzeQueryString()) { try { - return fieldType.termQuery(value, parseContext); + return fieldType.termQuery(value, context); } catch (RuntimeException e) { if (lenient) { return null; } throw e; } - + } Analyzer analyzer = getAnalyzer(fieldType); assert analyzer != null; diff --git a/core/src/main/java/org/elasticsearch/index/search/MultiMatchQuery.java b/core/src/main/java/org/elasticsearch/index/search/MultiMatchQuery.java index 878b0502972..2cac148c6e4 100644 --- a/core/src/main/java/org/elasticsearch/index/search/MultiMatchQuery.java +++ b/core/src/main/java/org/elasticsearch/index/search/MultiMatchQuery.java @@ -29,10 +29,9 @@ import org.apache.lucene.search.Query; import org.apache.lucene.util.BytesRef; import org.elasticsearch.common.collect.Tuple; import org.elasticsearch.common.lucene.search.Queries; -import org.elasticsearch.index.mapper.FieldMapper; import org.elasticsearch.index.mapper.MappedFieldType; import org.elasticsearch.index.query.MultiMatchQueryBuilder; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import java.io.IOException; import java.util.ArrayList; @@ -48,10 +47,10 @@ public class MultiMatchQuery extends MatchQuery { this.groupTieBreaker = tieBreaker; } - public MultiMatchQuery(QueryParseContext parseContext) { - super(parseContext); + public MultiMatchQuery(QueryShardContext context) { + super(context); } - + private Query parseAndApply(Type type, String fieldName, Object value, String minimumShouldMatch, Float boostValue) throws IOException { Query query = parse(type, fieldName, value); if (query instanceof BooleanQuery) { @@ -163,7 +162,7 @@ public class MultiMatchQuery extends MatchQuery { List> missing = new ArrayList<>(); for (Map.Entry entry : fieldNames.entrySet()) { String name = entry.getKey(); - MappedFieldType fieldType = parseContext.fieldMapper(name); + MappedFieldType fieldType = context.fieldMapper(name); if (fieldType != null) { Analyzer actualAnalyzer = getAnalyzer(fieldType); name = fieldType.names().indexName(); diff --git a/core/src/main/java/org/elasticsearch/index/shard/TranslogRecoveryPerformer.java b/core/src/main/java/org/elasticsearch/index/shard/TranslogRecoveryPerformer.java index 8738e0abdf5..7235b634951 100644 --- a/core/src/main/java/org/elasticsearch/index/shard/TranslogRecoveryPerformer.java +++ b/core/src/main/java/org/elasticsearch/index/shard/TranslogRecoveryPerformer.java @@ -35,7 +35,12 @@ import org.elasticsearch.index.aliases.IndexAliasesService; import org.elasticsearch.index.cache.IndexCache; import org.elasticsearch.index.engine.Engine; import org.elasticsearch.index.engine.IgnoreOnRecoveryEngineException; -import org.elasticsearch.index.mapper.*; +import org.elasticsearch.index.mapper.DocumentMapper; +import org.elasticsearch.index.mapper.MapperException; +import org.elasticsearch.index.mapper.MapperService; +import org.elasticsearch.index.mapper.MapperUtils; +import org.elasticsearch.index.mapper.Mapping; +import org.elasticsearch.index.mapper.Uid; import org.elasticsearch.index.query.IndexQueryParserService; import org.elasticsearch.index.query.ParsedQuery; import org.elasticsearch.index.query.QueryParsingException; diff --git a/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/GND.java b/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/GND.java index 0ac3b1dba1d..f85bd80cc4d 100644 --- a/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/GND.java +++ b/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/GND.java @@ -28,7 +28,7 @@ import org.elasticsearch.common.io.stream.StreamInput; import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.xcontent.XContentBuilder; import org.elasticsearch.common.xcontent.XContentParser; -import org.elasticsearch.index.query.QueryParsingException; +import org.elasticsearch.index.query.QueryShardException; import java.io.IOException; @@ -115,7 +115,7 @@ public class GND extends NXYSignificanceHeuristic { } @Override - public SignificanceHeuristic parse(XContentParser parser, ParseFieldMatcher parseFieldMatcher) throws IOException, QueryParsingException { + public SignificanceHeuristic parse(XContentParser parser, ParseFieldMatcher parseFieldMatcher) throws IOException, QueryShardException { String givenName = parser.currentName(); boolean backgroundIsSuperset = true; XContentParser.Token token = parser.nextToken(); diff --git a/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/JLHScore.java b/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/JLHScore.java index 78f15733291..5c9794a115a 100644 --- a/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/JLHScore.java +++ b/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/JLHScore.java @@ -27,7 +27,7 @@ import org.elasticsearch.common.io.stream.StreamInput; import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.xcontent.XContentBuilder; import org.elasticsearch.common.xcontent.XContentParser; -import org.elasticsearch.index.query.QueryParsingException; +import org.elasticsearch.index.query.QueryShardException; import java.io.IOException; @@ -108,7 +108,7 @@ public class JLHScore extends SignificanceHeuristic { public static class JLHScoreParser implements SignificanceHeuristicParser { @Override - public SignificanceHeuristic parse(XContentParser parser, ParseFieldMatcher parseFieldMatcher) throws IOException, QueryParsingException { + public SignificanceHeuristic parse(XContentParser parser, ParseFieldMatcher parseFieldMatcher) throws IOException, QueryShardException { // move to the closing bracket if (!parser.nextToken().equals(XContentParser.Token.END_OBJECT)) { throw new ElasticsearchParseException("failed to parse [jhl] significance heuristic. expected an empty object, but found [{}] instead", parser.currentToken()); diff --git a/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/NXYSignificanceHeuristic.java b/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/NXYSignificanceHeuristic.java index cc684c83ef4..d21b319916a 100644 --- a/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/NXYSignificanceHeuristic.java +++ b/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/NXYSignificanceHeuristic.java @@ -27,7 +27,7 @@ import org.elasticsearch.common.ParseFieldMatcher; import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.xcontent.XContentBuilder; import org.elasticsearch.common.xcontent.XContentParser; -import org.elasticsearch.index.query.QueryParsingException; +import org.elasticsearch.index.query.QueryShardException; import java.io.IOException; @@ -138,7 +138,7 @@ public abstract class NXYSignificanceHeuristic extends SignificanceHeuristic { public static abstract class NXYParser implements SignificanceHeuristicParser { @Override - public SignificanceHeuristic parse(XContentParser parser, ParseFieldMatcher parseFieldMatcher) throws IOException, QueryParsingException { + public SignificanceHeuristic parse(XContentParser parser, ParseFieldMatcher parseFieldMatcher) throws IOException, QueryShardException { String givenName = parser.currentName(); boolean includeNegatives = false; boolean backgroundIsSuperset = true; diff --git a/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/PercentageScore.java b/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/PercentageScore.java index 1587a8f5fdf..25556c9d004 100644 --- a/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/PercentageScore.java +++ b/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/PercentageScore.java @@ -27,7 +27,7 @@ import org.elasticsearch.common.io.stream.StreamInput; import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.xcontent.XContentBuilder; import org.elasticsearch.common.xcontent.XContentParser; -import org.elasticsearch.index.query.QueryParsingException; +import org.elasticsearch.index.query.QueryShardException; import java.io.IOException; @@ -77,7 +77,7 @@ public class PercentageScore extends SignificanceHeuristic { public static class PercentageScoreParser implements SignificanceHeuristicParser { @Override - public SignificanceHeuristic parse(XContentParser parser, ParseFieldMatcher parseFieldMatcher) throws IOException, QueryParsingException { + public SignificanceHeuristic parse(XContentParser parser, ParseFieldMatcher parseFieldMatcher) throws IOException, QueryShardException { // move to the closing bracket if (!parser.nextToken().equals(XContentParser.Token.END_OBJECT)) { throw new ElasticsearchParseException("failed to parse [percentage] significance heuristic. expected an empty object, but got [{}] instead", parser.currentToken()); diff --git a/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/ScriptHeuristic.java b/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/ScriptHeuristic.java index 59acd2dcd8b..d0a26b65c9e 100644 --- a/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/ScriptHeuristic.java +++ b/core/src/main/java/org/elasticsearch/search/aggregations/bucket/significant/heuristics/ScriptHeuristic.java @@ -30,7 +30,7 @@ import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.logging.ESLoggerFactory; import org.elasticsearch.common.xcontent.XContentBuilder; import org.elasticsearch.common.xcontent.XContentParser; -import org.elasticsearch.index.query.QueryParsingException; +import org.elasticsearch.index.query.QueryShardException; import org.elasticsearch.script.*; import org.elasticsearch.script.Script.ScriptField; import org.elasticsearch.script.ScriptParameterParser.ScriptParameterValue; @@ -130,7 +130,7 @@ public class ScriptHeuristic extends SignificanceHeuristic { } @Override - public SignificanceHeuristic parse(XContentParser parser, ParseFieldMatcher parseFieldMatcher) throws IOException, QueryParsingException { + public SignificanceHeuristic parse(XContentParser parser, ParseFieldMatcher parseFieldMatcher) throws IOException, QueryShardException { String heuristicName = parser.currentName(); Script script = null; XContentParser.Token token; diff --git a/core/src/main/java/org/elasticsearch/search/fetch/innerhits/InnerHitsParseElement.java b/core/src/main/java/org/elasticsearch/search/fetch/innerhits/InnerHitsParseElement.java index c02e2c6d8ed..ac6dc18d7d4 100644 --- a/core/src/main/java/org/elasticsearch/search/fetch/innerhits/InnerHitsParseElement.java +++ b/core/src/main/java/org/elasticsearch/search/fetch/innerhits/InnerHitsParseElement.java @@ -24,7 +24,7 @@ import org.elasticsearch.common.xcontent.XContentParser; import org.elasticsearch.index.mapper.DocumentMapper; import org.elasticsearch.index.mapper.object.ObjectMapper; import org.elasticsearch.index.query.ParsedQuery; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.search.SearchParseElement; import org.elasticsearch.search.fetch.fielddata.FieldDataFieldsParseElement; import org.elasticsearch.search.fetch.script.ScriptFieldsParseElement; @@ -59,15 +59,15 @@ public class InnerHitsParseElement implements SearchParseElement { @Override public void parse(XContentParser parser, SearchContext searchContext) throws Exception { - QueryParseContext parseContext = searchContext.queryParserService().getParseContext(); - parseContext.reset(parser); - Map innerHitsMap = parseInnerHits(parser, parseContext, searchContext); + QueryShardContext context = searchContext.queryParserService().getShardContext(); + context.reset(parser); + Map innerHitsMap = parseInnerHits(parser, context, searchContext); if (innerHitsMap != null) { searchContext.innerHits(new InnerHitsContext(innerHitsMap)); } } - private Map parseInnerHits(XContentParser parser, QueryParseContext parseContext, SearchContext searchContext) throws Exception { + private Map parseInnerHits(XContentParser parser, QueryShardContext context, SearchContext searchContext) throws Exception { XContentParser.Token token; Map innerHitsMap = null; while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) { @@ -79,7 +79,7 @@ public class InnerHitsParseElement implements SearchParseElement { if (token != XContentParser.Token.START_OBJECT) { throw new IllegalArgumentException("Inner hit definition for [" + innerHitName + " starts with a [" + token + "], expected a [" + XContentParser.Token.START_OBJECT + "]."); } - InnerHitsContext.BaseInnerHits innerHits = parseInnerHit(parser, parseContext, searchContext, innerHitName); + InnerHitsContext.BaseInnerHits innerHits = parseInnerHit(parser, context, searchContext, innerHitName); if (innerHitsMap == null) { innerHitsMap = new HashMap<>(); } @@ -88,7 +88,7 @@ public class InnerHitsParseElement implements SearchParseElement { return innerHitsMap; } - private InnerHitsContext.BaseInnerHits parseInnerHit(XContentParser parser, QueryParseContext parseContext, SearchContext searchContext, String innerHitName) throws Exception { + private InnerHitsContext.BaseInnerHits parseInnerHit(XContentParser parser, QueryShardContext context, SearchContext searchContext, String innerHitName) throws Exception { XContentParser.Token token = parser.nextToken(); if (token != XContentParser.Token.FIELD_NAME) { throw new IllegalArgumentException("Unexpected token " + token + " inside inner hit definition. Either specify [path] or [type] object"); @@ -123,9 +123,9 @@ public class InnerHitsParseElement implements SearchParseElement { final InnerHitsContext.BaseInnerHits innerHits; if (nestedPath != null) { - innerHits = parseNested(parser, parseContext, searchContext, fieldName); + innerHits = parseNested(parser, context, searchContext, fieldName); } else if (type != null) { - innerHits = parseParentChild(parser, parseContext, searchContext, fieldName); + innerHits = parseParentChild(parser, context, searchContext, fieldName); } else { throw new IllegalArgumentException("Either [path] or [type] must be defined"); } @@ -143,16 +143,16 @@ public class InnerHitsParseElement implements SearchParseElement { return innerHits; } - private InnerHitsContext.ParentChildInnerHits parseParentChild(XContentParser parser, QueryParseContext parseContext, SearchContext searchContext, String type) throws Exception { - ParseResult parseResult = parseSubSearchContext(searchContext, parseContext, parser); + private InnerHitsContext.ParentChildInnerHits parseParentChild(XContentParser parser, QueryShardContext context, SearchContext searchContext, String type) throws Exception { + ParseResult parseResult = parseSubSearchContext(searchContext, context, parser); DocumentMapper documentMapper = searchContext.mapperService().documentMapper(type); if (documentMapper == null) { throw new IllegalArgumentException("type [" + type + "] doesn't exist"); } - return new InnerHitsContext.ParentChildInnerHits(parseResult.context(), parseResult.query(), parseResult.childInnerHits(), parseContext.mapperService(), documentMapper); + return new InnerHitsContext.ParentChildInnerHits(parseResult.context(), parseResult.query(), parseResult.childInnerHits(), context.mapperService(), documentMapper); } - private InnerHitsContext.NestedInnerHits parseNested(XContentParser parser, QueryParseContext parseContext, SearchContext searchContext, String nestedPath) throws Exception { + private InnerHitsContext.NestedInnerHits parseNested(XContentParser parser, QueryShardContext context, SearchContext searchContext, String nestedPath) throws Exception { ObjectMapper objectMapper = searchContext.getObjectMapper(nestedPath); if (objectMapper == null) { throw new IllegalArgumentException("path [" + nestedPath +"] doesn't exist"); @@ -160,14 +160,14 @@ public class InnerHitsParseElement implements SearchParseElement { if (objectMapper.nested().isNested() == false) { throw new IllegalArgumentException("path [" + nestedPath +"] isn't nested"); } - ObjectMapper parentObjectMapper = parseContext.nestedScope().nextLevel(objectMapper); - ParseResult parseResult = parseSubSearchContext(searchContext, parseContext, parser); - parseContext.nestedScope().previousLevel(); + ObjectMapper parentObjectMapper = context.nestedScope().nextLevel(objectMapper); + ParseResult parseResult = parseSubSearchContext(searchContext, context, parser); + context.nestedScope().previousLevel(); return new InnerHitsContext.NestedInnerHits(parseResult.context(), parseResult.query(), parseResult.childInnerHits(), parentObjectMapper, objectMapper); } - private ParseResult parseSubSearchContext(SearchContext searchContext, QueryParseContext parseContext, XContentParser parser) throws Exception { + private ParseResult parseSubSearchContext(SearchContext searchContext, QueryShardContext context, XContentParser parser) throws Exception { ParsedQuery query = null; Map childInnerHits = null; SubSearchContext subSearchContext = new SubSearchContext(searchContext); @@ -178,10 +178,10 @@ public class InnerHitsParseElement implements SearchParseElement { fieldName = parser.currentName(); } else if (token == XContentParser.Token.START_OBJECT) { if ("query".equals(fieldName)) { - Query q = searchContext.queryParserService().parseInnerQuery(parseContext); - query = new ParsedQuery(q, parseContext.copyNamedQueries()); + Query q = searchContext.queryParserService().parseInnerQuery(context); + query = new ParsedQuery(q, context.copyNamedQueries()); } else if ("inner_hits".equals(fieldName)) { - childInnerHits = parseInnerHits(parser, parseContext, searchContext); + childInnerHits = parseInnerHits(parser, context, searchContext); } else { parseCommonInnerHitOptions(parser, token, fieldName, subSearchContext, sortParseElement, sourceParseElement, highlighterParseElement, scriptFieldsParseElement, fieldDataFieldsParseElement); } diff --git a/core/src/main/java/org/elasticsearch/search/internal/SearchContext.java b/core/src/main/java/org/elasticsearch/search/internal/SearchContext.java index 901b721c3b5..1c90a2b1ddc 100644 --- a/core/src/main/java/org/elasticsearch/search/internal/SearchContext.java +++ b/core/src/main/java/org/elasticsearch/search/internal/SearchContext.java @@ -41,7 +41,7 @@ import org.elasticsearch.index.mapper.MapperService; import org.elasticsearch.index.mapper.object.ObjectMapper; import org.elasticsearch.index.query.IndexQueryParserService; import org.elasticsearch.index.query.ParsedQuery; -import org.elasticsearch.index.query.QueryParseContext; +import org.elasticsearch.index.query.QueryShardContext; import org.elasticsearch.index.shard.IndexShard; import org.elasticsearch.index.similarity.SimilarityService; import org.elasticsearch.script.ScriptService; @@ -74,12 +74,12 @@ public abstract class SearchContext implements Releasable, HasContextAndHeaders public static void setCurrent(SearchContext value) { current.set(value); - QueryParseContext.setTypes(value.types()); + QueryShardContext.setTypes(value.types()); } public static void removeCurrent() { current.remove(); - QueryParseContext.removeTypes(); + QueryShardContext.removeTypes(); } public static SearchContext current() { diff --git a/core/src/main/java/org/elasticsearch/search/sort/GeoDistanceSortParser.java b/core/src/main/java/org/elasticsearch/search/sort/GeoDistanceSortParser.java index e7941a41d13..8cd88df8635 100644 --- a/core/src/main/java/org/elasticsearch/search/sort/GeoDistanceSortParser.java +++ b/core/src/main/java/org/elasticsearch/search/sort/GeoDistanceSortParser.java @@ -42,7 +42,6 @@ import org.elasticsearch.index.fielddata.IndexGeoPointFieldData; import org.elasticsearch.index.fielddata.MultiGeoPointValues; import org.elasticsearch.index.fielddata.NumericDoubleValues; import org.elasticsearch.index.fielddata.SortedNumericDoubleValues; -import org.elasticsearch.index.mapper.FieldMapper; import org.elasticsearch.index.mapper.MappedFieldType; import org.elasticsearch.index.mapper.object.ObjectMapper; import org.elasticsearch.index.query.support.NestedInnerQueryParseSupport; @@ -156,7 +155,7 @@ public class GeoDistanceSortParser implements SortParser { ObjectMapper objectMapper = context.mapperService().resolveClosestNestedObjectMapper(fieldName); if (objectMapper != null && objectMapper.nested().isNested()) { if (nestedHelper == null) { - nestedHelper = new NestedInnerQueryParseSupport(context.queryParserService().getParseContext()); + nestedHelper = new NestedInnerQueryParseSupport(context.queryParserService().getShardContext()); } nestedHelper.setPath(objectMapper.fullPath()); } @@ -164,7 +163,7 @@ public class GeoDistanceSortParser implements SortParser { final Nested nested; if (nestedHelper != null && nestedHelper.getPath() != null) { - + BitDocIdSetFilter rootDocumentsFilter = context.bitsetFilterCache().getBitDocIdSetFilter(Queries.newNonNestedFilter()); Filter innerDocumentsFilter; if (nestedHelper.filterFound()) { diff --git a/core/src/main/java/org/elasticsearch/search/sort/SortParseElement.java b/core/src/main/java/org/elasticsearch/search/sort/SortParseElement.java index 39da982e13f..d248514b6e2 100644 --- a/core/src/main/java/org/elasticsearch/search/sort/SortParseElement.java +++ b/core/src/main/java/org/elasticsearch/search/sort/SortParseElement.java @@ -244,7 +244,7 @@ public class SortParseElement implements SearchParseElement { ObjectMapper objectMapper = context.mapperService().resolveClosestNestedObjectMapper(fieldName); if (objectMapper != null && objectMapper.nested().isNested()) { if (nestedHelper == null) { - nestedHelper = new NestedInnerQueryParseSupport(context.queryParserService().getParseContext()); + nestedHelper = new NestedInnerQueryParseSupport(context.queryParserService().getShardContext()); } nestedHelper.setPath(objectMapper.fullPath()); } diff --git a/core/src/test/java/org/elasticsearch/ESExceptionTests.java b/core/src/test/java/org/elasticsearch/ESExceptionTests.java index a4a6d28847a..80d847ec80c 100644 --- a/core/src/test/java/org/elasticsearch/ESExceptionTests.java +++ b/core/src/test/java/org/elasticsearch/ESExceptionTests.java @@ -35,6 +35,7 @@ import org.elasticsearch.common.xcontent.XContentFactory; import org.elasticsearch.common.xcontent.XContentLocation; import org.elasticsearch.index.Index; import org.elasticsearch.index.IndexNotFoundException; +import org.elasticsearch.index.query.QueryShardException; import org.elasticsearch.index.query.QueryParsingException; import org.elasticsearch.index.query.TestQueryParsingException; import org.elasticsearch.rest.RestStatus; @@ -307,7 +308,7 @@ public class ESExceptionTests extends ESTestCase { new OutOfMemoryError("no memory left"), new AlreadyClosedException("closed!!", new NullPointerException()), new LockObtainFailedException("can't lock directory", new NullPointerException()), - new Throwable("this exception is unknown", new QueryParsingException(new Index("foo"), 1, 2, "foobar", null) ), // somethin unknown + new Throwable("this exception is unknown", new QueryShardException(new Index("foo"), 1, 2, "foobar", null) ), // somethin unknown }; for (Throwable t : causes) { BytesStreamOutput out = new BytesStreamOutput(); diff --git a/core/src/test/java/org/elasticsearch/ExceptionSerializationTests.java b/core/src/test/java/org/elasticsearch/ExceptionSerializationTests.java index 69d83b7bde7..e2b58bd19c9 100644 --- a/core/src/test/java/org/elasticsearch/ExceptionSerializationTests.java +++ b/core/src/test/java/org/elasticsearch/ExceptionSerializationTests.java @@ -22,6 +22,7 @@ import com.fasterxml.jackson.core.JsonLocation; import com.fasterxml.jackson.core.JsonParseException; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Sets; + import org.codehaus.groovy.runtime.typehandling.GroovyCastException; import org.elasticsearch.action.FailedNodeException; import org.elasticsearch.action.RoutingMissingException; @@ -31,13 +32,24 @@ import org.elasticsearch.action.search.ShardSearchFailure; import org.elasticsearch.cluster.block.ClusterBlockException; import org.elasticsearch.cluster.metadata.SnapshotId; import org.elasticsearch.cluster.node.DiscoveryNode; -import org.elasticsearch.cluster.routing.*; +import org.elasticsearch.cluster.routing.IllegalShardRoutingStateException; +import org.elasticsearch.cluster.routing.RoutingTableValidation; +import org.elasticsearch.cluster.routing.RoutingValidationException; +import org.elasticsearch.cluster.routing.ShardRouting; +import org.elasticsearch.cluster.routing.ShardRoutingState; +import org.elasticsearch.cluster.routing.TestShardRouting; import org.elasticsearch.common.breaker.CircuitBreakingException; import org.elasticsearch.common.io.PathUtils; -import org.elasticsearch.common.io.stream.*; +import org.elasticsearch.common.io.stream.BytesStreamOutput; +import org.elasticsearch.common.io.stream.NotSerializableExceptionWrapper; +import org.elasticsearch.common.io.stream.StreamInput; +import org.elasticsearch.common.io.stream.StreamOutput; import org.elasticsearch.common.transport.LocalTransportAddress; import org.elasticsearch.common.unit.ByteSizeValue; -import org.elasticsearch.common.xcontent.*; +import org.elasticsearch.common.xcontent.ToXContent; +import org.elasticsearch.common.xcontent.XContentBuilder; +import org.elasticsearch.common.xcontent.XContentFactory; +import org.elasticsearch.common.xcontent.XContentLocation; import org.elasticsearch.discovery.DiscoverySettings; import org.elasticsearch.index.AlreadyExpiredException; import org.elasticsearch.index.Index; @@ -46,7 +58,10 @@ import org.elasticsearch.index.engine.IndexFailedEngineException; import org.elasticsearch.index.engine.RecoveryEngineException; import org.elasticsearch.index.mapper.MergeMappingException; import org.elasticsearch.index.query.QueryParsingException; -import org.elasticsearch.index.shard.*; +import org.elasticsearch.index.shard.IllegalIndexShardStateException; +import org.elasticsearch.index.shard.IndexShardState; +import org.elasticsearch.index.shard.ShardId; +import org.elasticsearch.index.shard.TranslogRecoveryPerformer; import org.elasticsearch.indices.IndexTemplateAlreadyExistsException; import org.elasticsearch.indices.IndexTemplateMissingException; import org.elasticsearch.indices.InvalidIndexTemplateException; diff --git a/core/src/test/java/org/elasticsearch/index/query/AndQueryBuilderTest.java b/core/src/test/java/org/elasticsearch/index/query/AndQueryBuilderTest.java index 8861884dd59..5b7289f793b 100644 --- a/core/src/test/java/org/elasticsearch/index/query/AndQueryBuilderTest.java +++ b/core/src/test/java/org/elasticsearch/index/query/AndQueryBuilderTest.java @@ -52,7 +52,7 @@ public class AndQueryBuilderTest extends BaseQueryTestCase { } @Override - protected void doAssertLuceneQuery(AndQueryBuilder queryBuilder, Query query, QueryParseContext context) throws IOException { + protected void doAssertLuceneQuery(AndQueryBuilder queryBuilder, Query query, QueryShardContext context) throws IOException { if (queryBuilder.filters().isEmpty()) { assertThat(query, nullValue()); } else { @@ -82,19 +82,19 @@ public class AndQueryBuilderTest extends BaseQueryTestCase { * test corner case where no inner queries exist */ @Test - public void testNoInnerQueries() throws QueryParsingException, IOException { + public void testNoInnerQueries() throws QueryShardException, IOException { AndQueryBuilder andQuery = new AndQueryBuilder(); - assertNull(andQuery.toQuery(createContext())); + assertNull(andQuery.toQuery(createShardContext())); } @Test(expected=QueryParsingException.class) public void testMissingFiltersSection() throws IOException { - QueryParseContext context = createContext(); + QueryParseContext context = createParseContext(); String queryString = "{ \"and\" : {}"; XContentParser parser = XContentFactory.xContent(queryString).createParser(queryString); context.reset(parser); assertQueryHeader(parser, AndQueryBuilder.PROTOTYPE.getName()); - context.indexQueryParserService().queryParser(AndQueryBuilder.PROTOTYPE.getName()).fromXContent(context); + context.queryParser(AndQueryBuilder.PROTOTYPE.getName()).fromXContent(context); } @Test diff --git a/core/src/test/java/org/elasticsearch/index/query/BaseQueryTestCase.java b/core/src/test/java/org/elasticsearch/index/query/BaseQueryTestCase.java index 5bead0f07e3..249d8341d9e 100644 --- a/core/src/test/java/org/elasticsearch/index/query/BaseQueryTestCase.java +++ b/core/src/test/java/org/elasticsearch/index/query/BaseQueryTestCase.java @@ -171,7 +171,7 @@ public abstract class BaseQueryTestCase> ext //some query (e.g. range query) have a different behaviour depending on whether the current search context is set or not //which is why we randomly set the search context, which will internally also do QueryParseContext.setTypes(types) if (randomBoolean()) { - QueryParseContext.setTypes(types); + QueryShardContext.setTypes(types); } else { TestSearchContext testSearchContext = new TestSearchContext(); testSearchContext.setTypes(types); @@ -181,7 +181,7 @@ public abstract class BaseQueryTestCase> ext @After public void afterTest() { - QueryParseContext.removeTypes(); + QueryShardContext.removeTypes(); SearchContext.removeCurrent(); } @@ -210,7 +210,7 @@ public abstract class BaseQueryTestCase> ext @Test public void testFromXContent() throws IOException { QB testQuery = createTestQueryBuilder(); - QueryParseContext context = createContext(); + QueryParseContext context = createParseContext(); String contentString = testQuery.toString(); XContentParser parser = XContentFactory.xContent(contentString).createParser(contentString); context.reset(parser); @@ -228,7 +228,7 @@ public abstract class BaseQueryTestCase> ext */ @Test public void testToQuery() throws IOException { - QueryParseContext context = createContext(); + QueryShardContext context = createShardContext(); context.setAllowUnmappedFields(true); QB firstQuery = createTestQueryBuilder(); @@ -272,11 +272,11 @@ public abstract class BaseQueryTestCase> ext } /** - * Checks the result of {@link QueryBuilder#toQuery(QueryParseContext)} given the original {@link QueryBuilder} and {@link QueryParseContext}. - * Verifies that named queries and boost are properly handled and delegates to {@link #doAssertLuceneQuery(AbstractQueryBuilder, Query, QueryParseContext)} + * Checks the result of {@link QueryBuilder#toQuery(QueryShardContext)} given the original {@link QueryBuilder} and {@link QueryShardContext}. + * Verifies that named queries and boost are properly handled and delegates to {@link #doAssertLuceneQuery(AbstractQueryBuilder, Query, QueryShardContext)} * for query specific checks. */ - protected final void assertLuceneQuery(QB queryBuilder, Query query, QueryParseContext context) throws IOException { + protected final void assertLuceneQuery(QB queryBuilder, Query query, QueryShardContext context) throws IOException { if (queryBuilder.queryName() != null) { Query namedQuery = context.copyNamedQueries().get(queryBuilder.queryName()); assertThat(namedQuery, equalTo(query)); @@ -288,10 +288,10 @@ public abstract class BaseQueryTestCase> ext } /** - * Checks the result of {@link QueryBuilder#toQuery(QueryParseContext)} given the original {@link QueryBuilder} and {@link QueryParseContext}. + * Checks the result of {@link QueryBuilder#toQuery(QueryShardContext)} given the original {@link QueryBuilder} and {@link QueryShardContext}. * Contains the query specific checks to be implemented by subclasses. */ - protected abstract void doAssertLuceneQuery(QB queryBuilder, Query query, QueryParseContext context) throws IOException; + protected abstract void doAssertLuceneQuery(QB queryBuilder, Query query, QueryShardContext context) throws IOException; /** * Test serialization and deserialization of the test query. @@ -311,13 +311,21 @@ public abstract class BaseQueryTestCase> ext } } + /** + * @return a new {@link QueryShardContext} based on the base test index and queryParserService + */ + protected static QueryShardContext createShardContext() { + QueryShardContext queryCreationContext = new QueryShardContext(index, queryParserService); + queryCreationContext.parseFieldMatcher(ParseFieldMatcher.EMPTY); + return queryCreationContext; + } + /** * @return a new {@link QueryParseContext} based on the base test index and queryParserService */ - protected static QueryParseContext createContext() { - QueryParseContext queryParseContext = new QueryParseContext(index, queryParserService); - queryParseContext.parseFieldMatcher(ParseFieldMatcher.EMPTY); - return queryParseContext; + protected static QueryParseContext createParseContext() { + QueryParseContext parseContext = createShardContext().parseContext(); + return parseContext; } protected static void assertQueryHeader(XContentParser parser, String expectedParserName) throws IOException { diff --git a/core/src/test/java/org/elasticsearch/index/query/BaseTermQueryTestCase.java b/core/src/test/java/org/elasticsearch/index/query/BaseTermQueryTestCase.java index d34dcaad88a..6da2895ec52 100644 --- a/core/src/test/java/org/elasticsearch/index/query/BaseTermQueryTestCase.java +++ b/core/src/test/java/org/elasticsearch/index/query/BaseTermQueryTestCase.java @@ -72,7 +72,7 @@ public abstract class BaseTermQueryTestCase> protected abstract QB createQueryBuilder(String fieldName, Object value); @Test - public void testValidate() throws QueryParsingException { + public void testValidate() throws QueryShardException { QB queryBuilder = createQueryBuilder(randomAsciiOfLengthBetween(1, 30), randomAsciiOfLengthBetween(1, 30)); assertNull(queryBuilder.validate()); diff --git a/core/src/test/java/org/elasticsearch/index/query/BoolQueryBuilderTest.java b/core/src/test/java/org/elasticsearch/index/query/BoolQueryBuilderTest.java index f9283f5f0d2..027ab367b1c 100644 --- a/core/src/test/java/org/elasticsearch/index/query/BoolQueryBuilderTest.java +++ b/core/src/test/java/org/elasticsearch/index/query/BoolQueryBuilderTest.java @@ -67,7 +67,7 @@ public class BoolQueryBuilderTest extends BaseQueryTestCase { } @Override - protected void doAssertLuceneQuery(BoolQueryBuilder queryBuilder, Query query, QueryParseContext context) throws IOException { + protected void doAssertLuceneQuery(BoolQueryBuilder queryBuilder, Query query, QueryShardContext context) throws IOException { if (!queryBuilder.hasClauses()) { assertThat(query, instanceOf(MatchAllDocsQuery.class)); } else { @@ -103,10 +103,10 @@ public class BoolQueryBuilderTest extends BaseQueryTestCase { } } - private static List getBooleanClauses(List queryBuilders, BooleanClause.Occur occur, QueryParseContext parseContext) throws IOException { + private static List getBooleanClauses(List queryBuilders, BooleanClause.Occur occur, QueryShardContext context) throws IOException { List clauses = new ArrayList<>(); for (QueryBuilder query : queryBuilders) { - Query innerQuery = query.toQuery(parseContext); + Query innerQuery = query.toQuery(context); if (innerQuery != null) { clauses.add(new BooleanClause(innerQuery, occur)); } diff --git a/core/src/test/java/org/elasticsearch/index/query/BoostingQueryBuilderTest.java b/core/src/test/java/org/elasticsearch/index/query/BoostingQueryBuilderTest.java index 742e0a1f203..72c157e7bd1 100644 --- a/core/src/test/java/org/elasticsearch/index/query/BoostingQueryBuilderTest.java +++ b/core/src/test/java/org/elasticsearch/index/query/BoostingQueryBuilderTest.java @@ -38,7 +38,7 @@ public class BoostingQueryBuilderTest extends BaseQueryTestCase queries = AbstractQueryBuilder.toQueries(queryBuilder.queries(), context); if (queries.isEmpty()) { assertThat(query, nullValue()); @@ -76,7 +76,7 @@ public class DisMaxQueryBuilderTest extends BaseQueryTestCase { public void testIdsNotProvided() throws IOException { String noIdsFieldQuery = "{\"ids\" : { \"type\" : \"my_type\" }"; XContentParser parser = XContentFactory.xContent(noIdsFieldQuery).createParser(noIdsFieldQuery); - QueryParseContext context = createContext(); + QueryParseContext context = createParseContext(); context.reset(parser); assertQueryHeader(parser, "ids"); - context.indexQueryParserService().queryParser("ids").fromXContent(context); + context.queryParser("ids").fromXContent(context); } @Override @@ -86,7 +86,7 @@ public class IdsQueryBuilderTest extends BaseQueryTestCase { } @Override - protected void doAssertLuceneQuery(IdsQueryBuilder queryBuilder, Query query, QueryParseContext context) throws IOException { + protected void doAssertLuceneQuery(IdsQueryBuilder queryBuilder, Query query, QueryShardContext context) throws IOException { if (queryBuilder.ids().size() == 0) { assertThat(query, instanceOf(BooleanQuery.class)); assertThat(((BooleanQuery)query).clauses().size(), equalTo(0)); diff --git a/core/src/test/java/org/elasticsearch/index/query/IndexQueryParserFilterDateRangeTimezoneTests.java b/core/src/test/java/org/elasticsearch/index/query/IndexQueryParserFilterDateRangeTimezoneTests.java index d581aa6ae77..6222f3b6a35 100644 --- a/core/src/test/java/org/elasticsearch/index/query/IndexQueryParserFilterDateRangeTimezoneTests.java +++ b/core/src/test/java/org/elasticsearch/index/query/IndexQueryParserFilterDateRangeTimezoneTests.java @@ -83,7 +83,7 @@ public class IndexQueryParserFilterDateRangeTimezoneTests extends ESSingleNodeTe SearchContext.setCurrent(new TestSearchContext()); queryParser.parse(query).query(); fail("A Range Filter on a numeric field with a TimeZone should raise a QueryParsingException"); - } catch (QueryParsingException e) { + } catch (QueryShardException e) { // We expect it } finally { SearchContext.removeCurrent(); @@ -120,7 +120,7 @@ public class IndexQueryParserFilterDateRangeTimezoneTests extends ESSingleNodeTe SearchContext.setCurrent(new TestSearchContext()); queryParser.parse(query).query(); fail("A Range Query on a numeric field with a TimeZone should raise a QueryParsingException"); - } catch (QueryParsingException e) { + } catch (QueryShardException e) { // We expect it } finally { SearchContext.removeCurrent(); diff --git a/core/src/test/java/org/elasticsearch/index/query/LimitQueryBuilderTest.java b/core/src/test/java/org/elasticsearch/index/query/LimitQueryBuilderTest.java index b5c795f1663..59bb64489b0 100644 --- a/core/src/test/java/org/elasticsearch/index/query/LimitQueryBuilderTest.java +++ b/core/src/test/java/org/elasticsearch/index/query/LimitQueryBuilderTest.java @@ -37,7 +37,7 @@ public class LimitQueryBuilderTest extends BaseQueryTestCase } @Override - protected void doAssertLuceneQuery(LimitQueryBuilder queryBuilder, Query query, QueryParseContext context) throws IOException { + protected void doAssertLuceneQuery(LimitQueryBuilder queryBuilder, Query query, QueryShardContext context) throws IOException { assertThat(query, instanceOf(MatchAllDocsQuery.class)); } } diff --git a/core/src/test/java/org/elasticsearch/index/query/MatchAllQueryBuilderTest.java b/core/src/test/java/org/elasticsearch/index/query/MatchAllQueryBuilderTest.java index f5e48ef9815..277717cac69 100644 --- a/core/src/test/java/org/elasticsearch/index/query/MatchAllQueryBuilderTest.java +++ b/core/src/test/java/org/elasticsearch/index/query/MatchAllQueryBuilderTest.java @@ -34,7 +34,7 @@ public class MatchAllQueryBuilderTest extends BaseQueryTestCase { } @Override - protected void doAssertLuceneQuery(NotQueryBuilder queryBuilder, Query query, QueryParseContext context) throws IOException { + protected void doAssertLuceneQuery(NotQueryBuilder queryBuilder, Query query, QueryShardContext context) throws IOException { Query filter = queryBuilder.filter().toQuery(context); if (filter == null) { assertThat(query, nullValue()); @@ -64,12 +64,12 @@ public class NotQueryBuilderTest extends BaseQueryTestCase { */ @Test(expected=QueryParsingException.class) public void testMissingFilterSection() throws IOException { - QueryParseContext context = createContext(); + QueryParseContext context = createParseContext(); String queryString = "{ \"not\" : {}"; XContentParser parser = XContentFactory.xContent(queryString).createParser(queryString); context.reset(parser); assertQueryHeader(parser, NotQueryBuilder.PROTOTYPE.getName()); - context.indexQueryParserService().queryParser(NotQueryBuilder.PROTOTYPE.getName()).fromXContent(context); + context.queryParser(NotQueryBuilder.PROTOTYPE.getName()).fromXContent(context); } @Test diff --git a/core/src/test/java/org/elasticsearch/index/query/OrQueryBuilderTest.java b/core/src/test/java/org/elasticsearch/index/query/OrQueryBuilderTest.java index b7495979971..47ee4b5d944 100644 --- a/core/src/test/java/org/elasticsearch/index/query/OrQueryBuilderTest.java +++ b/core/src/test/java/org/elasticsearch/index/query/OrQueryBuilderTest.java @@ -40,7 +40,7 @@ public class OrQueryBuilderTest extends BaseQueryTestCase { /* @Override - protected Query doCreateExpectedQuery(OrQueryBuilder queryBuilder, QueryParseContext context) throws QueryParsingException, IOException { + protected Query doCreateExpectedQuery(OrQueryBuilder queryBuilder, QueryCreationContext context) throws QueryCreationException, IOException { if (queryBuilder.filters().isEmpty()) { return null; } @@ -73,7 +73,7 @@ public class OrQueryBuilderTest extends BaseQueryTestCase { } @Override - protected void doAssertLuceneQuery(OrQueryBuilder queryBuilder, Query query, QueryParseContext context) throws IOException { + protected void doAssertLuceneQuery(OrQueryBuilder queryBuilder, Query query, QueryShardContext context) throws IOException { if (queryBuilder.filters().isEmpty()) { assertThat(query, nullValue()); } else { @@ -104,19 +104,19 @@ public class OrQueryBuilderTest extends BaseQueryTestCase { * test corner case where no inner queries exist */ @Test - public void testNoInnerQueries() throws QueryParsingException, IOException { + public void testNoInnerQueries() throws QueryShardException, IOException { OrQueryBuilder orQuery = new OrQueryBuilder(); - assertNull(orQuery.toQuery(createContext())); + assertNull(orQuery.toQuery(createShardContext())); } @Test(expected=QueryParsingException.class) public void testMissingFiltersSection() throws IOException { - QueryParseContext context = createContext(); + QueryParseContext context = createParseContext(); String queryString = "{ \"or\" : {}"; XContentParser parser = XContentFactory.xContent(queryString).createParser(queryString); context.reset(parser); assertQueryHeader(parser, OrQueryBuilder.PROTOTYPE.getName()); - context.indexQueryParserService().queryParser(OrQueryBuilder.PROTOTYPE.getName()).fromXContent(context); + context.queryParser(OrQueryBuilder.PROTOTYPE.getName()).fromXContent(context); } @Test diff --git a/core/src/test/java/org/elasticsearch/index/query/PrefixQueryBuilderTest.java b/core/src/test/java/org/elasticsearch/index/query/PrefixQueryBuilderTest.java index 752fbcf6999..42fe5abff06 100644 --- a/core/src/test/java/org/elasticsearch/index/query/PrefixQueryBuilderTest.java +++ b/core/src/test/java/org/elasticsearch/index/query/PrefixQueryBuilderTest.java @@ -44,7 +44,7 @@ public class PrefixQueryBuilderTest extends BaseQueryTestCase query.to(new DateTime(System.currentTimeMillis() + randomIntBetween(0, 1000000), DateTimeZone.UTC).toString()); // Create timestamp option only then we have a date mapper, // otherwise we could trigger exception. - if (createContext().mapperService().smartNameFieldType(DATE_FIELD_NAME) != null) { + if (createShardContext().mapperService().smartNameFieldType(DATE_FIELD_NAME) != null) { if (randomBoolean()) { query.timeZone(TIMEZONE_IDS.get(randomIntBetween(0, TIMEZONE_IDS.size() - 1))); } @@ -89,7 +89,7 @@ public class RangeQueryBuilderTest extends BaseQueryTestCase } @Override - protected void doAssertLuceneQuery(RangeQueryBuilder queryBuilder, Query query, QueryParseContext context) throws IOException { + protected void doAssertLuceneQuery(RangeQueryBuilder queryBuilder, Query query, QueryShardContext context) throws IOException { if (getCurrentTypes().length == 0 || (queryBuilder.fieldName().equals(DATE_FIELD_NAME) == false && queryBuilder.fieldName().equals(INT_FIELD_NAME) == false)) { assertThat(query, instanceOf(TermRangeQuery.class)); } else if (queryBuilder.fieldName().equals(DATE_FIELD_NAME)) { @@ -125,20 +125,20 @@ public class RangeQueryBuilderTest extends BaseQueryTestCase /** * Specifying a timezone together with a numeric range query should throw an exception. */ - @Test(expected=QueryParsingException.class) - public void testToQueryNonDateWithTimezone() throws QueryParsingException, IOException { + @Test(expected=QueryShardException.class) + public void testToQueryNonDateWithTimezone() throws QueryShardException, IOException { RangeQueryBuilder query = new RangeQueryBuilder(INT_FIELD_NAME); query.from(1).to(10).timeZone("UTC"); - query.toQuery(createContext()); + query.toQuery(createShardContext()); } /** * Specifying a timezone together with an unmapped field should throw an exception. */ - @Test(expected=QueryParsingException.class) - public void testToQueryUnmappedWithTimezone() throws QueryParsingException, IOException { + @Test(expected=QueryShardException.class) + public void testToQueryUnmappedWithTimezone() throws QueryShardException, IOException { RangeQueryBuilder query = new RangeQueryBuilder("bogus_field"); query.from(1).to(10).timeZone("UTC"); - query.toQuery(createContext()); + query.toQuery(createShardContext()); } } diff --git a/core/src/test/java/org/elasticsearch/index/query/RegexpQueryBuilderTest.java b/core/src/test/java/org/elasticsearch/index/query/RegexpQueryBuilderTest.java index 153b2225625..9328609efd6 100644 --- a/core/src/test/java/org/elasticsearch/index/query/RegexpQueryBuilderTest.java +++ b/core/src/test/java/org/elasticsearch/index/query/RegexpQueryBuilderTest.java @@ -43,7 +43,7 @@ public class RegexpQueryBuilderTest extends BaseQueryTestCase flags = new ArrayList<>(); int iter = randomInt(5); for (int i = 0; i < iter; i++) { - flags.add(randomFrom(RegexpFlag.values())); + flags.add(randomFrom(RegexpFlag.values())); } query.flags(flags.toArray(new RegexpFlag[flags.size()])); } @@ -57,7 +57,7 @@ public class RegexpQueryBuilderTest extends BaseQueryTestCase 0 && parseContext.fieldMapper(DATE_FIELD_NAME) != null) { + if (getCurrentTypes().length > 0 && context.fieldMapper(DATE_FIELD_NAME) != null) { try { RangeQueryBuilder query = new RangeQueryBuilder(DATE_FIELD_NAME); - new SpanMultiTermQueryBuilder(query).toQuery(createContext()); + new SpanMultiTermQueryBuilder(query).toQuery(createShardContext()); fail("Exception expected, range query on date fields should not generate a lucene " + MultiTermQuery.class.getName()); } catch (UnsupportedOperationException e) { assert(e.getMessage().contains("unsupported inner query, should be " + MultiTermQuery.class.getName())); diff --git a/core/src/test/java/org/elasticsearch/index/query/SpanNearQueryBuilderTest.java b/core/src/test/java/org/elasticsearch/index/query/SpanNearQueryBuilderTest.java index d1c3db7012b..d2eb1a01810 100644 --- a/core/src/test/java/org/elasticsearch/index/query/SpanNearQueryBuilderTest.java +++ b/core/src/test/java/org/elasticsearch/index/query/SpanNearQueryBuilderTest.java @@ -45,7 +45,7 @@ public class SpanNearQueryBuilderTest extends BaseQueryTestCase { } @Override - protected void doAssertLuceneQuery(TypeQueryBuilder queryBuilder, Query query, QueryParseContext context) throws IOException { + protected void doAssertLuceneQuery(TypeQueryBuilder queryBuilder, Query query, QueryShardContext context) throws IOException { assertThat(query, either(instanceOf(TermQuery.class)).or(instanceOf(ConstantScoreQuery.class))); if (query instanceof ConstantScoreQuery) { query = ((ConstantScoreQuery) query).getQuery(); diff --git a/core/src/test/java/org/elasticsearch/index/query/WildcardQueryBuilderTest.java b/core/src/test/java/org/elasticsearch/index/query/WildcardQueryBuilderTest.java index 3e9f54dc972..ba23249c81f 100644 --- a/core/src/test/java/org/elasticsearch/index/query/WildcardQueryBuilderTest.java +++ b/core/src/test/java/org/elasticsearch/index/query/WildcardQueryBuilderTest.java @@ -48,7 +48,7 @@ public class WildcardQueryBuilderTest extends BaseQueryTestCase matcher) { - assertExplanation(queryBuilder, matcher, false); - } - - private void assertExplanation(QueryBuilder queryBuilder, Matcher matcher, boolean withRewrite) { + private static void assertExplanation(QueryBuilder queryBuilder, Matcher matcher, boolean withRewrite) { ValidateQueryResponse response = client().admin().indices().prepareValidateQuery("test") .setTypes("type1") .setQuery(queryBuilder)