@Nullable public Query parseInnerFilter() throws QueryParsingException, IOException { final boolean originalIsFilter = isFilter; try { isFilter = true; return parseInnerQuery(); } finally { isFilter = originalIsFilter; } }
@Override public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException { deprecationLogger.deprecated("The [query] filter is deprecated, you can now use queries as filters directly."); return new ConstantScoreQuery(parseContext.parseInnerQuery()); } }
@Nullable public Query parseInnerQuery(QueryParseContext parseContext) throws IOException { parseContext.parseFieldMatcher(parseFieldMatcher); Query query = parseContext.parseInnerQuery(); if (query == null) { query = Queries.newMatchNoDocsQuery(); } return query; }
@Nullable public Query parseInnerQuery(XContentParser parser) throws IOException { QueryParseContext context = cache.get(); XContentParser originalParser = context.parser(); context.reset(parser); try { return context.parseInnerQuery(); } finally { context.reset(originalParser); } }
if ("clauses".equals(currentFieldName)) { while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) { Query query = parseContext.parseInnerQuery(); if (!(query instanceof SpanQuery)) { throw new QueryParsingException(parseContext, "spanOr [clauses] must be of type span query");
if ("clauses".equals(currentFieldName)) { while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) { Query query = parseContext.parseInnerQuery(); if (!(query instanceof SpanQuery)) { throw new QueryParsingException(parseContext, "spanNear [clauses] must be of type span query");
} else if (token == XContentParser.Token.START_OBJECT) { if ("positive".equals(currentFieldName)) { positiveQuery = parseContext.parseInnerQuery(); positiveQueryFound = true; } else if ("negative".equals(currentFieldName)) { negativeQuery = parseContext.parseInnerQuery(); negativeQueryFound = true; } else {
public void query() throws IOException { if (path != null) { setPathLevel(); try { innerQuery = parseContext.parseInnerQuery(); } finally { resetPathLevel(); } queryParsed = true; } else { source = XContentFactory.smileBuilder().copyCurrentStructure(parseContext.parser()).bytes(); } queryFound = true; }
} else if (token == XContentParser.Token.START_OBJECT) { if ("big".equals(currentFieldName)) { Query query = parseContext.parseInnerQuery(); if (!(query instanceof SpanQuery)) { throw new QueryParsingException(parseContext, "span_containing [big] must be of type span query"); Query query = parseContext.parseInnerQuery(); if (!(query instanceof SpanQuery)) { throw new QueryParsingException(parseContext, "span_containing [little] must be of type span query");
private ParsedQuery innerParse(QueryParseContext parseContext, XContentParser parser) throws IOException, QueryParsingException { XContentParser originalParser = parseContext.parser(); parseContext.reset(parser); try { parseContext.parseFieldMatcher(parseFieldMatcher); Query query = parseContext.parseInnerQuery(); if (query == null) { query = Queries.newMatchNoDocsQuery(); } return new ParsedQuery(query, parseContext.copyNamedQueries()); } finally { parseContext.reset(originalParser); } }
} else if (token == XContentParser.Token.START_OBJECT) { if ("big".equals(currentFieldName)) { Query query = parseContext.parseInnerQuery(); if (query instanceof SpanQuery == false) { throw new QueryParsingException(parseContext, "span_within [big] must be of type span query"); Query query = parseContext.parseInnerQuery(); if (query instanceof SpanQuery == false) { throw new QueryParsingException(parseContext, "span_within [little] must be of type span query");
@Override public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException { XContentParser parser = parseContext.parser(); Token token = parser.nextToken(); if (!MATCH_NAME.equals(parser.currentName()) || token != XContentParser.Token.FIELD_NAME) { throw new QueryParsingException(parseContext, "spanMultiTerm must have [" + MATCH_NAME + "] multi term query clause"); } token = parser.nextToken(); if (token != XContentParser.Token.START_OBJECT) { throw new QueryParsingException(parseContext, "spanMultiTerm must have [" + MATCH_NAME + "] multi term query clause"); } Query subQuery = parseContext.parseInnerQuery(); if (!(subQuery instanceof MultiTermQuery)) { throw new QueryParsingException(parseContext, "spanMultiTerm [" + MATCH_NAME + "] must be of type multi term query"); } parser.nextToken(); return new SpanMultiTermQueryWrapper<>((MultiTermQuery) subQuery); } }
public InnerQuery(QueryParseContext parseContext1, @Nullable String... types) throws IOException { super(parseContext1); if (types != null) { String[] origTypes = QueryParseContext.setTypesWithPrevious(types); try { query = parseContext1.parseInnerQuery(); queryParsed = true; } finally { QueryParseContext.setTypes(origTypes); } } else { BytesReference innerBytes = XContentFactory.smileBuilder().copyCurrentStructure(parseContext1.parser()).bytes(); super.bytes(innerBytes); } }
query = parseContext.parseInnerQuery(); } else if ("filter".equals(currentFieldName)) { filterFound = true;
/** * Use the captured bytes to parse the inner query using the specified * types. The original QueryParseContext's parser is switched during this * parsing, so this method is NOT thread-safe. * @param types types to be used during the inner query parsing * @return {@link Query} parsed from the bytes captured in {@code freeze()} */ public Query asQuery(String... types) throws IOException { 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); XContentParser old = parseContext.parser(); parseContext.parser(innerParser); try { return parseContext.parseInnerQuery(); } finally { parseContext.parser(old); QueryParseContext.setTypes(origTypes); } }
} else if (token == XContentParser.Token.START_OBJECT) { if ("match".equals(currentFieldName)) { Query query = parseContext.parseInnerQuery(); if (!(query instanceof SpanQuery)) { throw new QueryParsingException(parseContext, "spanFirst [match] must be of type span query");
if ("query".equals(currentFieldName)) { queryFound = true; query = parseContext.parseInnerQuery(); } else { throw new QueryParsingException(parseContext, "[fquery] query does not support [" + currentFieldName + "]");
public Query getInnerQuery() throws IOException { if (queryParsed) { return innerQuery; } else { if (path == null) { throw new QueryParsingException(parseContext, "[nested] requires 'path' field"); } if (!queryFound) { throw new QueryParsingException(parseContext, "[nested] requires either 'query' or 'filter' field"); } XContentParser old = parseContext.parser(); try { XContentParser innerParser = XContentHelper.createParser(source); parseContext.parser(innerParser); setPathLevel(); try { innerQuery = parseContext.parseInnerQuery(); } finally { resetPathLevel(); } queryParsed = true; return innerQuery; } finally { parseContext.parser(old); } } }
/** * Parses the template query replacing template parameters with provided * values. Handles both submitting the template as part of the request as * well as referencing only the template name. * * @param parseContext * parse context containing the templated query. */ @Override @Nullable public Query parse(QueryParseContext parseContext) throws IOException { XContentParser parser = parseContext.parser(); Template template = parse(parser, parseContext.parseFieldMatcher()); ExecutableScript executable = this.scriptService.executable(template, ScriptContext.Standard.SEARCH, SearchContext.current(), Collections.<String, String>emptyMap()); BytesReference querySource = (BytesReference) executable.run(); try (XContentParser qSourceParser = XContentFactory.xContent(querySource).createParser(querySource)) { final QueryParseContext context = new QueryParseContext(parseContext.index(), parseContext.indexQueryParserService()); context.reset(qSourceParser); return context.parseInnerQuery(); } }
@Override public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException { XContentParser parser = parseContext.parser(); XContentParser.Token token = parser.nextToken(); if (token != XContentParser.Token.FIELD_NAME) { throw new QueryParsingException(parseContext, "[wrapper] query malformed"); } String fieldName = parser.currentName(); if (!fieldName.equals("query")) { throw new QueryParsingException(parseContext, "[wrapper] query malformed"); } parser.nextToken(); byte[] querySource = parser.binaryValue(); try (XContentParser qSourceParser = XContentFactory.xContent(querySource).createParser(querySource)) { final QueryParseContext context = new QueryParseContext(parseContext.index(), parseContext.indexQueryParserService()); context.reset(qSourceParser); Query result = context.parseInnerQuery(); parser.nextToken(); parseContext.combineNamedQueries(context); return result; } } }