Example usage for org.apache.lucene.search BooleanQuery clauses

Introduction

In this page you can find the example usage for org.apache.lucene.search BooleanQuery clauses.

Prototype

List clauses

To view the source code for org.apache.lucene.search BooleanQuery clauses.

Click Source Link

Usage

From source file:org.neo4j.index.impl.lucene.FullTxData.java

License:Open Source License

private Query injectOrphans(Query query) {
    if (query instanceof BooleanQuery) {
        BooleanQuery source = (BooleanQuery) query;
        BooleanQuery result = new BooleanQuery();
        for (BooleanClause clause : source.clauses()) {
            result.add(injectOrphans(clause.getQuery()), clause.getOccur());
        }/*www.  j a  va 2 s.  com*/
        return result;
    }

    String orphanField = extractTermField(query);
    if (orphanField == null) {
        return query;
    }

    BooleanQuery result = new BooleanQuery();
    result.add(query, Occur.SHOULD);
    result.add(new TermQuery(new Term(ORPHANS_KEY, orphanField)), Occur.SHOULD);
    return result;
}

---

From source file:org.neo4j.index.impl.lucene.legacy.FullTxData.java

License:Open Source License

private Query injectOrphans(Query query) {
    if (query instanceof BooleanQuery) {
        BooleanQuery source = (BooleanQuery) query;
        BooleanQuery.Builder builder = new BooleanQuery.Builder();
        for (BooleanClause clause : source.clauses()) {
            builder.add(injectOrphans(clause.getQuery()), clause.getOccur());
        }/*from  ww w  .  j a  va2 s.c o  m*/
        return builder.build();
    }

    String orphanField = extractTermField(query);
    if (orphanField == null) {
        return query;
    }

    return new BooleanQuery.Builder().add(query, Occur.SHOULD)
            .add(new TermQuery(new Term(ORPHANS_KEY, orphanField)), Occur.SHOULD).build();
}

---

From source file:org.rssowl.core.internal.persist.search.ModelSearchQueries.java

License:Open Source License

private static Query internalCreateQuery(Collection<ISearchCondition> conditions, ISearchCondition scope,
        boolean matchAllConditions) throws IOException {
    boolean isScoped = false;
    BooleanQuery bQuery = new BooleanQuery();
    Analyzer analyzer = Indexer.createAnalyzer();

    /* Handle Location Scope Query separately */
    for (ISearchCondition condition : conditions) {
        if (isLocationScopeCondition(condition)) {
            BooleanQuery locationScopeClause = createLocationClause(condition);
            if (!locationScopeClause.clauses().isEmpty()) {
                bQuery.add(locationScopeClause, Occur.MUST);
                isScoped = true;//  w ww  .jav  a  2 s  . c om
            }
        }
    }

    /* Add Condition Scope Query as necessary */
    if (scope != null) {
        addFieldClauses(Collections.singleton(scope), true, bQuery, analyzer);
        isScoped = true;
    }

    /* If scoped, the fieldQuery is a MUST-Clause to the outer Query */
    BooleanQuery fieldQuery = bQuery;
    if (isScoped)
        fieldQuery = new BooleanQuery();

    /* Add Conditions into the Boolean Query */
    addFieldClauses(conditions, matchAllConditions, fieldQuery, analyzer);

    /* Only add if not empty if scoped */
    if (isScoped && !fieldQuery.clauses().isEmpty())
        bQuery.add(fieldQuery, Occur.MUST);

    return bQuery;
}

---

From source file:org.rssowl.core.internal.persist.search.ModelSearchQueries.java

License:Open Source License

private static BooleanQuery createLocationClause(ISearchCondition condition) {
    BooleanQuery bQuery = new BooleanQuery();
    Long[][] value = (Long[][]) condition.getValue();
    if (value != null) {

        /* Receive Folders */
        for (int i = 0; value[0] != null && i < value[0].length; i++) {
            if (value[0][i] != null) {
                IFolder folder = new FolderReference(value[0][i]).resolve();
                if (folder != null)
                    addFolderLocationClause(bQuery, folder);
            }/* ww  w  . j  a  va2  s  .  c  o m*/
        }

        /* Receive BookMarks */
        for (int i = 0; value[1] != null && i < value[1].length; i++) {
            if (value[1][i] != null) {
                IBookMark bookmark = new BookMarkReference(value[1][i]).resolve();
                if (bookmark != null)
                    addBookMarkLocationClause(bQuery, bookmark);
            }
        }

        /* Receive NewsBins */
        if (value.length == 3) {
            for (int i = 0; value[2] != null && i < value[2].length; i++) {
                if (value[2][i] != null) {
                    INewsBin newsbin = new NewsBinReference(value[2][i]).resolve();
                    if (newsbin != null)
                        addNewsBinLocationClause(bQuery, newsbin);
                }
            }
        }
    }

    /* The folder could be empty, make sure to add at least 1 Clause */
    if (bQuery.clauses().isEmpty())
        bQuery.add(new TermQuery(new Term(String.valueOf(INews.FEED), "")), Occur.SHOULD); //$NON-NLS-1$

    return bQuery;
}

---

From source file:org.sakaiproject.nakamura.search.solr.SparseResultSetFactory.java

License:Apache License

/**
 * Process properties to query sparse content directly.
 *
 * @param request/*from  w ww.  j  ava 2 s. c  o m*/
 * @param query
 * @param asAnon
 * @return
 * @throws StorageClientException
 * @throws AccessDeniedException
 */
public SolrSearchResultSet processQuery(SlingHttpServletRequest request, Query query, boolean asAnon)
        throws SolrSearchException {
    try {
        // use solr parsing to get the terms from the query string
        QueryParser parser = new QueryParser(Version.LUCENE_40, "id", new TextField().getQueryAnalyzer());
        org.apache.lucene.search.Query luceneQuery = parser.parse(query.getQueryString());

        Map<String, Object> props = Maps.newHashMap();
        if (luceneQuery instanceof BooleanQuery) {
            BooleanQuery boolLucQuery = (BooleanQuery) luceneQuery;

            int orCount = 0;
            List<BooleanClause> clauses = boolLucQuery.clauses();
            for (BooleanClause clause : clauses) {
                org.apache.lucene.search.Query clauseQuery = clause.getQuery();
                Map<String, Object> subOrs = Maps.newHashMap();
                // we support 1 level of nesting for OR clauses
                if (clauseQuery instanceof BooleanQuery) {
                    BooleanQuery bq = (BooleanQuery) clauseQuery;
                    List<BooleanClause> subClauses = bq.clauses();
                    for (BooleanClause subclause : subClauses) {
                        org.apache.lucene.search.Query subclauseQuery = subclause.getQuery();
                        extractTerms(subclause, subclauseQuery, props, subOrs);
                    }
                    props.put("orset" + orCount, subOrs);
                    orCount++;
                } else {
                    extractTerms(clause, clauseQuery, props, subOrs);
                    if (!subOrs.isEmpty()) {
                        props.put("orset" + orCount, subOrs);
                        orCount++;
                    }
                }
            }
        } else {
            extractTerms(null, luceneQuery, props, null);
        }

        // add the options to the parameters but prepend _ to avoid collision
        for (Entry<String, Object> option : query.getOptions().entrySet()) {
            props.put("_" + option.getKey(), option.getValue());
        }

        String name = query.getName();
        if (name != null) {
            props.put(StorageConstants.CUSTOM_STATEMENT_SET, name);
        }

        Session session = StorageClientUtils
                .adaptToSession(request.getResourceResolver().adaptTo(javax.jcr.Session.class));
        ContentManager cm = session.getContentManager();
        long tquery = System.currentTimeMillis();
        Iterable<Content> items = cm.find(props);
        tquery = System.currentTimeMillis() - tquery;
        try {
            if (tquery > verySlowQueryThreshold) {
                SLOW_QUERY_LOGGER.error("Very slow sparse query {} ms {} ", tquery,
                        URLDecoder.decode(query.toString(), "UTF-8"));
            } else if (tquery > slowQueryThreshold) {
                SLOW_QUERY_LOGGER.warn("Slow sparse query {} ms {} ", tquery,
                        URLDecoder.decode(query.toString(), "UTF-8"));
            }
        } catch (UnsupportedEncodingException e) {
            // quietly swallow this exception
            LOGGER.debug(e.getLocalizedMessage(), e);
        }
        SolrSearchResultSet rs = new SparseSearchResultSet(items, defaultMaxResults);
        return getResultSetWithCount(rs, props, cm);
    } catch (AccessDeniedException e) {
        throw new SolrSearchException(500, e.getMessage());
    } catch (StorageClientException e) {
        throw new SolrSearchException(500, e.getMessage());
    } catch (ParseException e) {
        throw new SolrSearchException(500, e.getMessage());
    }
}

---

From source file:org.silverpeas.core.index.search.model.IndexSearcher.java

License:Open Source License

/**
 * Search the documents of the given component's set. All entries found whose startDate is not
 * reached or whose endDate is passed are pruned from the results set.
 * @param query the query.//from  www.  ja  va  2s .  c o m
 * @return an array of index entries.
 * @throws org.silverpeas.core.index.search.model.ParseException on parse error
 */
public MatchingIndexEntry[] search(QueryDescription query)
        throws org.silverpeas.core.index.search.model.ParseException {
    return doSearch(() -> {
        long startTime = System.nanoTime();
        List<MatchingIndexEntry> results;

        org.apache.lucene.search.IndexSearcher searcher = getSearcher(query);

        try {
            BooleanQuery.Builder booleanQueryBuilder = new BooleanQuery.Builder();
            BooleanQuery.Builder rangeClausesBuilder = new BooleanQuery.Builder();
            rangeClausesBuilder.add(getVisibilityStartQuery(), BooleanClause.Occur.MUST);
            rangeClausesBuilder.add(getVisibilityEndQuery(), BooleanClause.Occur.MUST);
            // filtering on searched scopes
            booleanQueryBuilder.add(getScopeQuery(query), BooleanClause.Occur.FILTER);

            parseQuery(query, booleanQueryBuilder, rangeClausesBuilder);

            // date range clauses are passed in the filter to optimize search performances
            // but the query cannot be empty : if so, then pass date range in the query
            BooleanQuery booleanQuery = booleanQueryBuilder.build();
            BooleanQuery rangeClauses = rangeClausesBuilder.build();
            TopDocs topDocs;
            if (booleanQuery.clauses().isEmpty()) {
                topDocs = searcher.search(rangeClauses, maxNumberResult);
            } else {
                booleanQueryBuilder.add(rangeClauses, BooleanClause.Occur.FILTER);
                booleanQuery = booleanQueryBuilder.build();
                topDocs = searcher.search(booleanQuery, maxNumberResult);
            }

            results = makeList(topDocs, query, searcher);
        } catch (IOException ioe) {
            SilverLogger.getLogger(this).error("Index file corrupted", ioe);
            results = new ArrayList<>();
        }
        long endTime = System.nanoTime();

        SilverLogger.getLogger(this).debug(
                () -> MessageFormat.format(" search duration in {0}ms", (endTime - startTime) / 1000000));
        return results.toArray(new MatchingIndexEntry[0]);
    }, () -> new MatchingIndexEntry[0]);
}

---

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

License:Apache License

/**
 * If the query contains only Occur.MUST_NOT clauses,
 * this will add a MatchAllDocsQuery./* ww  w.  j  av  a  2s  .  c om*/
 * @return query
 */
private Query rewriteAllNegative(Query q) {

    if (q instanceof BooleanQuery) {
        BooleanQuery bq = (BooleanQuery) q;

        List<BooleanClause> clauses = bq.clauses();
        if (clauses.size() == 0) {
            return q;
        }
        for (BooleanClause clause : clauses) {
            if (!clause.getOccur().equals(Occur.MUST_NOT)) {
                //something other than must_not exists, stop here and return q
                return q;
            }
        }
        BooleanQuery.Builder b = new BooleanQuery.Builder();
        for (BooleanClause clause : bq.clauses()) {
            b.add(clause);
        }
        b.add(new MatchAllDocsQuery(), Occur.MUST);
        return b.build();
    }
    return q;
}

---

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

License:Apache License

public void testBooleanQueryConstruction() throws Exception {
    String s = "cat dog AND elephant aardvark";
    Query q = PARSER.parse(s);//from   www . j av  a 2s  .  c o  m
    assertTrue(q instanceof BooleanQuery);
    BooleanQuery bq = (BooleanQuery) q;
    List<BooleanClause> clauses = bq.clauses();
    assertEquals(4, clauses.size());
    testForClause(clauses, "cat", Occur.SHOULD);
    testForClause(clauses, "dog", Occur.MUST);
    testForClause(clauses, "elephant", Occur.MUST);
    testForClause(clauses, "aardvark", Occur.SHOULD);

    s = "cat dog NOT elephant aardvark";
    q = PARSER.parse(s);
    assertTrue(q instanceof BooleanQuery);
    bq = (BooleanQuery) q;
    clauses = bq.clauses();
    assertEquals(4, clauses.size());
    testForClause(clauses, "cat", Occur.SHOULD);
    testForClause(clauses, "dog", Occur.SHOULD);
    testForClause(clauses, "elephant", Occur.MUST_NOT);
    testForClause(clauses, "aardvark", Occur.SHOULD);

    s = "cat +dog -elephant +aardvark";
    q = PARSER.parse(s);
    assertTrue(q instanceof BooleanQuery);
    bq = (BooleanQuery) q;
    clauses = bq.clauses();
    assertEquals(4, clauses.size());
    testForClause(clauses, "cat", Occur.SHOULD);
    testForClause(clauses, "dog", Occur.MUST);
    testForClause(clauses, "elephant", Occur.MUST_NOT);
    testForClause(clauses, "aardvark", Occur.MUST);
}

---

From source file:org.yes.cart.domain.query.impl.AttributiveSearchQueryBuilderImpl.java

License:Apache License

private BooleanQuery addKeyValue(final BooleanQuery query, final String attributeName,
        final String attributeValue) {

    final BooleanQuery aggregatedQuery = new BooleanQuery();

    final BooleanQuery productAttrNames = new BooleanQuery();
    productAttrNames.add(new TermQuery(new Term(ATTRIBUTE_CODE_FIELD, attributeName)),
            BooleanClause.Occur.SHOULD);
    productAttrNames.add(new TermQuery(new Term(SKU_ATTRIBUTE_CODE_FIELD, attributeName)),
            BooleanClause.Occur.SHOULD);

    final BooleanQuery productAttrVal = new BooleanQuery();
    productAttrVal.add(new TermQuery(new Term(ATTRIBUTE_VALUE_FIELD, attributeName + attributeValue)),
            BooleanClause.Occur.SHOULD);
    productAttrVal.add(new TermQuery(new Term(SKU_ATTRIBUTE_VALUE_FIELD, attributeName + attributeValue)),
            BooleanClause.Occur.SHOULD);

    if (!query.clauses().isEmpty()) {
        aggregatedQuery.add(query, BooleanClause.Occur.MUST);
    }//from w w w.  ja  v  a 2  s . c o  m

    aggregatedQuery.add(productAttrNames, BooleanClause.Occur.MUST);
    aggregatedQuery.add(productAttrVal, BooleanClause.Occur.MUST);

    return aggregatedQuery;

}

---

From source file:project.lucene.RelativeTermWeightQuery.java

License:Apache License

protected Query buildQuery(final int totalDocs, final TermContext[] contextArray, final Term[] queryTerms) {
    BooleanQuery query = new BooleanQuery(true);
    Set<TermWeight> weights = new TreeSet<TermWeight>();

    double totalIdf = 0.0;
    for (int i = 0; i < queryTerms.length; i++) {
        if (contextArray[i] != null) {
            TermWeight weight = new TermWeight(totalDocs, contextArray[i].docFreq(), queryTerms[i]);
            totalIdf += weight.idf;//from   w  w  w . ja  va 2  s. co  m
            weights.add(weight);
        }
    }

    double runningWeight = 0.0;
    for (TermWeight weight : weights) {
        if (runningWeight > threshold && query.clauses().size() >= mm) {
            break;
        }
        query.add(new TermQuery(weight.queryTerm), BooleanClause.Occur.SHOULD);
        runningWeight += weight.idf / totalIdf;
    }

    query.setBoost(getBoost());
    return query;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• »