Example usage for org.apache.lucene.search TermRangeQuery newStringRange

List of usage examples for org.apache.lucene.search TermRangeQuery newStringRange

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.search.*
  5. TermRangeQuery
  6. newStringRange

Introduction

In this page you can find the example usage for org.apache.lucene.search TermRangeQuery newStringRange.

Prototype

public static TermRangeQuery newStringRange(String field, String lowerTerm, String upperTerm,
        boolean includeLower, boolean includeUpper)

Source Link

Document

Factory that creates a new TermRangeQuery using Strings for term text.

Usage

From source file:com.liferay.portal.search.solr.internal.filter.DateRangeTermFilterTranslatorImpl.java

License:Open Source License

@Override
public org.apache.lucene.search.Query translate(DateRangeTermFilter dateRangeTermFilter) {

    TermRangeQuery termRangeQuery = TermRangeQuery.newStringRange(dateRangeTermFilter.getField(),
            dateRangeTermFilter.getLowerBound(), dateRangeTermFilter.getUpperBound(),
            dateRangeTermFilter.isIncludesLower(), dateRangeTermFilter.isIncludesUpper());

    return termRangeQuery;
}

From source file:com.liferay.portal.search.solr.internal.filter.ExistsFilterTranslatorImpl.java

License:Open Source License

@Override
public org.apache.lucene.search.Query translate(ExistsFilter existsFilter) {
    BooleanQuery booleanQuery = new BooleanQuery();

    MatchAllDocsQuery matchAllDocsQuery = new MatchAllDocsQuery();

    booleanQuery.add(matchAllDocsQuery, BooleanClause.Occur.SHOULD);

    TermRangeQuery termRangeQuery = TermRangeQuery.newStringRange(existsFilter.getField(), "*", "*", true,
            true);/*w  w  w  . jav  a  2 s .com*/

    booleanQuery.add(termRangeQuery, BooleanClause.Occur.MUST);

    return booleanQuery;
}

From source file:com.liferay.portal.search.solr.internal.filter.MissingFilterTranslatorImpl.java

License:Open Source License

@Override
public org.apache.lucene.search.Query translate(MissingFilter missingFilter) {

    BooleanQuery booleanQuery = new BooleanQuery();

    MatchAllDocsQuery matchAllDocsQuery = new MatchAllDocsQuery();

    booleanQuery.add(matchAllDocsQuery, BooleanClause.Occur.SHOULD);

    TermRangeQuery termRangeQuery = TermRangeQuery.newStringRange(missingFilter.getField(), "*", "*", true,
            true);//from ww w . ja v  a  2s .c  o  m

    booleanQuery.add(termRangeQuery, BooleanClause.Occur.MUST_NOT);

    return booleanQuery;
}

From source file:com.liferay.portal.search.solr.internal.filter.RangeTermFilterTranslatorImpl.java

License:Open Source License

@Override
public org.apache.lucene.search.Query translate(RangeTermFilter rangeTermFilter) {

    TermRangeQuery termRangeQuery = TermRangeQuery.newStringRange(rangeTermFilter.getField(),
            rangeTermFilter.getLowerBound(), rangeTermFilter.getUpperBound(), rangeTermFilter.isIncludesLower(),
            rangeTermFilter.isIncludesUpper());

    return termRangeQuery;
}

From source file:com.querydsl.lucene4.LuceneSerializer.java

License:Apache License

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);//from  w ww . j a  va 2  s  . c om
    } 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);
    }
}

From source file:com.stratio.cassandra.index.query.RangeCondition.java

License:Apache License

/**
 * {@inheritDoc}/*from   ww w  .j ava  2 s .c om*/
 */
@Override
public Query query(Schema schema) {

    if (field == null || field.trim().isEmpty()) {
        throw new IllegalArgumentException("Field name required");
    }

    ColumnMapper<?> columnMapper = schema.getMapper(field);
    if (columnMapper == null) {
        throw new IllegalArgumentException("Not found mapper for field " + field);
    }
    Class<?> clazz = columnMapper.baseClass();
    Query query;
    if (clazz == String.class) {
        String lower = (String) columnMapper.queryValue(field, this.lower);
        String upper = (String) columnMapper.queryValue(field, this.upper);
        if (lower != null) {
            lower = analyze(field, lower, columnMapper);
        }
        if (upper != null) {
            upper = analyze(field, upper, columnMapper);
        }
        query = TermRangeQuery.newStringRange(field, lower, upper, includeLower, includeUpper);
    } else if (clazz == Integer.class) {
        Integer lower = (Integer) columnMapper.queryValue(field, this.lower);
        Integer upper = (Integer) columnMapper.queryValue(field, this.upper);
        query = NumericRangeQuery.newIntRange(field, lower, upper, includeLower, includeUpper);
    } else if (clazz == Long.class) {
        Long lower = (Long) columnMapper.queryValue(field, this.lower);
        Long upper = (Long) columnMapper.queryValue(field, this.upper);
        query = NumericRangeQuery.newLongRange(field, lower, upper, includeLower, includeUpper);
    } else if (clazz == Float.class) {
        Float lower = (Float) columnMapper.queryValue(field, this.lower);
        Float upper = (Float) columnMapper.queryValue(field, this.upper);
        query = NumericRangeQuery.newFloatRange(field, lower, upper, includeLower, includeUpper);
    } else if (clazz == Double.class) {
        Double lower = (Double) columnMapper.queryValue(field, this.lower);
        Double upper = (Double) columnMapper.queryValue(field, this.upper);
        query = NumericRangeQuery.newDoubleRange(field, lower, upper, includeLower, includeUpper);
    } else {
        String message = String.format("Range queries are not supported by %s mapper", clazz.getSimpleName());
        throw new UnsupportedOperationException(message);
    }
    query.setBoost(boost);
    return query;
}

From source file:com.stratio.cassandra.lucene.search.condition.RangeCondition.java

License:Apache License

/**
 * {@inheritDoc}//from   w w w  . java 2s.c o m
 */
@Override
public Query query(Schema schema) {
    SingleColumnMapper<?> columnMapper = getMapper(schema, field);
    Class<?> clazz = columnMapper.baseClass();
    Query query;
    if (clazz == String.class) {
        String lower = (String) columnMapper.base(field, this.lower);
        String upper = (String) columnMapper.base(field, this.upper);
        query = TermRangeQuery.newStringRange(field, lower, upper, includeLower, includeUpper);
    } else if (clazz == Integer.class) {
        Integer lower = (Integer) columnMapper.base(field, this.lower);
        Integer upper = (Integer) columnMapper.base(field, this.upper);
        query = NumericRangeQuery.newIntRange(field, lower, upper, includeLower, includeUpper);
    } else if (clazz == Long.class) {
        Long lower = (Long) columnMapper.base(field, this.lower);
        Long upper = (Long) columnMapper.base(field, this.upper);
        query = NumericRangeQuery.newLongRange(field, lower, upper, includeLower, includeUpper);
    } else if (clazz == Float.class) {
        Float lower = (Float) columnMapper.base(field, this.lower);
        Float upper = (Float) columnMapper.base(field, this.upper);
        query = NumericRangeQuery.newFloatRange(field, lower, upper, includeLower, includeUpper);
    } else if (clazz == Double.class) {
        Double lower = (Double) columnMapper.base(field, this.lower);
        Double upper = (Double) columnMapper.base(field, this.upper);
        query = NumericRangeQuery.newDoubleRange(field, lower, upper, includeLower, includeUpper);
    } else {
        String message = String.format("Range queries are not supported by %s mapper", clazz.getSimpleName());
        throw new UnsupportedOperationException(message);
    }
    query.setBoost(boost);
    return query;
}

From source file:com.sxc.lucene.searching.TermRangeQueryTest.java

License:Apache License

public void testTermRangeQuery() throws Exception {
    String indexDir = "D:/programming/lucene/indexingTest";
    Directory dir = FSDirectory.open(new File(indexDir));
    IndexReader reader = DirectoryReader.open(dir);
    IndexSearcher searcher = new IndexSearcher(reader);

    TermRangeQuery query = TermRangeQuery.newStringRange("id", "1", "4", true, true);

    TopDocs matches = searcher.search(query, 100);

    assertEquals(2, matches.totalHits);/*w  w w.j av a2s.  c o m*/
    reader.close();
    dir.close();
}

From source file:com.tuplejump.stargate.lucene.query.RangeCondition.java

License:Apache License

/**
 * {@inheritDoc}//  w  w w  .j av  a 2 s . co  m
 */
@Override
public Query query(Options schema) throws Exception {
    Query query;
    if (field == null || field.trim().isEmpty()) {
        throw new IllegalArgumentException("Field name required");
    }
    NumericConfig numericConfig = schema.numericFieldOptions.get(field);

    Properties properties = schema.getProperties(field);
    Properties.Type fieldType = properties != null ? properties.getType() : Properties.Type.text;
    //TODO Range on TimeUUID type
    if (fieldType.isCharSeq()) {
        String lowerVal = null, upperVal = null;
        if (this.lower != null) {
            lowerVal = analyze(field, this.lower.toString(), schema.analyzer);
        }
        if (this.upper != null) {
            upperVal = analyze(field, this.upper.toString(), schema.analyzer);
        }
        query = TermRangeQuery.newStringRange(field, lowerVal, upperVal, includeLower, includeUpper);
    } else if (fieldType == Properties.Type.integer) {
        assert numericConfig != null;
        Integer lower = this.lower == null ? Integer.MIN_VALUE
                : numericConfig.getNumberFormat().parse(this.lower.toString()).intValue();
        Integer upper = this.upper == null ? Integer.MAX_VALUE
                : numericConfig.getNumberFormat().parse(this.upper.toString()).intValue();
        query = NumericRangeQuery.newIntRange(field, lower, upper, includeLower, includeUpper);
    } else if (fieldType == Properties.Type.bigint) {
        assert numericConfig != null;
        Long lower = this.lower == null ? Long.MIN_VALUE
                : numericConfig.getNumberFormat().parse(this.lower.toString()).longValue();
        Long upper = this.upper == null ? Long.MAX_VALUE
                : numericConfig.getNumberFormat().parse(this.upper.toString()).longValue();
        query = NumericRangeQuery.newLongRange(field, lower, upper, includeLower, includeUpper);
    } else if (fieldType == Properties.Type.decimal) {
        assert numericConfig != null;
        Float lower = this.lower == null ? Float.MIN_VALUE
                : numericConfig.getNumberFormat().parse(this.lower.toString()).floatValue();
        Float upper = this.upper == null ? Float.MAX_VALUE
                : numericConfig.getNumberFormat().parse(this.upper.toString()).floatValue();
        query = NumericRangeQuery.newFloatRange(field, lower, upper, includeLower, includeUpper);
    } else if (fieldType == Properties.Type.bigdecimal) {
        assert numericConfig != null;
        Double lower = this.lower == null ? Double.MIN_VALUE
                : numericConfig.getNumberFormat().parse(this.lower.toString()).doubleValue();
        Double upper = this.upper == null ? Double.MAX_VALUE
                : numericConfig.getNumberFormat().parse(this.upper.toString()).doubleValue();
        query = NumericRangeQuery.newDoubleRange(field, lower, upper, includeLower, includeUpper);
    } else if (fieldType == Properties.Type.date) {
        Long lower;
        Long upper;
        if ("millis".equals(format)) {
            lower = this.lower == null ? Long.MIN_VALUE : Long.valueOf(this.lower.toString());
            upper = this.upper == null ? Long.MAX_VALUE : Long.valueOf(this.upper.toString());
        } else {
            FormatDateTimeFormatter formatter = Dates.forPattern(format, Locale.getDefault());
            DateTimeFormatter parser = formatter.parser();
            lower = this.lower == null ? Long.MIN_VALUE : parser.parseMillis(this.lower.toString());
            upper = this.upper == null ? Long.MAX_VALUE : parser.parseMillis(this.upper.toString());
        }
        query = NumericRangeQuery.newLongRange(field, lower, upper, includeLower, includeUpper);
    } else {
        String message = String.format("Range queries are not supported by %s mapper", fieldType);
        throw new UnsupportedOperationException(message);
    }
    query.setBoost(boost);
    return query;
}

From source file:org.apache.cxf.jaxrs.ext.search.lucene.LuceneQueryVisitor.java

License:Apache License

private Query createRangeQuery(Class<?> cls, String name, Object value, ConditionType type) {

    boolean minInclusive = type == ConditionType.GREATER_OR_EQUALS || type == ConditionType.EQUALS;
    boolean maxInclusive = type == ConditionType.LESS_OR_EQUALS || type == ConditionType.EQUALS;

    if (String.class.isAssignableFrom(cls) || Number.class.isAssignableFrom(cls)) {
        Query query = null;/*from   w  w  w  .  java2 s .  com*/

        if (Double.class.isAssignableFrom(cls)) {
            query = createDoubleRangeQuery(name, value, type, minInclusive, maxInclusive);
        } else if (Float.class.isAssignableFrom(cls)) {
            query = createFloatRangeQuery(name, value, type, minInclusive, maxInclusive);
        } else if (Long.class.isAssignableFrom(cls)) {
            query = createLongRangeQuery(name, value, type, minInclusive, maxInclusive);
        } else {
            query = createIntRangeQuery(name, value, type, minInclusive, maxInclusive);
        }

        return query;
    } else if (Date.class.isAssignableFrom(cls)) {
        final Date date = getValue(Date.class, getFieldTypeConverter(), value.toString());
        final String luceneDateValue = getString(Date.class, getFieldTypeConverter(), date);

        if (type == ConditionType.LESS_THAN || type == ConditionType.LESS_OR_EQUALS) {
            return TermRangeQuery.newStringRange(name, null, luceneDateValue, minInclusive, maxInclusive);
        } else {
            return TermRangeQuery.newStringRange(name, luceneDateValue,
                    DateTools.dateToString(new Date(), Resolution.MILLISECOND), minInclusive, maxInclusive);
        }
    } else {
        return null;
    }
}