public void testFQ6() throws Exception {
Query q =
new FilteredQuery(
new TermQuery(new Term(FIELD, "xx")), new ItemizedFilter(new int[] {1, 3}));
q.setBoost(1000);
qtest(q, new int[] {3});
}
/**
* @param query
* @param virtualWikiNames comma separated list of virtual wiki names
* @param languages comma separated list of language codes to search in, may be null to search all
* languages
*/
private Query buildQuery(String query, String virtualWikiNames, String languages)
throws ParseException {
// build a query like this: <user query string> AND <wikiNamesQuery> AND
// <languageQuery>
BooleanQuery bQuery = new BooleanQuery();
Query parsedQuery = null;
// for object search
if (query.startsWith("PROP ")) {
String property = query.substring(0, query.indexOf(":"));
query = query.substring(query.indexOf(":") + 1, query.length());
QueryParser qp = new QueryParser(Version.LUCENE_36, property, this.analyzer);
parsedQuery = qp.parse(query);
bQuery.add(parsedQuery, BooleanClause.Occur.MUST);
} else if (query.startsWith("MULTI ")) {
// for fulltext search
List<String> fieldList = IndexUpdater.fields;
String[] fields = fieldList.toArray(new String[fieldList.size()]);
BooleanClause.Occur[] flags = new BooleanClause.Occur[fields.length];
for (int i = 0; i < flags.length; i++) {
flags[i] = BooleanClause.Occur.SHOULD;
}
parsedQuery =
MultiFieldQueryParser.parse(Version.LUCENE_36, query, fields, flags, this.analyzer);
bQuery.add(parsedQuery, BooleanClause.Occur.MUST);
} else {
String[] fields =
new String[] {
IndexFields.FULLTEXT,
IndexFields.DOCUMENT_TITLE,
IndexFields.DOCUMENT_NAME,
IndexFields.FILENAME
};
BooleanClause.Occur[] flags = new BooleanClause.Occur[fields.length];
for (int i = 0; i < flags.length; i++) {
flags[i] = BooleanClause.Occur.SHOULD;
}
QueryParser parser = new MultiFieldQueryParser(Version.LUCENE_36, fields, this.analyzer);
parsedQuery = parser.parse(query);
// Since the sub-queries are OR-ed, each sub-query score is normally divided by the number of
// sub-queries,
// which would cause extra-small scores whenever there's a hit on only one sub-query;
// compensate this by boosting the whole outer query
parsedQuery.setBoost(fields.length);
bQuery.add(parsedQuery, BooleanClause.Occur.MUST);
}
if (virtualWikiNames != null && virtualWikiNames.length() > 0) {
bQuery.add(
buildOredTermQuery(virtualWikiNames, IndexFields.DOCUMENT_WIKI),
BooleanClause.Occur.MUST);
}
if (languages != null && languages.length() > 0) {
bQuery.add(
buildOredTermQuery(languages, IndexFields.DOCUMENT_LANGUAGE), BooleanClause.Occur.MUST);
}
return bQuery;
}
public void testFQ6() throws Exception {
Query q =
new FilteredQuery(
new TermQuery(new Term(FIELD, "xx")),
new QueryWrapperFilter(matchTheseItems(new int[] {1, 3})));
q.setBoost(1000);
qtest(q, new int[] {3});
}
public void testEqualsHashcode() {
Query query = new RangeQuery(new Term("content", "A"), new Term("content", "C"), true);
query.setBoost(1.0f);
Query other = new RangeQuery(new Term("content", "A"), new Term("content", "C"), true);
other.setBoost(1.0f);
assertEquals("query equals itself is true", query, query);
assertEquals("equivalent queries are equal", query, other);
assertEquals(
"hashcode must return same value when equals is true", query.hashCode(), other.hashCode());
other.setBoost(2.0f);
assertFalse("Different boost queries are not equal", query.equals(other));
other = new RangeQuery(new Term("notcontent", "A"), new Term("notcontent", "C"), true);
assertFalse("Different fields are not equal", query.equals(other));
other = new RangeQuery(new Term("content", "X"), new Term("content", "C"), true);
assertFalse("Different lower terms are not equal", query.equals(other));
other = new RangeQuery(new Term("content", "A"), new Term("content", "Z"), true);
assertFalse("Different upper terms are not equal", query.equals(other));
query = new RangeQuery(null, new Term("content", "C"), true);
other = new RangeQuery(null, new Term("content", "C"), true);
assertEquals("equivalent queries with null lowerterms are equal()", query, other);
assertEquals(
"hashcode must return same value when equals is true", query.hashCode(), other.hashCode());
query = new RangeQuery(new Term("content", "C"), null, true);
other = new RangeQuery(new Term("content", "C"), null, true);
assertEquals("equivalent queries with null upperterms are equal()", query, other);
assertEquals("hashcode returns same value", query.hashCode(), other.hashCode());
query = new RangeQuery(null, new Term("content", "C"), true);
other = new RangeQuery(new Term("content", "C"), null, true);
assertFalse("queries with different upper and lower terms are not equal", query.equals(other));
query = new RangeQuery(new Term("content", "A"), new Term("content", "C"), false);
other = new RangeQuery(new Term("content", "A"), new Term("content", "C"), true);
assertFalse("queries with different inclusive are not equal", query.equals(other));
}
@Override
public Query rewrite(IndexReader reader) throws IOException {
if (query != null) {
Query rewritten = query.rewrite(reader);
if (rewritten != query) {
rewritten = new ConstantScoreQuery(rewritten);
rewritten.setBoost(this.getBoost());
return rewritten;
}
}
return this;
}
public static JsonObject fromLuceneFilter(Filter luceneFilter) {
if (luceneFilter instanceof QueryWrapperFilter) {
Query query = ((QueryWrapperFilter) luceneFilter).getQuery();
query.setBoost(luceneFilter.getBoost() * query.getBoost());
return fromLuceneQuery(query);
} else if (luceneFilter instanceof DistanceFilter) {
return convertDistanceFilter((DistanceFilter) luceneFilter);
} else if (luceneFilter instanceof SpatialHashFilter) {
return convertSpatialHashFilter((SpatialHashFilter) luceneFilter);
} else if (luceneFilter instanceof CachingWrapperFilter) {
return fromLuceneFilter(((CachingWrapperFilter) luceneFilter).getCachedFilter());
}
throw LOG.cannotTransformLuceneFilterIntoEsQuery(luceneFilter);
}
@Override
public Query rewrite(IndexReader reader) throws IOException {
if (query != null) {
Query rewritten = query.rewrite(reader);
if (rewritten != query) {
rewritten = new ImageFeatureScoreQuery(rewritten);
rewritten.setBoost(this.getBoost());
return rewritten;
}
} else {
assert filter != null;
// Fix outdated usage pattern from Lucene 2.x/early-3.x:
// because ConstantScoreQuery only accepted filters,
// QueryWrapperFilter was used to wrap queries.
if (filter instanceof QueryWrapperFilter) {
final QueryWrapperFilter qwf = (QueryWrapperFilter) filter;
final Query rewritten = new ImageFeatureScoreQuery(qwf.getQuery().rewrite(reader));
rewritten.setBoost(this.getBoost());
return rewritten;
}
}
return this;
}
private static Query createKeywordQuery(
final Analyzer queryAnalyser,
final String keywords,
final Collection<DtField> searchedFieldList,
final Optional<DtField> boostedField)
throws IOException {
if (StringUtil.isEmpty(keywords)) {
return new MatchAllDocsQuery();
}
// -----
final BooleanQuery query = new BooleanQuery();
for (final DtField dtField : searchedFieldList) {
final Query queryWord = createParsedKeywordsQuery(queryAnalyser, dtField.name(), keywords);
if (boostedField.isPresent() && dtField.equals(boostedField.get())) {
queryWord.setBoost(4);
}
query.add(queryWord, BooleanClause.Occur.SHOULD);
}
return query;
}
/**
* Should be called before executing the main query and after all other parameters have been set.
*/
public void preProcess() {
if (query() == null) {
parsedQuery(ParsedQuery.parsedMatchAllQuery());
}
if (queryBoost() != 1.0f) {
parsedQuery(
new ParsedQuery(
new FunctionScoreQuery(query(), new BoostScoreFunction(queryBoost)), parsedQuery()));
}
Filter searchFilter = searchFilter(types());
if (searchFilter != null) {
if (Queries.isConstantMatchAllQuery(query())) {
Query q = new XConstantScoreQuery(searchFilter);
q.setBoost(query().getBoost());
parsedQuery(new ParsedQuery(q, parsedQuery()));
} else {
parsedQuery(new ParsedQuery(new XFilteredQuery(query(), searchFilter), parsedQuery()));
}
}
}
@Override
public Query getQuery(Element e) throws ParserException {
String text = DOMUtils.getText(e);
try {
Query q = null;
if (unSafeParser != null) {
// synchronize on unsafe parser
synchronized (unSafeParser) {
q = unSafeParser.parse(text);
}
} else {
String fieldName = DOMUtils.getAttribute(e, "fieldName", defaultField);
// Create new parser
QueryParser parser = createQueryParser(fieldName, analyzer);
q = parser.parse(text);
}
q.setBoost(DOMUtils.getAttribute(e, "boost", 1.0f));
return q;
} catch (ParseException e1) {
throw new ParserException(e1.getMessage());
}
}
/**
* Should be called before executing the main query and after all other parameters have been set.
*/
@Override
public void preProcess() {
if (!(from() == -1 && size() == -1)) {
// from and size have been set.
int numHits = from() + size();
if (numHits < 0) {
String msg =
"Result window is too large, from + size must be less than or equal to: ["
+ Integer.MAX_VALUE
+ "] but was ["
+ (((long) from()) + ((long) size()))
+ "]";
throw new QueryPhaseExecutionException(this, msg);
}
}
if (query() == null) {
parsedQuery(ParsedQuery.parsedMatchAllQuery());
}
if (queryBoost() != 1.0f) {
parsedQuery(
new ParsedQuery(
new FunctionScoreQuery(query(), new BoostScoreFunction(queryBoost)), parsedQuery()));
}
Query searchFilter = searchFilter(types());
if (searchFilter != null) {
if (Queries.isConstantMatchAllQuery(query())) {
Query q = new ConstantScoreQuery(searchFilter);
q.setBoost(query().getBoost());
parsedQuery(new ParsedQuery(q, parsedQuery()));
} else {
BooleanQuery filtered = new BooleanQuery();
filtered.add(query(), Occur.MUST);
filtered.add(searchFilter, Occur.FILTER);
parsedQuery(new ParsedQuery(filtered, parsedQuery()));
}
}
}
/** {@inheritDoc} */
@Override
public Query query(Options schema) {
if (field == null || field.trim().isEmpty()) {
throw new IllegalArgumentException("Field name required");
}
if (value == null || value.trim().isEmpty()) {
throw new IllegalArgumentException("Field value required");
}
Query query;
Properties properties = schema.getProperties(field);
Properties.Type fieldType = properties != null ? properties.getType() : Properties.Type.text;
if (fieldType.isCharSeq()) {
Term term = new Term(field, value);
query = new RegexpQuery(term);
} else {
String message = String.format("Regexp queries are not supported by %s mapper", fieldType);
throw new UnsupportedOperationException(message);
}
query.setBoost(boost);
return query;
}
/**
* Optimize our representation and our subqueries representations
*
* @param reader the IndexReader we query
* @return an optimized copy of us (which may not be a copy if there is nothing to optimize)
*/
@Override
public Query rewrite(IndexReader reader) throws IOException {
int numDisjunctions = disjuncts.size();
if (numDisjunctions == 1) {
Query singleton = disjuncts.get(0);
Query result = singleton.rewrite(reader);
if (getBoost() != 1.0f) {
if (result == singleton) result = result.clone();
result.setBoost(getBoost() * result.getBoost());
}
return result;
}
DisjunctionMaxQuery clone = null;
for (int i = 0; i < numDisjunctions; i++) {
Query clause = disjuncts.get(i);
Query rewrite = clause.rewrite(reader);
if (rewrite != clause) {
if (clone == null) clone = this.clone();
clone.disjuncts.set(i, rewrite);
}
}
if (clone != null) return clone;
else return this;
}
@Override
protected void setFinalBoost(Query query) {
query.setBoost(boost * query.getBoost());
}
@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.index(), "[range] query malformed, no field to indicate field name");
}
String fieldName = parser.currentName();
token = parser.nextToken();
if (token != XContentParser.Token.START_OBJECT) {
throw new QueryParsingException(
parseContext.index(), "[range] query malformed, after field missing start object");
}
BytesRef from = null;
BytesRef to = null;
boolean includeLower = true;
boolean includeUpper = true;
float boost = 1.0f;
String currentFieldName = null;
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else {
if ("from".equals(currentFieldName)) {
from = parser.bytesOrNull();
} else if ("to".equals(currentFieldName)) {
to = parser.bytesOrNull();
} else if ("include_lower".equals(currentFieldName)
|| "includeLower".equals(currentFieldName)) {
includeLower = parser.booleanValue();
} else if ("include_upper".equals(currentFieldName)
|| "includeUpper".equals(currentFieldName)) {
includeUpper = parser.booleanValue();
} else if ("boost".equals(currentFieldName)) {
boost = parser.floatValue();
} else if ("gt".equals(currentFieldName)) {
from = parser.bytesOrNull();
includeLower = false;
} else if ("gte".equals(currentFieldName) || "ge".equals(currentFieldName)) {
from = parser.bytesOrNull();
includeLower = true;
} else if ("lt".equals(currentFieldName)) {
to = parser.bytesOrNull();
includeUpper = false;
} else if ("lte".equals(currentFieldName) || "le".equals(currentFieldName)) {
to = parser.bytesOrNull();
includeUpper = true;
} else {
throw new QueryParsingException(
parseContext.index(), "[range] query does not support [" + currentFieldName + "]");
}
}
}
// move to the next end object, to close the field name
token = parser.nextToken();
if (token != XContentParser.Token.END_OBJECT) {
throw new QueryParsingException(
parseContext.index(), "[range] query malformed, does not end with an object");
}
Query query = null;
MapperService.SmartNameFieldMappers smartNameFieldMappers =
parseContext.smartFieldMappers(fieldName);
if (smartNameFieldMappers != null) {
if (smartNameFieldMappers.hasMapper()) {
// LUCENE 4 UPGRADE Mapper#rangeQuery should use bytesref as well?
query =
smartNameFieldMappers
.mapper()
.rangeQuery(
from != null ? from.utf8ToString() : null,
to != null ? to.utf8ToString() : null,
includeLower,
includeUpper,
parseContext);
}
}
if (query == null) {
query = new TermRangeQuery(fieldName, from, to, includeLower, includeUpper);
}
query.setBoost(boost);
return wrapSmartNameQuery(query, smartNameFieldMappers, parseContext);
}
/** macro */
protected Query tq(String f, String t, float b) {
Query q = tq(f, t);
q.setBoost(b);
return q;
}
@Override
public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException {
XContentParser parser = parseContext.parser();
Query query = null;
boolean queryFound = false;
Filter filter = null;
boolean filterFound = false;
float boost = 1.0f;
boolean cache = false;
CacheKeyFilter.Key cacheKey = null;
String currentFieldName = null;
XContentParser.Token token;
FilteredQuery.FilterStrategy filterStrategy = XFilteredQuery.CUSTOM_FILTER_STRATEGY;
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if ("query".equals(currentFieldName)) {
queryFound = true;
query = parseContext.parseInnerQuery();
} else if ("filter".equals(currentFieldName)) {
filterFound = true;
filter = parseContext.parseInnerFilter();
} else {
throw new QueryParsingException(
parseContext.index(), "[filtered] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("strategy".equals(currentFieldName)) {
String value = parser.text();
if ("query_first".equals(value) || "queryFirst".equals(value)) {
filterStrategy = FilteredQuery.QUERY_FIRST_FILTER_STRATEGY;
} else if ("random_access_random".equals(value) || "randomAccessAlways".equals(value)) {
filterStrategy = XFilteredQuery.ALWAYS_RANDOM_ACCESS_FILTER_STRATEGY;
} else if ("leap_frog".equals(value) || "leapFrog".equals(value)) {
filterStrategy = FilteredQuery.LEAP_FROG_QUERY_FIRST_STRATEGY;
} else if (value.startsWith("random_access_")) {
int threshold = Integer.parseInt(value.substring("random_access_".length()));
filterStrategy = new XFilteredQuery.CustomRandomAccessFilterStrategy(threshold);
} else if (value.startsWith("randomAccess")) {
int threshold = Integer.parseInt(value.substring("randomAccess".length()));
filterStrategy = new XFilteredQuery.CustomRandomAccessFilterStrategy(threshold);
} else if ("leap_frog_query_first".equals(value) || "leapFrogQueryFirst".equals(value)) {
filterStrategy = FilteredQuery.LEAP_FROG_QUERY_FIRST_STRATEGY;
} else if ("leap_frog_filter_first".equals(value)
|| "leapFrogFilterFirst".equals(value)) {
filterStrategy = FilteredQuery.LEAP_FROG_FILTER_FIRST_STRATEGY;
} else {
throw new QueryParsingException(
parseContext.index(), "[filtered] strategy value not supported [" + value + "]");
}
} else if ("boost".equals(currentFieldName)) {
boost = parser.floatValue();
} else if ("_cache".equals(currentFieldName)) {
cache = parser.booleanValue();
} else if ("_cache_key".equals(currentFieldName) || "_cacheKey".equals(currentFieldName)) {
cacheKey = new CacheKeyFilter.Key(parser.text());
} else {
throw new QueryParsingException(
parseContext.index(), "[filtered] query does not support [" + currentFieldName + "]");
}
}
}
if (!queryFound) {
throw new QueryParsingException(parseContext.index(), "[filtered] requires 'query' element");
}
if (query == null) {
return null;
}
if (filter == null) {
if (!filterFound) {
// we allow for null filter, so it makes compositions on the client side to be simpler
return query;
} else {
// the filter was provided, but returned null, meaning we should discard it, this means no
// matches for this query...
return Queries.NO_MATCH_QUERY;
}
}
if (filter == Queries.MATCH_ALL_FILTER) {
// this is an instance of match all filter, just execute the query
return query;
}
// cache if required
if (cache) {
filter = parseContext.cacheFilter(filter, cacheKey);
}
// if its a match_all query, use constant_score
if (Queries.isConstantMatchAllQuery(query)) {
Query q = new XConstantScoreQuery(filter);
q.setBoost(boost);
return q;
}
XFilteredQuery filteredQuery = new XFilteredQuery(query, filter, filterStrategy);
filteredQuery.setBoost(boost);
return filteredQuery;
}
public void testMA2() throws Exception {
Query q = new MatchAllDocsQuery();
q.setBoost(1000);
qtest(q, new int[] {0, 1, 2, 3});
}
@Override
public Filter parse(QueryParseContext parseContext) throws IOException, QueryParsingException {
XContentParser parser = parseContext.parser();
Query query = null;
Filter filter = null;
float boost = 1.0f;
String scope = null;
String path = null;
boolean cache = false;
String filterName = null;
// we need a late binding filter so we can inject a parent nested filter inner nested queries
NestedQueryParser.LateBindingParentFilter currentParentFilterContext =
NestedQueryParser.parentFilterContext.get();
NestedQueryParser.LateBindingParentFilter usAsParentFilter =
new NestedQueryParser.LateBindingParentFilter();
NestedQueryParser.parentFilterContext.set(usAsParentFilter);
String currentFieldName = null;
XContentParser.Token token;
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if ("query".equals(currentFieldName)) {
query = parseContext.parseInnerQuery();
} else if ("filter".equals(currentFieldName)) {
filter = parseContext.parseInnerFilter();
}
} else if (token.isValue()) {
if ("path".equals(currentFieldName)) {
path = parser.text();
} else if ("boost".equals(currentFieldName)) {
boost = parser.floatValue();
} else if ("_scope".equals(currentFieldName)) {
scope = parser.text();
} else if ("_name".equals(currentFieldName)) {
filterName = parser.text();
} else if ("_cache".equals(currentFieldName)) {
cache = parser.booleanValue();
}
}
}
if (query == null && filter == null) {
throw new QueryParsingException(
parseContext.index(), "[nested] requires either 'query' or 'filter' field");
}
if (path == null) {
throw new QueryParsingException(parseContext.index(), "[nested] requires 'path' field");
}
if (filter != null) {
query = new DeletionAwareConstantScoreQuery(filter);
}
query.setBoost(boost);
MapperService.SmartNameObjectMapper mapper =
parseContext.mapperService().smartNameObjectMapper(path);
if (mapper == null) {
throw new QueryParsingException(
parseContext.index(), "[nested] failed to find nested object under path [" + path + "]");
}
ObjectMapper objectMapper = mapper.mapper();
if (objectMapper == null) {
throw new QueryParsingException(
parseContext.index(), "[nested] failed to find nested object under path [" + path + "]");
}
if (!objectMapper.nested().isNested()) {
throw new QueryParsingException(
parseContext.index(),
"[nested] nested object under path [" + path + "] is not of nested type");
}
Filter childFilter = parseContext.cacheFilter(objectMapper.nestedTypeFilter());
usAsParentFilter.filter = childFilter;
// wrap the child query to only work on the nested path type
query = new FilteredQuery(query, childFilter);
Filter parentFilter = currentParentFilterContext;
if (parentFilter == null) {
parentFilter = NonNestedDocsFilter.INSTANCE;
if (mapper.hasDocMapper()) {
// filter based on the type...
parentFilter = mapper.docMapper().typeFilter();
}
parentFilter = parseContext.cacheFilter(parentFilter);
}
// restore the thread local one...
NestedQueryParser.parentFilterContext.set(currentParentFilterContext);
BlockJoinQuery joinQuery =
new BlockJoinQuery(query, parentFilter, BlockJoinQuery.ScoreMode.None);
if (scope != null) {
SearchContext.current().addNestedQuery(scope, joinQuery);
}
Filter joinFilter = new QueryWrapperFilter(joinQuery);
if (cache) {
joinFilter = parseContext.cacheFilter(joinFilter);
}
if (filterName != null) {
parseContext.addNamedFilter(filterName, joinFilter);
}
return joinFilter;
}
public void setBoost(float boost) {
q.setBoost(boost);
}
@SuppressWarnings("unused")
List<Query> createShouldQueries(Map<Short, Collection<?>> records) throws ParseException {
List<Query> list = new ArrayList<Query>();
// today
Calendar calendar = Calendar.getInstance();
long max = calendar.getTimeInMillis();
calendar.set(Calendar.HOUR, 0);
long min = calendar.getTimeInMillis();
StringBuilder builder = new StringBuilder();
builder.append('[').append(min).append(" TO ").append(max).append(']');
Query timeQuery = timeParser.parse(builder.toString());
timeQuery.setBoost(10.0f);
list.add(timeQuery);
// System.out.println(" boost " + calendar.get(Calendar.DATE) + " : "+
// timeQuery.getBoost());
// yestoday
max = min;
calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - 1);
min = calendar.getTimeInMillis();
builder.setLength(0);
builder.append('[').append(min).append(" TO ").append(max).append(']');
timeQuery = timeParser.parse(builder.toString());
timeQuery.setBoost(8.0f);
list.add(timeQuery);
// System.out.println(" boost " + calendar.get(Calendar.DATE) + " : "+
// timeQuery.getBoost());
max = min;
calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - 1);
min = calendar.getTimeInMillis();
builder.setLength(0);
builder.append('[').append(min).append(" TO ").append(max).append(']');
timeQuery = timeParser.parse(builder.toString());
timeQuery.setBoost(7.0f);
list.add(timeQuery);
// System.out.println(" boost " + calendar.get(Calendar.DATE) + " : "+
// timeQuery.getBoost());
max = min;
calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - 1);
min = calendar.getTimeInMillis();
builder.setLength(0);
builder.append('[').append(min).append(" TO ").append(max).append(']');
timeQuery = timeParser.parse(builder.toString());
timeQuery.setBoost(4.0f);
list.add(timeQuery);
// System.out.println(" boost " + calendar.get(Calendar.DATE) + " : "+
// timeQuery.getBoost());
max = min;
calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - 2);
min = calendar.getTimeInMillis();
builder.setLength(0);
builder.append('[').append(min).append(" TO ").append(max).append(']');
timeQuery = timeParser.parse(builder.toString());
timeQuery.setBoost(2.0f);
list.add(timeQuery);
// System.out.println(" boost " + calendar.get(Calendar.DATE) + " : "+
// timeQuery.getBoost());
// for source time
calendar = Calendar.getInstance();
max = calendar.getTimeInMillis();
calendar.set(Calendar.HOUR, 0);
min = calendar.getTimeInMillis();
builder.setLength(0);
builder.append('[').append(min).append(" TO ").append(max).append(']');
timeQuery = sourceTimeParser.parse(builder.toString());
timeQuery.setBoost(7.0f);
list.add(timeQuery);
// System.out.println(" source time boost " + calendar.get(Calendar.DATE) + " : "+
// timeQuery.getBoost());
calendar = Calendar.getInstance();
max = calendar.getTimeInMillis();
calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - 1);
min = calendar.getTimeInMillis();
builder.setLength(0);
builder.append('[').append(min).append(" TO ").append(max).append(']');
timeQuery = sourceTimeParser.parse(builder.toString());
timeQuery.setBoost(5.0f);
list.add(timeQuery);
// System.out.println(" source time boost " + calendar.get(Calendar.DATE) + " : "+
// timeQuery.getBoost() );
calendar = Calendar.getInstance();
max = calendar.getTimeInMillis();
calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - 1);
min = calendar.getTimeInMillis();
builder.setLength(0);
builder.append('[').append(min).append(" TO ").append(max).append(']');
timeQuery = sourceTimeParser.parse(builder.toString());
timeQuery.setBoost(2.0f);
list.add(timeQuery);
// System.out.println(" source time boost " + calendar.get(Calendar.DATE) + " : "+
// timeQuery.getBoost());
// TermRangeQuery tquery = new TermRangeQuery(
// "time", String.valueOf(min), String.valueOf(max), true, true);
// list.add(tquery);
return list;
}
@Override
public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException {
ensureNotDeleteByQuery(NAME, parseContext);
XContentParser parser = parseContext.parser();
boolean queryFound = false;
float boost = 1.0f;
String childType = null;
ScoreType scoreType = ScoreType.NONE;
int minChildren = 0;
int maxChildren = 0;
int shortCircuitParentDocSet = 8192;
String queryName = null;
Tuple<String, SubSearchContext> innerHits = null;
String currentFieldName = null;
XContentParser.Token token;
XContentStructure.InnerQuery iq = null;
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
// Usually, the query would be parsed here, but the child
// type may not have been extracted yet, so use the
// XContentStructure.<type> facade to parse if available,
// or delay parsing if not.
if ("query".equals(currentFieldName)) {
iq =
new XContentStructure.InnerQuery(
parseContext, childType == null ? null : new String[] {childType});
queryFound = true;
} else if ("inner_hits".equals(currentFieldName)) {
innerHits = innerHitsQueryParserHelper.parse(parseContext);
} else {
throw new QueryParsingException(
parseContext.index(),
"[has_child] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("type".equals(currentFieldName)
|| "child_type".equals(currentFieldName)
|| "childType".equals(currentFieldName)) {
childType = parser.text();
} else if ("score_type".equals(currentFieldName) || "scoreType".equals(currentFieldName)) {
scoreType = ScoreType.fromString(parser.text());
} else if ("score_mode".equals(currentFieldName) || "scoreMode".equals(currentFieldName)) {
scoreType = ScoreType.fromString(parser.text());
} else if ("boost".equals(currentFieldName)) {
boost = parser.floatValue();
} else if ("min_children".equals(currentFieldName)
|| "minChildren".equals(currentFieldName)) {
minChildren = parser.intValue(true);
} else if ("max_children".equals(currentFieldName)
|| "maxChildren".equals(currentFieldName)) {
maxChildren = parser.intValue(true);
} else if ("short_circuit_cutoff".equals(currentFieldName)) {
shortCircuitParentDocSet = parser.intValue();
} else if ("_name".equals(currentFieldName)) {
queryName = parser.text();
} else {
throw new QueryParsingException(
parseContext.index(),
"[has_child] query does not support [" + currentFieldName + "]");
}
}
}
if (!queryFound) {
throw new QueryParsingException(parseContext.index(), "[has_child] requires 'query' field");
}
if (childType == null) {
throw new QueryParsingException(parseContext.index(), "[has_child] requires 'type' field");
}
Query innerQuery = iq.asQuery(childType);
if (innerQuery == null) {
return null;
}
innerQuery.setBoost(boost);
DocumentMapper childDocMapper = parseContext.mapperService().documentMapper(childType);
if (childDocMapper == null) {
throw new QueryParsingException(
parseContext.index(), "[has_child] No mapping for for type [" + childType + "]");
}
if (!childDocMapper.parentFieldMapper().active()) {
throw new QueryParsingException(
parseContext.index(),
"[has_child] Type [" + childType + "] does not have parent mapping");
}
if (innerHits != null) {
InnerHitsContext.ParentChildInnerHits parentChildInnerHits =
new InnerHitsContext.ParentChildInnerHits(
innerHits.v2(), innerQuery, null, childDocMapper);
String name = innerHits.v1() != null ? innerHits.v1() : childType;
parseContext.addInnerHits(name, parentChildInnerHits);
}
ParentFieldMapper parentFieldMapper = childDocMapper.parentFieldMapper();
if (!parentFieldMapper.active()) {
throw new QueryParsingException(
parseContext.index(), "[has_child] _parent field not configured");
}
String parentType = parentFieldMapper.type();
DocumentMapper parentDocMapper = parseContext.mapperService().documentMapper(parentType);
if (parentDocMapper == null) {
throw new QueryParsingException(
parseContext.index(),
"[has_child] Type ["
+ childType
+ "] points to a non existent parent type ["
+ parentType
+ "]");
}
if (maxChildren > 0 && maxChildren < minChildren) {
throw new QueryParsingException(
parseContext.index(), "[has_child] 'max_children' is less than 'min_children'");
}
BitDocIdSetFilter nonNestedDocsFilter = null;
if (parentDocMapper.hasNestedObjects()) {
nonNestedDocsFilter = parseContext.bitsetFilter(NonNestedDocsFilter.INSTANCE);
}
// wrap the query with type query
innerQuery =
new FilteredQuery(
innerQuery,
parseContext.cacheFilter(
childDocMapper.typeFilter(), null, parseContext.autoFilterCachePolicy()));
Query query;
Filter parentFilter =
parseContext.cacheFilter(
parentDocMapper.typeFilter(), null, parseContext.autoFilterCachePolicy());
ParentChildIndexFieldData parentChildIndexFieldData =
parseContext.getForField(parentFieldMapper);
if (minChildren > 1 || maxChildren > 0 || scoreType != ScoreType.NONE) {
query =
new ChildrenQuery(
parentChildIndexFieldData,
parentType,
childType,
parentFilter,
innerQuery,
scoreType,
minChildren,
maxChildren,
shortCircuitParentDocSet,
nonNestedDocsFilter);
} else {
query =
new ChildrenConstantScoreQuery(
parentChildIndexFieldData,
innerQuery,
parentType,
childType,
parentFilter,
shortCircuitParentDocSet,
nonNestedDocsFilter);
}
if (queryName != null) {
parseContext.addNamedFilter(queryName, new CustomQueryWrappingFilter(query));
}
query.setBoost(boost);
return query;
}
private void _includeIfUnique(
BooleanQuery booleanQuery,
boolean like,
QueryParser queryParser,
Query query,
BooleanClause.Occur occur) {
if (query instanceof TermQuery) {
Set<Term> terms = new HashSet<Term>();
TermQuery termQuery = (TermQuery) query;
termQuery.extractTerms(terms);
float boost = termQuery.getBoost();
for (Term term : terms) {
String termValue = term.text();
if (like) {
termValue = termValue.toLowerCase(queryParser.getLocale());
term = term.createTerm(StringPool.STAR.concat(termValue).concat(StringPool.STAR));
query = new WildcardQuery(term);
} else {
query = new TermQuery(term);
}
query.setBoost(boost);
boolean included = false;
for (BooleanClause booleanClause : booleanQuery.getClauses()) {
if (query.equals(booleanClause.getQuery())) {
included = true;
}
}
if (!included) {
booleanQuery.add(query, occur);
}
}
} else if (query instanceof BooleanQuery) {
BooleanQuery curBooleanQuery = (BooleanQuery) query;
BooleanQuery containerBooleanQuery = new BooleanQuery();
for (BooleanClause booleanClause : curBooleanQuery.getClauses()) {
_includeIfUnique(
containerBooleanQuery,
like,
queryParser,
booleanClause.getQuery(),
booleanClause.getOccur());
}
if (containerBooleanQuery.getClauses().length > 0) {
booleanQuery.add(containerBooleanQuery, occur);
}
} else {
boolean included = false;
for (BooleanClause booleanClause : booleanQuery.getClauses()) {
if (query.equals(booleanClause.getQuery())) {
included = true;
}
}
if (!included) {
booleanQuery.add(query, occur);
}
}
}
@Override
public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException {
XContentParser parser = parseContext.parser();
Query query = Queries.newMatchAllQuery();
Filter filter = null;
boolean filterFound = false;
float boost = 1.0f;
FilterCachingPolicy cache = parseContext.autoFilterCachePolicy();
HashedBytesRef cacheKey = null;
String queryName = null;
String currentFieldName = null;
XContentParser.Token token;
FilteredQuery.FilterStrategy filterStrategy = CUSTOM_FILTER_STRATEGY;
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
if ("query".equals(currentFieldName)) {
query = parseContext.parseInnerQuery();
} else if ("filter".equals(currentFieldName)) {
filterFound = true;
filter = parseContext.parseInnerFilter();
} else {
throw new QueryParsingException(
parseContext.index(), "[filtered] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("strategy".equals(currentFieldName)) {
String value = parser.text();
if ("query_first".equals(value) || "queryFirst".equals(value)) {
filterStrategy = FilteredQuery.QUERY_FIRST_FILTER_STRATEGY;
} else if ("random_access_always".equals(value) || "randomAccessAlways".equals(value)) {
filterStrategy = ALWAYS_RANDOM_ACCESS_FILTER_STRATEGY;
} else if ("leap_frog".equals(value) || "leapFrog".equals(value)) {
filterStrategy = FilteredQuery.LEAP_FROG_QUERY_FIRST_STRATEGY;
} else if (value.startsWith("random_access_")) {
int threshold = Integer.parseInt(value.substring("random_access_".length()));
filterStrategy = new CustomRandomAccessFilterStrategy(threshold);
} else if (value.startsWith("randomAccess")) {
int threshold = Integer.parseInt(value.substring("randomAccess".length()));
filterStrategy = new CustomRandomAccessFilterStrategy(threshold);
} else if ("leap_frog_query_first".equals(value) || "leapFrogQueryFirst".equals(value)) {
filterStrategy = FilteredQuery.LEAP_FROG_QUERY_FIRST_STRATEGY;
} else if ("leap_frog_filter_first".equals(value)
|| "leapFrogFilterFirst".equals(value)) {
filterStrategy = FilteredQuery.LEAP_FROG_FILTER_FIRST_STRATEGY;
} else {
throw new QueryParsingException(
parseContext.index(), "[filtered] strategy value not supported [" + value + "]");
}
} else if ("_name".equals(currentFieldName)) {
queryName = parser.text();
} else if ("boost".equals(currentFieldName)) {
boost = parser.floatValue();
} else if ("_cache".equals(currentFieldName)) {
cache = parseContext.parseFilterCachePolicy();
} else if ("_cache_key".equals(currentFieldName) || "_cacheKey".equals(currentFieldName)) {
cacheKey = new HashedBytesRef(parser.text());
} else {
throw new QueryParsingException(
parseContext.index(), "[filtered] query does not support [" + currentFieldName + "]");
}
}
}
// parsed internally, but returned null during parsing...
if (query == null) {
return null;
}
if (filter == null) {
if (!filterFound) {
// we allow for null filter, so it makes compositions on the client side to be simpler
return query;
} else {
// even if the filter is not found, and its null, we should simply ignore it, and go
// by the query
return query;
}
}
if (filter == Queries.MATCH_ALL_FILTER) {
// this is an instance of match all filter, just execute the query
return query;
}
// cache if required
if (cache != null) {
filter = parseContext.cacheFilter(filter, cacheKey, cache);
}
// if its a match_all query, use constant_score
if (Queries.isConstantMatchAllQuery(query)) {
Query q = new ConstantScoreQuery(filter);
q.setBoost(boost);
return q;
}
FilteredQuery filteredQuery = new FilteredQuery(query, filter, filterStrategy);
filteredQuery.setBoost(boost);
if (queryName != null) {
parseContext.addNamedQuery(queryName, filteredQuery);
}
return filteredQuery;
}
public void testCSQ3() throws Exception {
Query q = new ConstantScoreQuery(new ItemizedFilter(new int[] {0, 2}));
q.setBoost(1000);
qtest(q, new int[] {0, 2});
}
protected Query tq(float boost, String field, String text) {
Query query = new TermQuery(new Term(field, text));
query.setBoost(boost);
return query;
}
@Override
public Query parse(QueryParseContext parseContext) throws IOException, QueryParsingException {
XContentParser parser = parseContext.parser();
boolean queryFound = false;
float boost = 1.0f;
String parentType = null;
boolean score = false;
String queryName = null;
String currentFieldName = null;
XContentParser.Token token;
XContentStructure.InnerQuery iq = null;
while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
if (token == XContentParser.Token.FIELD_NAME) {
currentFieldName = parser.currentName();
} else if (token == XContentParser.Token.START_OBJECT) {
// Usually, the query would be parsed here, but the child
// type may not have been extracted yet, so use the
// XContentStructure.<type> facade to parse if available,
// or delay parsing if not.
if ("query".equals(currentFieldName)) {
iq =
new XContentStructure.InnerQuery(
parseContext, parentType == null ? null : new String[] {parentType});
queryFound = true;
} else {
throw new QueryParsingException(
parseContext.index(),
"[has_parent] query does not support [" + currentFieldName + "]");
}
} else if (token.isValue()) {
if ("type".equals(currentFieldName)
|| "parent_type".equals(currentFieldName)
|| "parentType".equals(currentFieldName)) {
parentType = parser.text();
} else if ("_scope".equals(currentFieldName)) {
throw new QueryParsingException(
parseContext.index(),
"the [_scope] support in [has_parent] query has been removed, use a filter as a facet_filter in the relevant global facet");
} else if ("score_type".equals(currentFieldName) || "scoreType".equals(currentFieldName)) {
String scoreTypeValue = parser.text();
if ("score".equals(scoreTypeValue)) {
score = true;
} else if ("none".equals(scoreTypeValue)) {
score = false;
}
} else if ("score_mode".equals(currentFieldName) || "scoreMode".equals(currentFieldName)) {
String scoreModeValue = parser.text();
if ("score".equals(scoreModeValue)) {
score = true;
} else if ("none".equals(scoreModeValue)) {
score = false;
}
} else if ("boost".equals(currentFieldName)) {
boost = parser.floatValue();
} else if ("_name".equals(currentFieldName)) {
queryName = parser.text();
} else {
throw new QueryParsingException(
parseContext.index(),
"[has_parent] query does not support [" + currentFieldName + "]");
}
}
}
if (!queryFound) {
throw new QueryParsingException(
parseContext.index(), "[has_parent] query requires 'query' field");
}
if (parentType == null) {
throw new QueryParsingException(
parseContext.index(), "[has_parent] query requires 'parent_type' field");
}
Query innerQuery = iq.asQuery(parentType);
if (innerQuery == null) {
return null;
}
DocumentMapper parentDocMapper = parseContext.mapperService().documentMapper(parentType);
if (parentDocMapper == null) {
throw new QueryParsingException(
parseContext.index(),
"[has_parent] query configured 'parent_type' [" + parentType + "] is not a valid type");
}
innerQuery.setBoost(boost);
// wrap the query with type query
innerQuery =
new XFilteredQuery(
innerQuery, parseContext.cacheFilter(parentDocMapper.typeFilter(), null));
ParentChildIndexFieldData parentChildIndexFieldData = null;
Set<String> parentTypes = new HashSet<>(5);
parentTypes.add(parentType);
for (DocumentMapper documentMapper : parseContext.mapperService()) {
ParentFieldMapper parentFieldMapper = documentMapper.parentFieldMapper();
if (parentFieldMapper.active()) {
parentChildIndexFieldData = parseContext.fieldData().getForField(parentFieldMapper);
DocumentMapper parentTypeDocumentMapper =
parseContext.mapperService().documentMapper(parentFieldMapper.type());
if (parentTypeDocumentMapper == null) {
// Only add this, if this parentFieldMapper (also a parent) isn't a child of another
// parent.
parentTypes.add(parentFieldMapper.type());
}
}
}
if (parentChildIndexFieldData == null) {
throw new QueryParsingException(
parseContext.index(), "[has_parent] no _parent field configured");
}
Filter parentFilter;
if (parentTypes.size() == 1) {
DocumentMapper documentMapper =
parseContext.mapperService().documentMapper(parentTypes.iterator().next());
parentFilter = parseContext.cacheFilter(documentMapper.typeFilter(), null);
} else {
XBooleanFilter parentsFilter = new XBooleanFilter();
for (String parentTypeStr : parentTypes) {
DocumentMapper documentMapper = parseContext.mapperService().documentMapper(parentTypeStr);
Filter filter = parseContext.cacheFilter(documentMapper.typeFilter(), null);
parentsFilter.add(filter, BooleanClause.Occur.SHOULD);
}
parentFilter = parentsFilter;
}
Filter childrenFilter = parseContext.cacheFilter(new NotFilter(parentFilter), null);
boolean deleteByQuery = "delete_by_query".equals(SearchContext.current().source());
Query query;
if (!deleteByQuery && score) {
query = new ParentQuery(parentChildIndexFieldData, innerQuery, parentType, childrenFilter);
} else {
query =
new ParentConstantScoreQuery(
parentChildIndexFieldData, innerQuery, parentType, childrenFilter);
if (deleteByQuery) {
query = new XConstantScoreQuery(new DeleteByQueryWrappingFilter(query));
}
}
query.setBoost(boost);
if (queryName != null) {
parseContext.addNamedFilter(queryName, new CustomQueryWrappingFilter(query));
}
return query;
}
@Override
public Query parse(JsonQueryParseContext parseContext) throws IOException, QueryParsingException {
JsonParser jp = parseContext.jp();
JsonToken token = jp.nextToken();
assert token == JsonToken.FIELD_NAME;
String fieldName = jp.getCurrentName();
String from = null;
String to = null;
boolean includeLower = true;
boolean includeUpper = true;
float boost = 1.0f;
String currentFieldName = null;
while ((token = jp.nextToken()) != JsonToken.END_OBJECT) {
if (token == JsonToken.FIELD_NAME) {
currentFieldName = jp.getCurrentName();
} else {
if ("from".equals(currentFieldName)) {
if (jp.getCurrentToken() == JsonToken.VALUE_NULL) {
from = null;
} else {
from = jp.getText();
}
} else if ("to".equals(currentFieldName)) {
if (jp.getCurrentToken() == JsonToken.VALUE_NULL) {
to = null;
} else {
to = jp.getText();
}
} else if ("include_lower".equals(currentFieldName)) {
if (token == JsonToken.VALUE_NUMBER_INT) {
includeLower = jp.getIntValue() != 0;
} else if (token == JsonToken.VALUE_STRING) {
includeLower = Booleans.parseBoolean(jp.getText(), includeLower);
} else {
includeLower = token == JsonToken.VALUE_TRUE;
}
} else if ("include_upper".equals(currentFieldName)) {
if (token == JsonToken.VALUE_NUMBER_INT) {
includeUpper = jp.getIntValue() != 0;
} else if (token == JsonToken.VALUE_STRING) {
includeUpper = Booleans.parseBoolean(jp.getText(), includeUpper);
} else {
includeUpper = token == JsonToken.VALUE_TRUE;
}
} else if ("boost".equals(currentFieldName)) {
if (token == JsonToken.VALUE_STRING) {
boost = Float.parseFloat(jp.getText());
} else {
boost = jp.getFloatValue();
}
} else if ("gt".equals(currentFieldName)) {
if (jp.getCurrentToken() == JsonToken.VALUE_NULL) {
from = null;
} else {
from = jp.getText();
}
includeLower = false;
} else if ("gte".equals(currentFieldName)) {
if (jp.getCurrentToken() == JsonToken.VALUE_NULL) {
from = null;
} else {
from = jp.getText();
}
includeLower = true;
} else if ("lt".equals(currentFieldName)) {
if (jp.getCurrentToken() == JsonToken.VALUE_NULL) {
to = null;
} else {
to = jp.getText();
}
includeUpper = false;
} else if ("lte".equals(currentFieldName)) {
if (jp.getCurrentToken() == JsonToken.VALUE_NULL) {
to = null;
} else {
to = jp.getText();
}
includeUpper = true;
}
}
}
// move to the next end object, to close the field name
token = jp.nextToken();
assert token == JsonToken.END_OBJECT;
Query query = null;
MapperService.SmartNameFieldMappers smartNameFieldMappers =
parseContext.smartFieldMappers(fieldName);
if (smartNameFieldMappers != null) {
if (smartNameFieldMappers.hasMapper()) {
query = smartNameFieldMappers.mapper().rangeQuery(from, to, includeLower, includeUpper);
}
}
if (query == null) {
query = new TermRangeQuery(fieldName, from, to, includeLower, includeUpper);
}
query.setBoost(boost);
return wrapSmartNameQuery(query, smartNameFieldMappers, parseContext.indexCache());
}
