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

Introduction

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

Prototype

@Override
    public String toString() 

Source Link

Usage

From source file:org.fao.geonet.kernel.search.LuceneQueryBuilder.java

License:Open Source License

/**
 * Builds a query where OR operator is used for each search criteria.
 *
 * @param searchCriteria//  www .ja  va  2  s. c  om
 * @param query
 * @param similarity
 * @return
 */
private BooleanQuery buildORQuery(Map<String, Set<String>> searchCriteria, BooleanQuery query,
        String similarity) {

    spatialCriteriaAdded = false;
    temporalCriteriaAdded = false;
    templateCriteriaAdded = false;

    if (searchCriteria.size() == 0) {
        return query;
    }

    // Avoid search by field who control privileges
    Set<String> fields = new HashSet<String>();
    for (String requestedField : searchCriteria.keySet()) {
        if (!(UserQueryInput.SECURITY_FIELDS.contains(requestedField)
                || SearchParameter.EDITABLE.equals(requestedField))) {
            fields.add(requestedField);
        }
    }

    BooleanClause.Occur occur = LuceneUtils.convertRequiredAndProhibitedToOccur(true, false);
    BooleanClause.Occur tokenOccur = LuceneUtils.convertRequiredAndProhibitedToOccur(false, false);
    BooleanQuery booleanQuery = new BooleanQuery();
    for (String fieldName : fields) {

        Set<String> fieldValues = searchCriteria.get(fieldName);
        String fieldValue = fieldValues.iterator().next();

        if (fieldValue.contains(OR_SEPARATOR)) {
            // TODO : change OR separator
            // Add all separated values to the boolean query
            addSeparatedTextField(fieldValue, OR_SEPARATOR, fieldName, booleanQuery);
        } else {
            if (LuceneIndexField.ANY.equals(fieldName) || "all".equals(fieldName)) {
                BooleanClause anyClause = null;
                if (!onlyWildcard(fieldValue)) {
                    // tokenize searchParam
                    StringTokenizer st = new StringTokenizer(fieldValue, STRING_TOKENIZER_DELIMITER);
                    if (st.countTokens() == 1) {
                        String token = st.nextToken();
                        Query subQuery = textFieldToken(token, LuceneIndexField.ANY, similarity);
                        if (subQuery != null) {
                            anyClause = new BooleanClause(subQuery, tokenOccur);
                        }
                    } else {
                        BooleanQuery ooleanQuery = new BooleanQuery();
                        while (st.hasMoreTokens()) {
                            String token = st.nextToken();
                            Query subQuery = textFieldToken(token, LuceneIndexField.ANY, similarity);
                            if (subQuery != null) {
                                BooleanClause subClause = new BooleanClause(subQuery, tokenOccur);
                                booleanQuery.add(subClause);
                            }
                        }
                        anyClause = new BooleanClause(ooleanQuery, tokenOccur);
                    }
                }
                if (StringUtils.isNotEmpty(anyClause.toString())) {
                    booleanQuery.add(anyClause);
                }
            } else {
                if (!_tokenizedFieldSet.contains(fieldName)) {
                    // TODO : use similarity when needed
                    TermQuery termQuery = new TermQuery(new Term(fieldName, "\"" + fieldValue.trim() + "\""));
                    BooleanClause clause = new BooleanClause(termQuery, tokenOccur);
                    booleanQuery.add(clause);
                } else {
                    // tokenize searchParam
                    StringTokenizer st = new StringTokenizer(fieldValue.trim(), STRING_TOKENIZER_DELIMITER);

                    while (st.hasMoreTokens()) {
                        String token = st.nextToken();
                        Query subQuery = textFieldToken(token, fieldName, similarity);
                        if (subQuery != null) {
                            BooleanClause subClause = new BooleanClause(subQuery, tokenOccur);
                            booleanQuery.add(subClause);
                        }
                    }
                }
            }
        }
    }
    BooleanClause booleanClause = new BooleanClause(booleanQuery, occur);
    query.add(booleanClause);

    // Search only for metadata (no template or sub-templates) if not set by search criteria before
    if (!templateCriteriaAdded) {
        occur = LuceneUtils.convertRequiredAndProhibitedToOccur(true, false);
        Query q = new TermQuery(new Term(LuceneIndexField.IS_TEMPLATE, "n"));
        query.add(q, occur);
        templateCriteriaAdded = true;
    }
    return query;
}

---

From source file:ubic.gemma.search.SearchServiceImpl.java

License:Apache License

/**
 * @param query/*from   w w  w. j a  v  a 2  s.  co m*/
 * @return
 */
private Set<String> extractTerms(String query) {
    Query lquer = this.makeLuceneQuery(query);

    Set<String> rawTerms = new HashSet<String>();
    if (lquer instanceof BooleanQuery) {
        BooleanClause[] clauses = ((BooleanQuery) lquer).getClauses();
        for (BooleanClause booleanClause : clauses) {
            rawTerms.add(booleanClause.toString().replaceAll("^[\\+-]", ""));
        }
    } else if (lquer instanceof PhraseQuery) {
        rawTerms.add(((PhraseQuery) lquer).toString().replaceAll("\"", ""));
    } else if (lquer instanceof PrefixQuery) {
        rawTerms.add(((PrefixQuery) lquer).getPrefix().field());
    } else {
        rawTerms.add(query);
    }
    return rawTerms;
}

---