protected Query stringRange(Path<?> leftHandSide, String field, @Nullable Expression<?> min, @Nullable Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata) { if (min == null) { return TermRangeQuery.newStringRange(field, null, convert(leftHandSide, max, metadata)[0], minInc, maxInc); } else if (max == null) { return TermRangeQuery.newStringRange(field, convert(leftHandSide, min, metadata)[0], null, minInc, maxInc); } else { return TermRangeQuery.newStringRange(field, convert(leftHandSide, min, metadata)[0], convert(leftHandSide, max, metadata)[0], minInc, maxInc); } }
protected Query stringRange( Path<?> leftHandSide, String field, @Nullable Expression<?> min, @Nullable Expression<?> max, boolean minInc, boolean maxInc, QueryMetadata metadata) { if (min == null) { return TermRangeQuery.newStringRange( field, null, convert(leftHandSide, max, metadata)[0], minInc, maxInc); } else if (max == null) { return TermRangeQuery.newStringRange( field, convert(leftHandSide, min, metadata)[0], null, minInc, maxInc); } else { return TermRangeQuery.newStringRange( field, convert(leftHandSide, min, metadata)[0], convert(leftHandSide, max, metadata)[0], minInc, maxInc); } }
public static Query newRangeSeekByStringQuery( String lower, boolean includeLower, String upper, boolean includeUpper ) { boolean includeLowerBoundary = StringUtils.EMPTY.equals( lower ) || includeLower; boolean includeUpperBoundary = StringUtils.EMPTY.equals( upper ) || includeUpper; TermRangeQuery termRangeQuery = TermRangeQuery.newStringRange( ValueEncoding.String.key( 0 ), lower, upper, includeLowerBoundary, includeUpperBoundary ); if ( (includeLowerBoundary != includeLower) || (includeUpperBoundary != includeUpper) ) { BooleanQuery.Builder builder = new BooleanQuery.Builder(); builder.setDisableCoord(true); if ( includeLowerBoundary != includeLower ) { builder.add( new TermQuery( new Term( ValueEncoding.String.key( 0 ), lower ) ), BooleanClause.Occur.MUST_NOT ); } if ( includeUpperBoundary != includeUpper ) { builder.add( new TermQuery( new Term( ValueEncoding.String.key( 0 ), upper ) ), BooleanClause.Occur.MUST_NOT ); } builder.add( termRangeQuery, BooleanClause.Occur.FILTER ); return new ConstantScoreQuery( builder.build() ); } return termRangeQuery; }
@Override public Query toRangeQuery(final String name, final String lower, final String upper, final boolean lowerInclusive, final boolean upperInclusive) { return TermRangeQuery.newStringRange(name, lower, upper, lowerInclusive, upperInclusive); }
public static Query getPKRangeDeleteQuery(String startPK, String endPK) { return TermRangeQuery.newStringRange(PK_INDEXED, startPK, endPK, true, true); }
/** * Generates the <code>Query</code> object corresponding to a numeric range search query. * * Returns a <code>NumericRangeQuery</code> based on the values in this object. * * @return a <code>NumericRangeQuery</code> or <code>null</code> if empty. */ @Override public Query toQuery() { if (this._min == null && this._max == null) return null; if (this._query == null) { this._query = TermRangeQuery.newStringRange(this._field, this._min, this._max, this._minInclusive, this._maxInclusive); } return this._query; }
@Override Query query(String field, String value) { List<String> terms = toStreamFromDelimitedValue.apply(value).map(lettersNumbersTrimLowerCase).collect(Collectors.toList()); String lower = terms.get(0); String upper = terms.get(1); return TermRangeQuery.newStringRange(field, lower, upper, true, true); } },
@Override Query query(String field, String value) { List<String> terms = toStreamFromDelimitedValue.apply(value).map(lettersNumbersTrimLowerCase).collect(Collectors.toList()); String lower = (terms.get(0).equals(UNBOUNDED)) ? null : terms.get(0); String upper = (terms.get(1).equals(UNBOUNDED)) ? null : terms.get(1); boolean included = Boolean.valueOf(terms.get(2)); boolean includeUpper = lower == null && included; boolean includeLower = upper == null && included; return TermRangeQuery.newStringRange(field, lower, upper, includeLower, includeUpper); } },
@Override public TermRangeQuery getQuery(Element e) throws ParserException { String fieldName = DOMUtils.getAttributeWithInheritance(e, "fieldName"); String lowerTerm = e.hasAttribute ("lowerTerm") ? e.getAttribute("lowerTerm") : null; String upperTerm = e.hasAttribute("upperTerm") ? e.getAttribute("upperTerm") : null; boolean includeLower = DOMUtils.getAttribute(e, "includeLower", true); boolean includeUpper = DOMUtils.getAttribute(e, "includeUpper", true); return TermRangeQuery.newStringRange(fieldName, lowerTerm, upperTerm, includeLower, includeUpper); }
private Query createQuery(Date startOfRange, Date endOfRange) { // leave the range query open ended if no date is specified. String lower = (startOfRange != null) ? LuceneUtils.dateToString(startOfRange) : null; String upper = (endOfRange != null) ? LuceneUtils.dateToString(endOfRange) : null; return TermRangeQuery.newStringRange(field, lower, upper, true, true); } }
@Override final public MultiTermQuery getQuery(final QueryContext queryContext) { return org.apache.lucene.search.TermRangeQuery.newStringRange(resolveField(queryContext.getFieldMap()), lower_term, upper_term, include_lower == null ? true : include_lower, include_upper == null ? true : include_upper); } }
@Override protected Query newRangeQuery(String field, String part1, String part2, boolean startInclusive, boolean endInclusive) { if (isPass2ResolvingPhrases) { // Must use old-style RangeQuery in order to produce a BooleanQuery // that can be turned into SpanOr clause TermRangeQuery rangeQuery = TermRangeQuery.newStringRange(field, part1, part2, startInclusive, endInclusive); rangeQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE); return rangeQuery; } return super.newRangeQuery(field, part1, part2, startInclusive, endInclusive); }
@Override public Query getQuery(Element e) throws ParserException { String fieldName = DOMUtils.getAttributeWithInheritance(e, "fieldName"); String lowerTerm = e.getAttribute("lowerTerm"); String upperTerm = e.getAttribute("upperTerm"); boolean includeLower = DOMUtils.getAttribute(e, "includeLower", true); boolean includeUpper = DOMUtils.getAttribute(e, "includeUpper", true); return TermRangeQuery.newStringRange(fieldName, lowerTerm, upperTerm, includeLower, includeUpper); }
@Override public Query getQuery(Element e) throws ParserException { String fieldName = DOMUtils.getAttributeWithInheritance(e, "fieldName"); String lowerTerm = e.getAttribute("lowerTerm"); String upperTerm = e.getAttribute("upperTerm"); boolean includeLower = DOMUtils.getAttribute(e, "includeLower", true); boolean includeUpper = DOMUtils.getAttribute(e, "includeUpper", true); return TermRangeQuery.newStringRange(fieldName, lowerTerm, upperTerm, includeLower, includeUpper); }
@Override protected Query newRangeQuery(String field, String part1, String part2, boolean startInclusive, boolean endInclusive) { if (isPass2ResolvingPhrases) { // Must use old-style RangeQuery in order to produce a BooleanQuery // that can be turned into SpanOr clause TermRangeQuery rangeQuery = TermRangeQuery.newStringRange(field, part1, part2, startInclusive, endInclusive); rangeQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE); return rangeQuery; } return super.newRangeQuery(field, part1, part2, startInclusive, endInclusive); }
@Override protected Query doBuild(LuceneSearchPredicateContext context) { // Note that a range query only makes sense if only one token is returned by the analyzer // and we should even consider forcing having a normalizer here, instead of supporting // range queries on analyzed fields. return TermRangeQuery.newStringRange( absoluteFieldPath, codec.normalize( absoluteFieldPath, lowerLimit ), codec.normalize( absoluteFieldPath, upperLimit ), // we force the true value if the limit is null because of some Lucene checks down the hill lowerLimit == null ? true : !excludeLowerLimit, upperLimit == null ? true : !excludeUpperLimit ); } }
private Query query(String start, String stop) { return docValues ? DocValuesRangeQuery.newBytesRefRange(field, docValue(start), docValue(stop), includeLower, includeUpper) : TermRangeQuery.newStringRange(field, start, stop, includeLower, includeUpper); }
@Test public void testExtractFieldNameFromTermRangeQuery() { TermRangeQuery query = TermRangeQuery.newStringRange( "stringField", "A", "Z", true, true ); assertFieldNames( query, FieldType.STRING, "stringField" ); }
private Query toRangeQuery(RangeTerm range) { return TermRangeQuery.newStringRange( range.getField(), range.hasMin() ? range.getMin() : null, range.hasMax() ? range.getMax() : null, range.getMinInclusive(), range.getMaxInclusive()); }
@Test @TestForIssue(jiraKey = "HSEARCH-997") public void testByteDocumentIdMappedAsStringFieldByDefault() { Query query = TermRangeQuery.newStringRange( "id", "1", "1", true, true ); helper.assertThat( query ).from( Position.class ) .matchesExactlyIds( (byte) 1 ); }