Example usage for org.apache.lucene.search PhraseQuery getTerms

Introduction

In this page you can find the example usage for org.apache.lucene.search PhraseQuery getTerms.

Prototype

public Term[] getTerms() 

Source Link

Document

Returns the list of terms in this phrase.

Usage

From source file:aos.lucene.search.ext.queryparser.CustomQueryParser.java

License:Apache License

/**
 * Replace PhraseQuery with SpanNearQuery to force in-order
 * phrase matching rather than reverse.// w  w  w . ja  v  a2  s .com
 */
protected Query getFieldQuery(String field, String queryText, int slop) throws ParseException {
    Query orig = super.getFieldQuery(field, queryText, slop); //

    if (!(orig instanceof PhraseQuery)) { //
        return orig; //
    } //

    PhraseQuery pq = (PhraseQuery) orig;
    Term[] terms = pq.getTerms(); //
    SpanTermQuery[] clauses = new SpanTermQuery[terms.length];
    for (int i = 0; i < terms.length; i++) {
        clauses[i] = new SpanTermQuery(terms[i]);
    }

    SpanNearQuery query = new SpanNearQuery( //
            clauses, slop, true); //

    return query;
}

---

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

License:Apache License

@Test
public void test_parse_term_and_phrase_query() {
    String query = "Select name,address from '/path/to/index/' where first_name='Beth' and last_name='Bejeck' or type='Big   Cutie '";
    BooleanQuery booleanQuery = parseQuery(query);
    BooleanClause[] clauses = booleanQuery.getClauses();
    assertThat(clauses.length, is(3));/*from w ww  . jav  a2s  .co m*/
    assertThat(clauses[0].getOccur(), is(BooleanClause.Occur.MUST));
    assertThat(clauses[1].getOccur(), is(BooleanClause.Occur.MUST));
    assertThat(clauses[2].getOccur(), is(BooleanClause.Occur.SHOULD));

    TermQuery termQuery = (TermQuery) clauses[0].getQuery();
    assertThat(termQuery.getTerm().field(), is("first_name"));
    assertThat(termQuery.getTerm().text(), is("beth"));

    termQuery = (TermQuery) clauses[1].getQuery();
    assertThat(termQuery.getTerm().field(), is("last_name"));
    assertThat(termQuery.getTerm().text(), is("bejeck"));

    assertThat(clauses[2].getQuery().getClass().isAssignableFrom(PhraseQuery.class), is(true));
    assertThat(clauses[2].getOccur(), is(BooleanClause.Occur.SHOULD));
    PhraseQuery phraseQuery = (PhraseQuery) clauses[2].getQuery();
    assertArrayEquals(phraseQuery.getTerms(),
            new Term[] { new Term("type", "big"), new Term("type", "cutie") });
}

---

From source file:com.browseengine.bobo.search.section.SectionSearchQueryPlanBuilder.java

License:Apache License

private SectionSearchQueryPlan translatePhraseQuery(PhraseQuery query) throws IOException {
    Term[] terms = query.getTerms();
    TermNode[] nodes = new TermNode[terms.length];
    int[] positions = query.getPositions();
    for (int i = 0; i < terms.length; i++) {
        nodes[i] = new TermNode(terms[i], positions[i], _reader);
    }/*from  w  ww  .  j  ava 2s.  com*/
    return new PhraseNode(nodes, _reader);
}

---

From source file:com.flaptor.indextank.query.IndexEngineParser.java

License:Apache License

private QueryNode internalParse(org.apache.lucene.search.Query luceneQuery, final String originalStr)
        throws ParseException {
    QueryNode node;//from w w  w.  j av  a2 s . c o m
    if (luceneQuery instanceof org.apache.lucene.search.TermQuery) {
        Term t = ((org.apache.lucene.search.TermQuery) luceneQuery).getTerm();
        String field = t.field();
        String text = t.text();
        node = new TermQuery(field, text);
    } else if (luceneQuery instanceof org.apache.lucene.search.PrefixQuery) {
        Term t = ((org.apache.lucene.search.PrefixQuery) luceneQuery).getPrefix();
        String field = t.field();
        String text = t.text();
        node = new PrefixTermQuery(field, text);
    } else if (luceneQuery instanceof org.apache.lucene.search.BooleanQuery) {
        List<BooleanClause> clauses = ((org.apache.lucene.search.BooleanQuery) luceneQuery).clauses();
        if (clauses.isEmpty()) {
            throw new ParseException("error parsing: " + originalStr);
        }
        node = internalParseBooleanQuery(clauses, originalStr);
    } else if (luceneQuery instanceof org.apache.lucene.search.PhraseQuery) {
        org.apache.lucene.search.PhraseQuery phraseQuery = (org.apache.lucene.search.PhraseQuery) luceneQuery;
        int[] positions = phraseQuery.getPositions();
        node = internalParsePhraseQuery(phraseQuery.getTerms(), positions, originalStr);
    } else {
        throw new ParseException("unimplemented");
    }
    node.setBoost(luceneQuery.getBoost());
    return node;
}

---

From source file:com.globalsight.ling.lucene.highlight.QueryTermExtractor.java

License:Apache License

private static final void getTermsFromPhraseQuery(PhraseQuery query, HashSet terms) {
    Term[] queryTerms = query.getTerms();
    int i;//  w ww. ja  v a 2s  . co m

    for (i = 0; i < queryTerms.length; i++) {
        terms.add(new WeightedTerm(query.getBoost(), queryTerms[i].text()));
    }
}

---

From source file:com.jaeksoft.searchlib.snippet.SnippetQueries.java

License:Open Source License

private final void parse(final PhraseQuery query) {
    Term[] terms = query.getTerms();
    if (terms == null)
        return;/*from   www .ja v  a2 s .c  om*/

    List<Integer> termPosSequence = new ArrayList<Integer>(terms.length);
    for (Term term : terms) {
        if (!field.equals(term.field()))
            continue;
        int pos = checkTerm(term.text());
        termPosSequence.add(pos);
        termPhraseSet.add(pos);
    }
    // Term sequences with one term are not phrase queries
    if (termPosSequence.size() <= 1)
        return;
    termSequenceList.add(new TermSequence(termPosSequence, query.getSlop()));
}

---

From source file:com.leavesfly.lia.extsearch.queryparser.CustomQueryParser.java

License:Apache License

/**
 * Replace PhraseQuery with SpanNearQuery to force in-order phrase matching
 * rather than reverse.//from   w w  w  .java2 s.  c  o m
 */
protected Query getFieldQuery(String field, String queryText, int slop) throws ParseException {
    Query orig = super.getFieldQuery(field, queryText, slop); // #1

    if (!(orig instanceof PhraseQuery)) { // #2
        return orig; // #2
    } // #2

    PhraseQuery pq = (PhraseQuery) orig;
    Term[] terms = pq.getTerms(); // #3
    SpanTermQuery[] clauses = new SpanTermQuery[terms.length];
    for (int i = 0; i < terms.length; i++) {
        clauses[i] = new SpanTermQuery(terms[i]);
    }

    SpanNearQuery query = new SpanNearQuery( // #4
            clauses, slop, true); // #4

    return query;
}

---

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;
            }// w  w w  .ja v  a2s. c o  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:com.liferay.portal.repository.search.RepositorySearchQueryBuilderImpl.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) {
        Set<Term> terms = new HashSet<Term>();

        query.extractTerms(terms);/*ww w .j  a va 2  s . com*/

        for (Term term : terms) {
            String termValue = term.text();

            booleanQuery.addTerm(term.field(), termValue, false, 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 = BooleanQueryFactoryUtil.create(searchContext);
        BooleanQuery disjunctionQuery = BooleanQueryFactoryUtil.create(searchContext);

        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;
            }

            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);

        booleanQuery.addTerm(term.field(), termValue, true, 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);
        }

        booleanQuery.addTerm(terms[0].field(), sb.toString().trim(), false, 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);

        booleanQuery.addTerm(prefixTerm.field(), termValue, true, 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(),
                termRangeQuery.getUpperTerm());
    } else if (query instanceof org.apache.lucene.search.WildcardQuery) {
        org.apache.lucene.search.WildcardQuery wildcardQuery = (org.apache.lucene.search.WildcardQuery) query;

        Term wildcardTerm = wildcardQuery.getTerm();

        booleanQuery.addTerm(wildcardTerm.field(), wildcardTerm.text(), true, booleanClauseOccur);
    } else {
        if (_log.isWarnEnabled()) {
            _log.warn("Ignoring unknown query type " + query.getClass() + " with query " + query);
        }
    }
}

---

From source file:com.o19s.solr.swan.highlight.SpanAwareFieldQuery.java

License:Apache License

SpanAwareFieldQuery(Query query, IndexReader reader, boolean phraseHighlight, boolean fieldMatch,
        TreeSet<Integer> filterDocIds) throws IOException {
    this.fieldMatch = fieldMatch;
    this.filterDocIds = filterDocIds;
    Set<Query> flatQueries = new LinkedHashSet<Query>();
    flatten(query, reader, flatQueries);
    saveTerms(flatQueries, reader);/*from w  w w . j  av  a 2  s .  c o m*/
    Collection<Query> expandQueries = expand(flatQueries);

    for (Query flatQuery : expandQueries) {
        QueryPhraseMap rootMap = getRootMap(flatQuery);
        rootMap.add(flatQuery, reader);
        if (!phraseHighlight && flatQuery instanceof PhraseQuery) {
            PhraseQuery pq = (PhraseQuery) flatQuery;
            if (pq.getTerms().length > 1) {
                for (Term term : pq.getTerms())
                    rootMap.addTerm(term, flatQuery.getBoost());
            }
        }
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• »