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

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

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

Introduction

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

Prototype

public boolean includesLower()

Source Link

Document

Returns true if the lower endpoint is inclusive

Usage

From source file:bbejeck.nosql.lucene.LuceneQueryParsingTest.java

License:Apache License

@Test
public void test_greater_than_term() {
    String query = "Select foo from '/index/path/' where age > '49'";
    BooleanQuery booleanQuery = parseQuery(query);
    BooleanClause[] clauses = booleanQuery.getClauses();
    assertThat(clauses[0].getQuery().getClass().getSimpleName(), is("TermRangeQuery"));
    TermRangeQuery termRangeQuery = (TermRangeQuery) clauses[0].getQuery();
    assertThat(termRangeQuery.getLowerTerm().utf8ToString(), is("49"));
    assertThat(termRangeQuery.getUpperTerm(), is(nullValue()));
    assertThat(termRangeQuery.includesLower(), is(false));
}

From source file:bbejeck.nosql.lucene.LuceneQueryParsingTest.java

License:Apache License

@Test
public void test_greater_than_equals_term() {
    String query = "Select foo from '/index/path/' where age >= '49'";
    BooleanQuery booleanQuery = parseQuery(query);
    BooleanClause[] clauses = booleanQuery.getClauses();
    assertThat(clauses[0].getQuery().getClass().getSimpleName(), is("TermRangeQuery"));
    TermRangeQuery termRangeQuery = (TermRangeQuery) clauses[0].getQuery();
    assertThat(termRangeQuery.getLowerTerm().utf8ToString(), is("49"));
    assertThat(termRangeQuery.getUpperTerm(), is(nullValue()));
    assertThat(termRangeQuery.includesLower(), is(true));
}

From source file:bbejeck.nosql.lucene.LuceneQueryParsingTest.java

License:Apache License

@Test
public void test_greater_than_equals_date() {
    String query = "Select foo from '/index/path/' where date >= 2015/03/18";
    BooleanQuery booleanQuery = parseQuery(query);
    BooleanClause[] clauses = booleanQuery.getClauses();
    assertThat(clauses[0].getQuery().getClass().getSimpleName(), is("TermRangeQuery"));
    TermRangeQuery termRangeQuery = (TermRangeQuery) clauses[0].getQuery();
    assertThat(termRangeQuery.getLowerTerm().utf8ToString(), is("20150318"));
    assertThat(termRangeQuery.getUpperTerm(), is(nullValue()));
    assertThat(termRangeQuery.includesLower(), is(true));
}

From source file:bbejeck.nosql.lucene.LuceneQueryParsingTest.java

License:Apache License

@Test
public void test_greater_than_equals_date_dash_separators() {
    String query = "Select foo from '/index/path/' where date >= 2015-03-18";
    BooleanQuery booleanQuery = parseQuery(query);
    BooleanClause[] clauses = booleanQuery.getClauses();
    assertThat(clauses[0].getQuery().getClass().getSimpleName(), is("TermRangeQuery"));
    TermRangeQuery termRangeQuery = (TermRangeQuery) clauses[0].getQuery();
    assertThat(termRangeQuery.getLowerTerm().utf8ToString(), is("20150318"));
    assertThat(termRangeQuery.getUpperTerm(), is(nullValue()));
    assertThat(termRangeQuery.includesLower(), is(true));
}

From source file:de.unioninvestment.eai.portal.portlet.crud.domain.model.CompoundSearch.java

License:Apache License

private Filter convertTermRangeQuery(Table table, TermRangeQuery termRangeQuery) {
    String columnName = caseCorrectedFieldName(termRangeQuery.getField());
    Class<?> columnType = table.getContainer().getType(columnName);
    if (columnType == null) {
        return null;
    }/*from ww  w  .ja va2s.co  m*/

    String lowerText = termRangeQuery.getLowerTerm().utf8ToString();
    String upperText = termRangeQuery.getUpperTerm().utf8ToString();
    Filter lowerFilter;
    Filter upperFilter;

    if (Number.class.isAssignableFrom(columnType)) {
        Number lowerNumber = convertTextToNumber(table, columnName, columnType, lowerText);
        lowerFilter = new Greater(columnName, lowerNumber, termRangeQuery.includesLower());

        Number upperNumber = convertTextToNumber(table, columnName, columnType, upperText);
        upperFilter = new Less(columnName, upperNumber, termRangeQuery.includesUpper());
    } else if (Date.class.isAssignableFrom(columnType)) {
        Date lowerDate = convertTextToDate(columnName, lowerText, dateFormats, !termRangeQuery.includesLower());
        lowerFilter = new Greater(columnName, DateUtils.adjustDateType(lowerDate, columnType), true);
        Date upperDate = convertTextToDate(columnName, upperText, dateFormats, termRangeQuery.includesUpper());
        upperFilter = new Less(columnName, DateUtils.adjustDateType(upperDate, columnType), false);

    } else { /* String */
        lowerFilter = new Greater(columnName, lowerText, termRangeQuery.includesLower());
        upperFilter = new Less(columnName, upperText, termRangeQuery.includesUpper());
    }
    return new All(asList(lowerFilter, upperFilter));
}

From source file:lia.common.NumericDateRangeQueryParser.java

License:Apache License

public Query getRangeQuery(String field, String part1, String part2, boolean inclusive) throws ParseException {
    TermRangeQuery query = (TermRangeQuery) super.getRangeQuery(field, part1, part2, inclusive, true);

    if ("pubmonth".equals(field)) {
        return LegacyNumericRangeQuery.newIntRange("pubmonth", Integer.parseInt("1"), Integer.parseInt("10"),
                query.includesLower(), query.includesUpper());
    } else {// ww w . j  ava 2  s.c o m
        return query;
    }
}

From source file:org.apache.atlas.catalog.query.TermRangeQueryExpression.java

License:Apache License

public TermRangeQueryExpression(TermRangeQuery query, ResourceDefinition resourceDefinition) {
    super(query.getField(), null, resourceDefinition);
    m_lowerTerm = query.getLowerTerm();//from ww w.j a v a 2  s .com
    m_upperTerm = query.getUpperTerm();
    m_lowerInclusive = query.includesLower();
    m_upperInclusive = query.includesUpper();
}

From source file:org.apache.blur.utils.HighlightHelper.java

License:Apache License

private static Query setFieldIfNeeded(Query query, String name, String fieldLessFieldName) {
    if (name == null) {
        return query;
    }//from  www. j  a v  a 2 s .c o m
    if (query instanceof TermQuery) {
        TermQuery tq = (TermQuery) query;
        Term term = tq.getTerm();
        if (term.field().equals(fieldLessFieldName)) {
            return new TermQuery(new Term(name, term.bytes()));
        }
    } else if (query instanceof WildcardQuery) {
        WildcardQuery wq = (WildcardQuery) query;
        Term term = wq.getTerm();
        if (term.field().equals(fieldLessFieldName)) {
            return new WildcardQuery(new Term(name, term.bytes()));
        }
    } else if (query instanceof MultiPhraseQuery) {
        MultiPhraseQuery mpq = (MultiPhraseQuery) query;
        int[] positions = mpq.getPositions();
        List<Term[]> termArrays = mpq.getTermArrays();
        if (isTermField(termArrays, fieldLessFieldName)) {
            MultiPhraseQuery multiPhraseQuery = new MultiPhraseQuery();
            multiPhraseQuery.setSlop(mpq.getSlop());
            for (int i = 0; i < termArrays.size(); i++) {
                multiPhraseQuery.add(changeFields(termArrays.get(i), name), positions[i]);
            }
            return multiPhraseQuery;
        }
    } else if (query instanceof PhraseQuery) {
        PhraseQuery pq = (PhraseQuery) query;
        Term[] terms = pq.getTerms();
        int[] positions = pq.getPositions();
        String field = terms[0].field();
        if (field.equals(BlurConstants.SUPER)) {
            PhraseQuery phraseQuery = new PhraseQuery();
            for (int i = 0; i < terms.length; i++) {
                phraseQuery.add(new Term(name, terms[i].bytes()), positions[i]);
            }
            phraseQuery.setSlop(pq.getSlop());
            return phraseQuery;
        }
    } else if (query instanceof PrefixQuery) {
        PrefixQuery pq = (PrefixQuery) query;
        Term term = pq.getPrefix();
        if (term.field().equals(BlurConstants.SUPER)) {
            return new PrefixQuery(new Term(name, term.bytes()));
        }
    } else if (query instanceof TermRangeQuery) {
        TermRangeQuery trq = (TermRangeQuery) query;
        BytesRef lowerTerm = trq.getLowerTerm();
        BytesRef upperTerm = trq.getUpperTerm();
        boolean includeUpper = trq.includesUpper();
        boolean includeLower = trq.includesLower();
        String field = trq.getField();
        if (field.equals(BlurConstants.SUPER)) {
            return new TermRangeQuery(name, lowerTerm, upperTerm, includeLower, includeUpper);
        }
    }
    return query;
}

From source file:org.codelibs.fess.helper.QueryHelper.java

License:Apache License

protected QueryBuilder convertTermRangeQuery(final QueryContext context, final TermRangeQuery termRangeQuery,
        final float boost) {
    final String field = getSearchField(context, termRangeQuery.getField());
    if (isSearchField(field)) {
        context.addFieldLog(field, termRangeQuery.toString(field));
        final RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery(field);
        final BytesRef min = termRangeQuery.getLowerTerm();
        if (min != null) {
            if (termRangeQuery.includesLower()) {
                rangeQuery.gte(min.utf8ToString());
            } else {
                rangeQuery.gt(min.utf8ToString());
            }//from  w ww.  java2  s  . c  om
        }
        final BytesRef max = termRangeQuery.getUpperTerm();
        if (max != null) {
            if (termRangeQuery.includesUpper()) {
                rangeQuery.lte(max.utf8ToString());
            } else {
                rangeQuery.lt(max.utf8ToString());
            }
        }
        rangeQuery.boost(boost);
        return rangeQuery;
    } else {
        final String origQuery = termRangeQuery.toString();
        context.addFieldLog(Constants.DEFAULT_FIELD, origQuery);
        context.addHighlightedQuery(origQuery);
        return buildDefaultQueryBuilder((f, b) -> QueryBuilders.matchPhraseQuery(f, origQuery).boost(b));
    }
}

From source file:org.elasticsearch.index.query.RangeQueryBuilderTests.java

License:Apache License

@Override
protected void doAssertLuceneQuery(RangeQueryBuilder queryBuilder, Query query, QueryShardContext context)
        throws IOException {
    if (getCurrentTypes().length == 0 || (queryBuilder.fieldName().equals(DATE_FIELD_NAME) == false
            && queryBuilder.fieldName().equals(INT_FIELD_NAME) == false)) {
        assertThat(query, instanceOf(TermRangeQuery.class));
        TermRangeQuery termRangeQuery = (TermRangeQuery) query;
        assertThat(termRangeQuery.getField(), equalTo(queryBuilder.fieldName()));
        assertThat(termRangeQuery.getLowerTerm(), equalTo(BytesRefs.toBytesRef(queryBuilder.from())));
        assertThat(termRangeQuery.getUpperTerm(), equalTo(BytesRefs.toBytesRef(queryBuilder.to())));
        assertThat(termRangeQuery.includesLower(), equalTo(queryBuilder.includeLower()));
        assertThat(termRangeQuery.includesUpper(), equalTo(queryBuilder.includeUpper()));
    } else if (queryBuilder.fieldName().equals(DATE_FIELD_NAME)) {
        //we can't properly test unmapped dates because LateParsingQuery is package private
    } else if (queryBuilder.fieldName().equals(INT_FIELD_NAME)) {
        assertThat(query,//from w  w  w  .j av a  2s.  co  m
                either(instanceOf(LegacyNumericRangeQuery.class)).or(instanceOf(PointRangeQuery.class)));
        if (query instanceof LegacyNumericRangeQuery) {
            LegacyNumericRangeQuery numericRangeQuery = (LegacyNumericRangeQuery) query;
            assertThat(numericRangeQuery.getField(), equalTo(queryBuilder.fieldName()));
            assertThat(numericRangeQuery.getMin(), equalTo(queryBuilder.from()));
            assertThat(numericRangeQuery.getMax(), equalTo(queryBuilder.to()));
            assertThat(numericRangeQuery.includesMin(), equalTo(queryBuilder.includeLower()));
            assertThat(numericRangeQuery.includesMax(), equalTo(queryBuilder.includeUpper()));
        } else {
            Integer min = (Integer) queryBuilder.from();
            Integer max = (Integer) queryBuilder.to();
            int minInt, maxInt;
            if (min == null) {
                minInt = Integer.MIN_VALUE;
            } else {
                minInt = min.intValue();
                if (queryBuilder.includeLower() == false && minInt != Integer.MAX_VALUE) {
                    minInt++;
                }
            }
            if (max == null) {
                maxInt = Integer.MAX_VALUE;
            } else {
                maxInt = max.intValue();
                if (queryBuilder.includeUpper() == false && maxInt != Integer.MIN_VALUE) {
                    maxInt--;
                }
            }
            try {
                assertEquals(IntPoint.newRangeQuery(INT_FIELD_NAME, minInt, maxInt), query);
            } catch (AssertionError e) {
                throw e;
            }
        }
    } else {
        throw new UnsupportedOperationException();
    }
}