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

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

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

Introduction

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

Prototype

public BytesRef getUpperTerm()

Source Link

Document

Returns the upper value of this range query

Usage

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

License:Apache License

@Test
public void test_parse_between_query() {
    String query = "Select foo from '/path/index/' where foo between 'Beth' and 'Elizabeth'";
    BooleanQuery bq = parseQuery(query);
    BooleanClause[] clauses = bq.getClauses();
    TermRangeQuery termRangeQuery = (TermRangeQuery) clauses[0].getQuery();
    assertThat(termRangeQuery.getField(), is("foo"));
    assertThat(new String(termRangeQuery.getLowerTerm().bytes).trim(), is("beth"));
    assertThat(new String(termRangeQuery.getUpperTerm().bytes).trim(), is("elizabeth"));
}

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

License:Apache License

@Test
public void test_less_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(), is(nullValue()));
    assertThat(termRangeQuery.getUpperTerm().utf8ToString(), is("49"));
    assertThat(termRangeQuery.includesUpper(), is(false));
}

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

License:Apache License

@Test
public void test_less_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(), is(nullValue()));
    assertThat(termRangeQuery.getUpperTerm().utf8ToString(), is("49"));
    assertThat(termRangeQuery.includesUpper(), is(true));
}

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:com.github.rnewson.couchdb.lucene.QueryPlan.java

License:Apache License

private static void planTermRangeQuery(final StringBuilder builder, final TermRangeQuery query) {
    builder.append(query.getLowerTerm().utf8ToString());
    builder.append(" TO ");
    builder.append(query.getUpperTerm().utf8ToString());
}

From source file:com.liferay.document.library.repository.search.internal.LuceneRepositorySearchQueryTermBuilder.java

License:Open Source License

protected void translateQuery(BooleanQuery booleanQuery, SearchContext searchContext,
        org.apache.lucene.search.Query query, org.apache.lucene.search.BooleanClause.Occur occur)
        throws Exception {

    BooleanClauseOccur booleanClauseOccur = getBooleanClauseOccur(occur);

    if (query instanceof org.apache.lucene.search.TermQuery) {
        org.apache.lucene.search.TermQuery luceneTermQuery = (org.apache.lucene.search.TermQuery) query;

        Term term = luceneTermQuery.getTerm();

        String termValue = term.text();

        TermQuery termQuery = new TermQueryImpl(term.field(), termValue);

        booleanQuery.add(termQuery, getBooleanClauseOccur(occur));
    } else if (query instanceof org.apache.lucene.search.BooleanQuery) {
        org.apache.lucene.search.BooleanQuery curBooleanQuery = (org.apache.lucene.search.BooleanQuery) query;

        BooleanQuery conjunctionQuery = new BooleanQueryImpl();

        BooleanQuery disjunctionQuery = new BooleanQueryImpl();

        for (org.apache.lucene.search.BooleanClause booleanClause : curBooleanQuery.getClauses()) {

            BooleanClauseOccur curBooleanClauseOccur = getBooleanClauseOccur(booleanClause.getOccur());

            BooleanQuery subbooleanQuery = null;

            if (curBooleanClauseOccur.equals(BooleanClauseOccur.SHOULD)) {
                subbooleanQuery = disjunctionQuery;
            } else {
                subbooleanQuery = conjunctionQuery;
            }//  ww  w. j  a va  2 s .co  m

            translateQuery(subbooleanQuery, searchContext, booleanClause.getQuery(), booleanClause.getOccur());
        }

        if (conjunctionQuery.hasClauses()) {
            booleanQuery.add(conjunctionQuery, BooleanClauseOccur.MUST);
        }

        if (disjunctionQuery.hasClauses()) {
            booleanQuery.add(disjunctionQuery, BooleanClauseOccur.SHOULD);
        }
    } else if (query instanceof org.apache.lucene.search.FuzzyQuery) {
        org.apache.lucene.search.FuzzyQuery fuzzyQuery = (org.apache.lucene.search.FuzzyQuery) query;

        Term term = fuzzyQuery.getTerm();

        String termValue = term.text().concat(StringPool.STAR);

        WildcardQuery wildcardQuery = new WildcardQueryImpl(term.field(), termValue);

        booleanQuery.add(wildcardQuery, booleanClauseOccur);
    } else if (query instanceof org.apache.lucene.search.PhraseQuery) {
        org.apache.lucene.search.PhraseQuery phraseQuery = (org.apache.lucene.search.PhraseQuery) query;

        Term[] terms = phraseQuery.getTerms();

        StringBundler sb = new StringBundler(terms.length * 2);

        for (Term term : terms) {
            sb.append(term.text());
            sb.append(StringPool.SPACE);
        }

        TermQuery termQuery = new TermQueryImpl(terms[0].field(), sb.toString().trim());

        booleanQuery.add(termQuery, booleanClauseOccur);
    } else if (query instanceof org.apache.lucene.search.PrefixQuery) {
        org.apache.lucene.search.PrefixQuery prefixQuery = (org.apache.lucene.search.PrefixQuery) query;

        Term prefixTerm = prefixQuery.getPrefix();

        String termValue = prefixTerm.text().concat(StringPool.STAR);

        WildcardQuery wildcardQuery = new WildcardQueryImpl(prefixTerm.field(), termValue);

        booleanQuery.add(wildcardQuery, booleanClauseOccur);
    } else if (query instanceof org.apache.lucene.search.TermRangeQuery) {
        org.apache.lucene.search.TermRangeQuery termRangeQuery = (org.apache.lucene.search.TermRangeQuery) query;

        booleanQuery.addRangeTerm(termRangeQuery.getField(), termRangeQuery.getLowerTerm().utf8ToString(),
                termRangeQuery.getUpperTerm().utf8ToString());
    } else if (query instanceof org.apache.lucene.search.WildcardQuery) {
        org.apache.lucene.search.WildcardQuery luceneWildcardQuery = (org.apache.lucene.search.WildcardQuery) query;

        Term wildcardTerm = luceneWildcardQuery.getTerm();

        WildcardQuery wildcardQuery = new WildcardQueryImpl(wildcardTerm.field(), wildcardTerm.text());

        booleanQuery.add(wildcardQuery, booleanClauseOccur);
    } else {
        if (_log.isWarnEnabled()) {
            _log.warn("Ignoring unknown query type " + query.getClass() + " with query " + query);
        }
    }
}

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  w  w w . jav  a 2 s .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));
}