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

Introduction

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

Prototype

public List<Term> getTerms() 

Source Link

Usage

From source file:org.tallison.lucene.queryparser.spans.SpanQueryParserBase.java

License:Apache License

/**
 * Converts {@link #newFieldQuery(String, String, boolean, int)} to something
 * as close as possible to a SpanQuery./*from  w  w w  .  j  a  va 2s .  com*/
 * <p>
 * Can return null, e.g. if asked to create newFieldSpanQuery from a stop word.
 * @param fieldName field for query
 * @param termText text for term
 * @param quoted whether or not this is quoted
 * @return a SpanQuery that is as close as possible to the Query created by
 *  {@link #newFieldQuery(String, String, boolean, int)}
 * @throws ParseException if encountered during parse
 */
protected SpanQuery newFieldSpanQuery(String fieldName, String termText, boolean quoted) throws ParseException {

    Analyzer analyzer = getAnalyzer(fieldName);

    if (analyzer == null) {
        throw new ParseException("Need to have non-null analyzer for term queries within a 'near' clause.");
    }
    Query q = newFieldQuery(fieldName, termText, quoted, 0);
    if (q == null) {
        return null;
    }
    //now convert to a SpanQuery
    if (q instanceof TermQuery) {
        SpanTermQuery stq = new SpanTermQuery(((TermQuery) q).getTerm());
        return stq;
    } else if (q instanceof BooleanQuery) {
        //TODO: there are dragons here.  convertBooleanOfBooleanOrTermsToSpan
        //ignores the operators inside of the BooleanQuery
        //and just treats this as big "OR" for now
        return convertBooleanOfBooleanOrTermsToSpan((BooleanQuery) q);
    } else if (q instanceof PhraseQuery) {
        PhraseQuery pq = (PhraseQuery) q;
        Term[] terms = pq.getTerms();
        int[] positions = pq.getPositions();
        List<SpanQuery> spanTerms = new LinkedList<>();
        for (Term t : terms) {
            spanTerms.add(new SpanTermQuery(t));
        }
        int slop = positions[positions.length - 1] - (positions.length - 1);
        return buildSpanNearQuery(spanTerms, slop, true);
    } else if (q instanceof MultiPhraseQuery) {
        MultiPhraseQuery mpq = (MultiPhraseQuery) q;
        int[] positions = mpq.getPositions();
        Term[][] terms = mpq.getTermArrays();
        List<SpanQuery> spanTerms = new LinkedList<>();
        for (Term[] tArr : terms) {
            List<SpanQuery> spans = new LinkedList<>();
            for (Term t : tArr) {
                spans.add(new SpanTermQuery(t));
            }
            SpanQuery spanOr = buildSpanOrQuery(spans);
            spanTerms.add(spanOr);
        }
        int slop = positions[positions.length - 1] - positions.length;
        return buildSpanNearQuery(spanTerms, slop, true);
    } else if (q instanceof SynonymQuery) {
        SynonymQuery synonymQuery = (SynonymQuery) q;
        if (synonymQuery.getTerms().size() == 0) {
            return new SpanOrQuery();
        } else if (synonymQuery.getTerms().size() == 1) {
            return new SpanTermQuery(synonymQuery.getTerms().get(0));
        }
        SpanQuery[] clauses = new SpanQuery[((SynonymQuery) q).getTerms().size()];
        int i = 0;
        for (Term t : ((SynonymQuery) q).getTerms()) {
            clauses[i++] = new SpanTermQuery(t);
        }
        return new SpanOrQuery(clauses);
    }
    throw new IllegalArgumentException("Can't convert class >" + q.getClass() + "< to a SpanQuery");
}

---