/** * Create a query for matching a bounding box using doc values. * This query is usually slow as it does not use an index structure and needs * to verify documents one-by-one in order to know whether they match. It is * best used wrapped in an {@link IndexOrDocValuesQuery} alongside a * {@link LatLonPoint#newBoxQuery}. */ public static Query newSlowBoxQuery(String field, double minLatitude, double maxLatitude, double minLongitude, double maxLongitude) { // exact double values of lat=90.0D and lon=180.0D must be treated special as they are not represented in the encoding // and should not drag in extra bogus junk! TODO: should encodeCeil just throw ArithmeticException to be less trappy here? if (minLatitude == 90.0) { // range cannot match as 90.0 can never exist return new MatchNoDocsQuery("LatLonDocValuesField.newBoxQuery with minLatitude=90.0"); } if (minLongitude == 180.0) { if (maxLongitude == 180.0) { // range cannot match as 180.0 can never exist return new MatchNoDocsQuery("LatLonDocValuesField.newBoxQuery with minLongitude=maxLongitude=180.0"); } else if (maxLongitude < minLongitude) { // encodeCeil() with dateline wrapping! minLongitude = -180.0; } } return new LatLonDocValuesBoxQuery(field, minLatitude, maxLatitude, minLongitude, maxLongitude); }
@Override public Query rewrite(IndexReader reader) throws IOException { if (terms.length == 0) { return new MatchNoDocsQuery("empty PhraseQuery"); } else if (terms.length == 1) { return new TermQuery(terms[0]); } else if (positions[0] != 0) { int[] newPositions = new int[positions.length]; for (int i = 0; i < positions.length; ++i) { newPositions[i] = positions[i] - positions[0]; } return new PhraseQuery(slop, terms, newPositions); } else { return super.rewrite(reader); } }
return new MatchNoDocsQuery("empty BinaryPoint.newSetQuery");
@Override public Query rewrite(IndexReader reader) throws IOException { if (termArrays.length == 0) { return new MatchNoDocsQuery("empty MultiPhraseQuery"); } else if (termArrays.length == 1) { // optimize one-term case Term[] terms = termArrays[0]; BooleanQuery.Builder builder = new BooleanQuery.Builder(); for (Term term : terms) { builder.add(new TermQuery(term), BooleanClause.Occur.SHOULD); } return builder.build(); } else { return super.rewrite(reader); } }
@Override public Query rewrite(IndexReader reader) throws IOException { if (clauses.size() == 0) { return new MatchNoDocsQuery("empty BooleanQuery"); case MUST_NOT: return new MatchNoDocsQuery("pure negative BooleanQuery"); default: throw new AssertionError(); final Predicate<Query> p = clauseSets.get(Occur.MUST)::contains; if (mustNotClauses.stream().anyMatch(p.or(clauseSets.get(Occur.FILTER)::contains))) { return new MatchNoDocsQuery("FILTER or MUST clause also in MUST_NOT"); return new MatchNoDocsQuery("MUST_NOT clause is MatchAllDocsQuery");
/** Return a query that matches no document. */ public static Query newMatchNoDocsQuery(String reason) { return new MatchNoDocsQuery(reason); }
return new MatchNoDocsQuery("LatLonPoint.newBoxQuery with minLatitude=90.0"); return new MatchNoDocsQuery("LatLonPoint.newBoxQuery with minLongitude=maxLongitude=180.0"); } else if (maxLongitude < minLongitude) {
@Override protected Query doToQuery(QueryShardContext context) throws IOException { //LUCENE 4 UPGRADE document mapper should use bytesref as well? DocumentMapper documentMapper = context.getMapperService().documentMapper(type); if (documentMapper == null) { // no type means no documents return new MatchNoDocsQuery(); } else { return documentMapper.typeFilter(context); } }
private Query existsQuery(String fieldName) { final FieldNamesFieldMapper.FieldNamesFieldType fieldNamesFieldType = (FieldNamesFieldMapper.FieldNamesFieldType) context.getMapperService().fullName(FieldNamesFieldMapper.NAME); if (fieldNamesFieldType == null) { return new MatchNoDocsQuery("No mappings yet"); } if (fieldNamesFieldType.isEnabled() == false) { // The field_names_field is disabled so we switch to a wildcard query that matches all terms return new WildcardQuery(new Term(fieldName, "*")); } return ExistsQueryBuilder.newFilter(context, fieldName); }
@Override protected Query doToQuery(QueryShardContext context) throws IOException { MappedFieldType fieldType = context.fieldMapper(fieldName); if (fieldType == null) { return new MatchNoDocsQuery("unknown field [" + fieldName + "]"); } MultiTermQuery.RewriteMethod method = QueryParsers.parseRewriteMethod( rewrite, null, LoggingDeprecationHandler.INSTANCE); return fieldType.wildcardQuery(value, method, context); }
groups.get(actualAnalyzer).add(new FieldAndFieldType(fieldType, boost)); } else { queries.add(new MatchNoDocsQuery("unknown field " + name));
@Override public Query rangeQuery(Object lowerTerm, Object upperTerm, boolean includeLower, boolean includeUpper, QueryShardContext context) { long l = Long.MIN_VALUE; long u = Long.MAX_VALUE; if (lowerTerm != null) { l = parse(lowerTerm); if (includeLower == false) { if (l == Long.MAX_VALUE) { return new MatchNoDocsQuery(); } ++l; } } if (upperTerm != null) { u = parse(upperTerm); if (includeUpper == false) { if (u == Long.MIN_VALUE) { return new MatchNoDocsQuery(); } --u; } } return LongPoint.newRangeQuery(name(), l, u); }
Collection<String> indexTypes = context.getMapperService().types(); if (indexTypes.isEmpty()) { return new MatchNoDocsQuery("No types"); return new MatchNoDocsQuery("Type list does not contain the index type");
@Override protected Query doToQuery(QueryShardContext context) throws IOException { Query query; MappedFieldType uidField = context.fieldMapper(UidFieldMapper.NAME); if (uidField == null) { return new MatchNoDocsQuery("No mappings"); } if (this.ids.isEmpty()) { query = Queries.newMatchNoDocsQuery("Missing ids in \"" + this.getName() + "\" query."); } else { Collection<String> typesForQuery; if (types.length == 0) { typesForQuery = context.queryTypes(); } else if (types.length == 1 && MetaData.ALL.equals(types[0])) { typesForQuery = context.getMapperService().types(); } else { typesForQuery = new HashSet<>(); Collections.addAll(typesForQuery, types); } query = uidField.termsQuery(Arrays.asList(Uid.createUidsForTypesAndIds(typesForQuery, ids)), context); } return query; }
return new MatchNoDocsQuery("No types");
@Override public Query rangeQuery(Object lowerTerm, Object upperTerm, boolean includeLower, boolean includeUpper, QueryShardContext context) { failIfNotIndexed(); InetAddress lower; if (lowerTerm == null) { lower = InetAddressPoint.MIN_VALUE; } else { lower = parse(lowerTerm); if (includeLower == false) { if (lower.equals(InetAddressPoint.MAX_VALUE)) { return new MatchNoDocsQuery(); } lower = InetAddressPoint.nextUp(lower); } } InetAddress upper; if (upperTerm == null) { upper = InetAddressPoint.MAX_VALUE; } else { upper = parse(upperTerm); if (includeUpper == false) { if (upper.equals(InetAddressPoint.MIN_VALUE)) { return new MatchNoDocsQuery(); } upper = InetAddressPoint.nextDown(upper); } } return InetAddressPoint.newRangeQuery(name(), lower, upper); }
int comp = indexedValueForSearch(lowerTerm).compareTo(typeBytes); if (comp > 0 || (comp == 0 && includeLower == false)) { result = new MatchNoDocsQuery("[_type] was lexicographically smaller than lower bound of range"); int comp = indexedValueForSearch(upperTerm).compareTo(typeBytes); if (comp < 0 || (comp == 0 && includeUpper == false)) { result = new MatchNoDocsQuery("[_type] was lexicographically greater than upper bound of range"); return new MatchNoDocsQuery();
return new MatchNoDocsQuery();
(FieldNamesFieldMapper.FieldNamesFieldType) context.getMapperService().fullName(FieldNamesFieldMapper.NAME); if (fieldNamesFieldType == null) { return new MatchNoDocsQuery("No mappings yet");
@Override protected Query doToQuery(QueryShardContext shardContext) throws IOException { MappedFieldType fieldType = shardContext.fieldMapper(fieldName); if (fieldType == null) { if (ignoreUnmapped) { return new MatchNoDocsQuery(); } else { throw new QueryShardException(shardContext, "failed to find geo_point field [" + fieldName + "]"); } } if (!(fieldType instanceof GeoPointFieldType)) { throw new QueryShardException(shardContext, "field [" + fieldName + "] is not a geo_point field"); } QueryValidationException exception = checkLatLon(); if (exception != null) { throw new QueryShardException(shardContext, "couldn't validate latitude/ longitude values", exception); } if (GeoValidationMethod.isCoerce(validationMethod)) { GeoUtils.normalizePoint(center, true, true); } Query query = LatLonPoint.newDistanceQuery(fieldType.name(), center.lat(), center.lon(), this.distance); if (fieldType.hasDocValues()) { Query dvQuery = LatLonDocValuesField.newSlowDistanceQuery(fieldType.name(), center.lat(), center.lon(), this.distance); query = new IndexOrDocValuesQuery(query, dvQuery); } return query; }