Example usage for org.apache.lucene.search BooleanClause getOccur

Introduction

In this page you can find the example usage for org.apache.lucene.search BooleanClause getOccur.

Prototype

public Occur getOccur() 

Source Link

Usage

From source file:com.amalto.core.storage.hibernate.LuceneQueryGenerator.java

License:Open Source License

private static boolean isNotQuery(Query left) {
    if (left instanceof BooleanQuery) {
        for (BooleanClause booleanClause : ((BooleanQuery) left).getClauses()) {
            if (booleanClause.getOccur() == BooleanClause.Occur.MUST_NOT) {
                return true;
            }// w  w w . ja  va2 s .co  m
        }
    }
    return false;
}

---

From source file:com.bizosys.hsearch.query.HQueryParser.java

License:Apache License

private static void parseComposites(Query lQuery, HQuery hQuery) {

    for (BooleanClause clause : ((BooleanQuery) lQuery).clauses()) {

        Query subQueryL = clause.getQuery();

        if (subQueryL instanceof BooleanQuery) {

            HQuery subQueryH = new HQuery();
            subQueryH.isShould = clause.getOccur().compareTo(Occur.SHOULD) == 0;
            subQueryH.isMust = clause.getOccur().compareTo(Occur.MUST) == 0;

            hQuery.subQueries.add(subQueryH);
            parseComposites(subQueryL, subQueryH);

        } else {//from   ww  w .  j  a v  a 2  s .co  m
            HQuery.HTerm hTerm = new HQuery.HTerm();
            hTerm.isShould = clause.getOccur().compareTo(Occur.SHOULD) == 0;
            hTerm.isMust = clause.getOccur().compareTo(Occur.MUST) == 0;
            hTerm.boost = subQueryL.getBoost();
            hQuery.terms.add(hTerm);

            if (subQueryL instanceof TermQuery) {
                TermQuery lTerm = (TermQuery) subQueryL;
                hTerm.type = lTerm.getTerm().field();
                hTerm.text = lTerm.getTerm().text();

            } else if (subQueryL instanceof FuzzyQuery) {
                FuzzyQuery lTerm = (FuzzyQuery) subQueryL;
                hTerm.isFuzzy = true;
                hTerm.type = lTerm.getTerm().field();
                hTerm.text = lTerm.getTerm().text();

            } else {
                hTerm.type = "Not Impemented";
                hTerm.text = "Not Impemented";
            }

        }
    }
}

---

From source file:com.github.healthonnet.search.SynonymExpandingExtendedDismaxQParserPlugin.java

License:Apache License

/**
 * Find the main query and its surrounding clause, make it SHOULD instead of MUST and append a bunch of other SHOULDs to it, then wrap it in a MUST E.g. +(text:dog) becomes +((text:dog)^1.5 ((text:hound) (text:pooch))^1.2)
 * /*  www  .  ja  v  a  2s  .  com*/
 * @param query
 * @param synonymQueries
 * @param originalBoost
 * @param synonymBoost
 */
private Query applySynonymQueries(Query query, List<Query> synonymQueries, float originalBoost,
        float synonymBoost) {
    if (query instanceof BoostedQuery) {
        return applySynonymQueries(((BoostedQuery) query).getQuery(), synonymQueries, originalBoost,
                synonymBoost);
    } else if (query instanceof BooleanQuery) {
        BooleanQuery.Builder booleanQueryBuilder = new BooleanQuery.Builder();
        for (BooleanClause booleanClause : ((BooleanQuery) query).clauses()) {
            if (Occur.MUST == booleanClause.getOccur()) {
                BooleanQuery.Builder combinedQueryBuilder = new BooleanQuery.Builder();
                combinedQueryBuilder.add(new BoostQuery(booleanClause.getQuery(), originalBoost), Occur.SHOULD);
                // standard 'must occur' clause - i.e. the main user query

                for (Query synonymQuery : synonymQueries) {
                    if (synonymQuery != null) {
                        BooleanQuery.Builder booleanSynonymQueryBuilder = new BooleanQuery.Builder();
                        booleanSynonymQueryBuilder.add(new BoostQuery(synonymQuery, synonymBoost),
                                Occur.SHOULD);
                        combinedQueryBuilder.add(booleanSynonymQueryBuilder.build(), Occur.SHOULD);
                    }
                }
                booleanQueryBuilder.add(combinedQueryBuilder.build(), Occur.MUST);
            } else {
                booleanQueryBuilder.add(booleanClause);
            }
        }
        query = booleanQueryBuilder.build();
        queryToHighlight = query;
    }
    return query;
}

---

From source file:com.github.rnewson.couchdb.lucene.QueryPlan.java

License:Apache License

private static void planBooleanQuery(final StringBuilder builder, final BooleanQuery query) {
    for (final BooleanClause clause : query.getClauses()) {
        builder.append(clause.getOccur());
        toPlan(builder, clause.getQuery());
    }/*  w ww  .  j ava 2  s  .  com*/
}

---

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

License:Open Source License

private final void parse(final BooleanQuery query) {
    BooleanClause[] clauses = query.getClauses();
    if (clauses == null)
        return;/*from w w w .ja  v a2  s  . c  om*/
    for (BooleanClause clause : clauses) {
        switch (clause.getOccur()) {
        case MUST:
        case SHOULD:
            parse(clause.getQuery());
            break;
        default:
            break;
        }
    }
}

---

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;
            }/*from w w  w .j ava2  s  . 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.search.lucene.highlight.QueryTermExtractor.java

License:Open Source License

public static WeightedTerm[] getTerms(Query query, boolean prohibited, String fieldName) {

    if (query == null) {
        return _emptyWeightedTermArray;
    }//from w w  w. j a va 2  s  .c o  m

    Set<WeightedTerm> weightedTerms = new HashSet<WeightedTerm>();

    Set<Term> terms = new HashSet<Term>();

    LinkedList<Query> queries = new LinkedList<Query>();

    Query lastQuery = query;

    while (lastQuery != null) {
        if (lastQuery instanceof BooleanQuery) {
            BooleanQuery booleanQuery = (BooleanQuery) lastQuery;

            BooleanClause[] booleanClauses = booleanQuery.getClauses();

            for (BooleanClause booleanClause : booleanClauses) {
                if (prohibited || (booleanClause.getOccur() != BooleanClause.Occur.MUST_NOT)) {

                    Query booleanClauseQuery = booleanClause.getQuery();

                    if (booleanClauseQuery != null) {
                        queries.addFirst(booleanClauseQuery);
                    }
                }
            }

            lastQuery = queries.poll();
        } else if (lastQuery instanceof FilteredQuery) {
            FilteredQuery filteredQuery = (FilteredQuery) lastQuery;

            lastQuery = filteredQuery.getQuery();

            if (lastQuery == null) {
                lastQuery = queries.poll();
            }
        } else {
            Class<? extends Query> queryClass = lastQuery.getClass();

            if (!_queryClasses.contains(queryClass)) {
                try {
                    lastQuery.extractTerms(terms);

                    for (Term term : terms) {
                        if ((fieldName == null) || fieldName.equals(term.field())) {

                            WeightedTerm weightedTerm = new WeightedTerm(query.getBoost(), term.text());

                            weightedTerms.add(weightedTerm);
                        }
                    }

                    terms.clear();
                } catch (UnsupportedOperationException uoe) {
                    _queryClasses.addIfAbsent(queryClass);
                }
            }

            lastQuery = queries.poll();
        }
    }

    return weightedTerms.toArray(new WeightedTerm[weightedTerms.size()]);
}

---

From source file:com.liferay.portal.search.lucene.LuceneHelperImpl.java

License:Open Source License

private void _includeIfUnique(BooleanQuery booleanQuery, Query query, BooleanClause.Occur occur, boolean like) {

    if (query instanceof TermQuery) {
        Set<Term> terms = new HashSet<Term>();

        query.extractTerms(terms);//from  ww w .  j a va  2  s.  c  om

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

            if (like) {
                term = term.createTerm(StringPool.STAR.concat(termValue).concat(StringPool.STAR));

                query = new WildcardQuery(term);
            } else {
                query = new TermQuery(term);
            }

            boolean included = false;

            for (BooleanClause booleanClause : booleanQuery.getClauses()) {
                if (query.equals(booleanClause.getQuery())) {
                    included = true;
                }
            }

            if (!included) {
                booleanQuery.add(query, occur);
            }
        }
    } else if (query instanceof BooleanQuery) {
        BooleanQuery curBooleanQuery = (BooleanQuery) query;

        for (BooleanClause booleanClause : curBooleanQuery.getClauses()) {
            _includeIfUnique(booleanQuery, booleanClause.getQuery(), booleanClause.getOccur(), like);
        }
    } else {
        boolean included = false;

        for (BooleanClause booleanClause : booleanQuery.getClauses()) {
            if (query.equals(booleanClause.getQuery())) {
                included = true;
            }
        }

        if (!included) {
            booleanQuery.add(query, occur);
        }
    }
}

---

From source file:com.liferay.portal.search.solr.internal.query.TermQueryTranslatorImpl.java

License:Open Source License

private org.apache.lucene.search.Query _toCaseInsensitiveSubstringQuery(
        org.apache.lucene.search.BooleanQuery booleanQuery) {

    org.apache.lucene.search.BooleanQuery newBooleanQuery = new org.apache.lucene.search.BooleanQuery();

    List<BooleanClause> clauses = booleanQuery.clauses();

    for (BooleanClause booleanClause : clauses) {
        org.apache.lucene.search.TermQuery termQuery = (org.apache.lucene.search.TermQuery) booleanClause
                .getQuery();/*from   w w  w .jav a 2s  .  co  m*/

        org.apache.lucene.search.Query query = _toCaseInsensitiveSubstringQuery(termQuery);

        newBooleanQuery.add(query, booleanClause.getOccur());
    }

    return newBooleanQuery;
}

---

From source file:com.mhs.qsol.proximity.ProximityVisitor.java

License:Apache License

private void addQueryToDistributable(Query query) {
    if (query instanceof SpanQuery) {
        proxBuilder.addDistrib(new BasicDistributable((SpanQuery) query));
    } else if (query instanceof BooleanQuery) {
        BooleanClause[] booleanClauses = ((BooleanQuery) query).getClauses();
        for (BooleanClause booleanClause : booleanClauses) {
            Occur occur = booleanClause.getOccur();
            Query subQuery = booleanClause.getQuery();
            if (subQuery instanceof SpanQuery) { //about to add span query, so, add the connector now
                proxBuilder.addConnector(occur);
            }//from   ww w  .j a va 2s. c  o  m
            addQueryToDistributable(subQuery);
        }
    }
}

---

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