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

List of usage examples for org.apache.lucene.search BooleanQuery BooleanQuery

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.search.*
  5. BooleanQuery
  6. BooleanQuery

Introduction

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

Prototype

BooleanQuery

Source Link

Usage

From source file:com.zimbra.cs.index.AbstractIndexStoreTest.java

License:Open Source License

@Test
public void booleanQuery() throws Exception {
    ZimbraLog.test.debug("--->TEST booleanQuery");
    Mailbox mbox = MailboxManager.getInstance().getMailboxByAccountId(MockProvisioning.DEFAULT_ACCOUNT_ID);
    Contact contact = createContact(mbox, "First", "Last", "f.last@zimbra.com",
            "Software Development Engineer");
    createContact(mbox, "Given", "Surname", "GiV.SurN@zimbra.com");
    mbox.index.indexDeferredItems(); // Make sure all indexing has been done

    IndexStore index = mbox.index.getIndexStore();
    ZimbraIndexSearcher searcher = index.openSearcher();
    // This seems to be the supported way of enabling leading wildcard queries
    QueryParser queryParser = new QueryParser(LuceneIndex.VERSION, LuceneFields.L_CONTACT_DATA,
            new StandardAnalyzer(LuceneIndex.VERSION));
    queryParser.setAllowLeadingWildcard(true);
    Query wquery = queryParser.parse("*irst");
    Query tquery = new TermQuery(new Term(LuceneFields.L_CONTACT_DATA, "absent"));
    Query tquery2 = new TermQuery(new Term(LuceneFields.L_CONTACT_DATA, "Last"));
    BooleanQuery bquery = new BooleanQuery();
    bquery.add(wquery, Occur.MUST);//from w w  w  . ja v  a  2s .c o m
    bquery.add(tquery, Occur.MUST_NOT);
    bquery.add(tquery2, Occur.SHOULD);
    ZimbraTopDocs result = searcher.search(bquery, 100);
    Assert.assertNotNull("searcher.search result object", result);
    ZimbraLog.test.debug("Result for search [hits=%d]:%s", result.getTotalHits(), result.toString());
    Assert.assertEquals("Number of hits", 1, result.getTotalHits());
    String expected1Id = String.valueOf(contact.getId());
    String match1Id = searcher.doc(result.getScoreDoc(0).getDocumentID()).get(LuceneFields.L_MAILBOX_BLOB_ID);
    Assert.assertEquals("Mailbox Blob ID of match", expected1Id, match1Id);
}

From source file:com.zimbra.cs.index.LuceneQueryOperation.java

License:Open Source License

/**
 * Adds the specified text clause at the top level.
 * <p>/*  w  w  w.jav a 2 s. c o  m*/
 * e.g. going in "a b c" if we addClause("d") we get "a b c d".
 *
 * @param queryStr Appended to the end of the text-representation of this query
 * @param query Lucene query
 * @param bool allows for negated query terms
 */
public void addClause(String queryStr, Query query, boolean bool) {
    assert (!haveRunSearch);

    // ignore empty BooleanQuery
    if (query instanceof BooleanQuery && ((BooleanQuery) query).clauses().isEmpty()) {
        return;
    }

    if (queryString.isEmpty()) {
        queryString = (bool ? "" : "-") + queryStr;
    } else {
        queryString = queryString + " " + (bool ? "" : "-") + queryStr;
    }

    if (bool) {
        if (luceneQuery == null) {
            luceneQuery = query;
        } else if (luceneQuery instanceof BooleanQuery) {
            ((BooleanQuery) luceneQuery).add(query, BooleanClause.Occur.MUST);
        } else if (query instanceof BooleanQuery) {
            ((BooleanQuery) query).add(luceneQuery, BooleanClause.Occur.MUST);
            luceneQuery = query;
        } else {
            BooleanQuery combined = new BooleanQuery();
            combined.add(luceneQuery, BooleanClause.Occur.MUST);
            combined.add(query, BooleanClause.Occur.MUST);
            luceneQuery = combined;
        }
    } else {
        if (luceneQuery == null) {
            BooleanQuery negate = new BooleanQuery();
            negate.add(query, BooleanClause.Occur.MUST_NOT);
            luceneQuery = negate;
        } else if (luceneQuery instanceof BooleanQuery) {
            ((BooleanQuery) luceneQuery).add(query, BooleanClause.Occur.MUST_NOT);
        } else {
            BooleanQuery combined = new BooleanQuery();
            combined.add(luceneQuery, BooleanClause.Occur.MUST);
            combined.add(query, BooleanClause.Occur.MUST_NOT);
            luceneQuery = combined;
        }
    }
}

From source file:com.zimbra.cs.index.LuceneQueryOperation.java

License:Open Source License

/**
 * Adds the specified text clause ANDED with the existing query.
 * <p>/*from   www .  ja v  a  2s  .c  o m*/
 * e.g. going in w/ "a b c" if we addAndedClause("d") we get "(a b c) AND d".
 * <p>
 * This API may only be called AFTER query optimizing and AFTER remote queries have been split.
 * <p>
 * Note that this API does *not* update the text-representation of this query.
 */
void addAndedClause(Query query, boolean bool) {
    assert (luceneQuery != null);
    haveRunSearch = false; // will need to re-run the search with this new clause
    curHitNo = 0;

    if (luceneQuery instanceof BooleanQuery) {
        BooleanQuery bquery = ((BooleanQuery) luceneQuery);
        boolean orOnly = true;
        for (BooleanClause clause : bquery) {
            if (clause.getOccur() != BooleanClause.Occur.SHOULD) {
                orOnly = false;
                break;
            }
        }
        if (!orOnly) {
            bquery.add(
                    new BooleanClause(query, bool ? BooleanClause.Occur.MUST : BooleanClause.Occur.MUST_NOT));
            return;
        }
    }

    BooleanQuery bquery = new BooleanQuery();
    bquery.add(new BooleanClause(luceneQuery, BooleanClause.Occur.MUST));
    bquery.add(new BooleanClause(query, bool ? BooleanClause.Occur.MUST : BooleanClause.Occur.MUST_NOT));
    luceneQuery = bquery;
}

From source file:com.zimbra.cs.index.LuceneQueryOperation.java

License:Open Source License

@Override
protected QueryOperation combineOps(QueryOperation other, boolean union) {
    assert (!haveRunSearch);

    if (union) {/* w  w  w.j  a v  a2 s.  c om*/
        if (other.hasNoResults()) {
            queryInfo.addAll(other.getResultInfo());
            // a query for (other OR nothing) == other
            return this;
        }
    } else {
        if (other.hasAllResults()) {
            if (other.hasSpamTrashSetting()) {
                forceHasSpamTrashSetting();
            }
            queryInfo.addAll(other.getResultInfo());
            // we match all results.  (other AND anything) == other
            return this;
        }
    }

    if (other instanceof LuceneQueryOperation) {
        LuceneQueryOperation otherLucene = (LuceneQueryOperation) other;
        if (union) {
            queryString = '(' + queryString + ") OR (" + otherLucene.queryString + ')';
        } else {
            queryString = '(' + queryString + ") AND (" + otherLucene.queryString + ')';
        }

        BooleanQuery top = new BooleanQuery();
        if (union) {
            if (luceneQuery instanceof BooleanQuery) {
                orCopy((BooleanQuery) luceneQuery, top);
            } else {
                top.add(new BooleanClause(luceneQuery, Occur.SHOULD));
            }
            if (otherLucene.luceneQuery instanceof BooleanQuery) {
                orCopy((BooleanQuery) otherLucene.luceneQuery, top);
            } else {
                top.add(new BooleanClause(otherLucene.luceneQuery, Occur.SHOULD));
            }
        } else {
            if (luceneQuery instanceof BooleanQuery) {
                andCopy((BooleanQuery) luceneQuery, top);
            } else {
                top.add(new BooleanClause(luceneQuery, Occur.MUST));
            }
            if (otherLucene.luceneQuery instanceof BooleanQuery) {
                andCopy((BooleanQuery) otherLucene.luceneQuery, top);
            } else {
                top.add(new BooleanClause(otherLucene.luceneQuery, Occur.MUST));
            }
        }
        luceneQuery = top;
        queryInfo.addAll(other.getResultInfo());
        if (other.hasSpamTrashSetting()) {
            forceHasSpamTrashSetting();
        }
        return this;
    }
    return null;
}

From source file:com.zimbra.cs.service.admin.GetMailQueue.java

License:Open Source License

public static Query buildLuceneQuery(Element queryElem) throws ServiceException {
    BooleanQuery fq = new BooleanQuery();
    boolean emptyQuery = true;
    for (Iterator fieldIter = queryElem.elementIterator(AdminConstants.E_FIELD); fieldIter.hasNext();) {
        emptyQuery = false;//from  w  ww . j a v a2s .c  o m
        Element fieldElement = (Element) fieldIter.next();
        String fieldName = fieldElement.getAttribute(AdminConstants.A_NAME);
        BooleanQuery mq = new BooleanQuery();
        for (Iterator matchIter = fieldElement.elementIterator(AdminConstants.E_MATCH); matchIter.hasNext();) {
            Element matchElement = (Element) matchIter.next();
            String matchValue = matchElement.getAttribute(AdminConstants.A_VALUE);
            Term term = new Term(fieldName, matchValue);
            mq.add(new TermQuery(term), Occur.SHOULD);
        }
        fq.add(mq, Occur.MUST);
    }
    if (emptyQuery) {
        return null;
    } else {
        return fq;
    }
}

From source file:db.infiniti.config.HighFreqTerms.java

License:Apache License

private String getTheBestMatchingTerm(IndexReader indexReader, TermStats[] terms, ArrayList<String> sentQueries,
        ArrayList<String> initialQuery) {
    String specificFreqTerm = "";
    if (sentQueries.size() == 0 && terms.length > 0) {
        String temp = terms[0].term + "";
        temp = temp.substring(temp.indexOf(":") + 1, temp.length());
        return temp;
    }//w  w  w .j a v a 2 s .co m

    HashMap<String, Integer> averageOfEach = new HashMap<String, Integer>();
    for (int i = 0; i < terms.length; i++) {
        String temp = terms[i].term + "";
        String queryATerm = temp.substring(temp.indexOf(":") + 1, temp.length());
        try {
            // indexReader = IndexReader.open(indexDirectory);
            IndexSearcher indexSearcher = new IndexSearcher(indexReader);
            // int n = w.numDocs();
            BooleanQuery bq = new BooleanQuery();
            int totalNumberOfResults = 0;
            // double average = 0;
            for (String queryB : sentQueries) {
                Term term1 = new Term("text", queryATerm);
                TermQuery query1 = new TermQuery(term1);
                Term term2 = new Term("text", queryB);
                TermQuery query2 = new TermQuery(term2);

                bq.add(query1, BooleanClause.Occur.MUST);
                bq.add(query2, BooleanClause.Occur.MUST);
                int numberOfResults = 0;
                HitCollector results;
                int n = indexReader.maxDoc();
                TopDocs hits = indexSearcher.search(bq, n);

                /*   if (hits.totalHits > 0 ){
                      System.out.println();
                   }*/
                totalNumberOfResults = totalNumberOfResults + hits.totalHits;
            }
            averageOfEach.put(queryATerm, totalNumberOfResults);
            // average = (double) totalNumberOfResults / (double)
            // sentQueries.size();

        } catch (CorruptIndexException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    Set<Entry<String, Integer>> set = averageOfEach.entrySet();
    List<Entry<String, Integer>> list = new ArrayList<Entry<String, Integer>>(set);
    Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
        public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
            return (o2.getValue()).compareTo(o1.getValue());
        }
    });
    System.out.println("sorted by relevance to previous submitted queries: ");
    for (Map.Entry<String, Integer> entry : list) {
        System.out.println(entry.getKey() + " ==== " + entry.getValue());
    }
    int i = list.size() - 1;
    while (i >= 0) {
        specificFreqTerm = list.get(i).getKey();
        if (!initialQuery.contains(specificFreqTerm)) {
            return specificFreqTerm;
        } else {
            i--;
        }
    }

    return specificFreqTerm;
}

From source file:dcu.com.ie.patent.queryreduction.PatentMagdyQueryReduction.java

License:Apache License

/**
 * Performs Rocchio's query expansion with pseudo feedback for each fields
 * separatlly qm = alpha * query + ( beta / relevanDocsCount ) * Sum ( rel
 * docs vector )//w w w .j  ava  2  s.co  m
 *
 * @param query
 *
 * @return expandedQuery
 *
 * @throws IOException
 * @throws ParseException
 */
@Override
public Query expandQuery(PatentQuery query) throws ParseException, IOException {
    IndexReader ir = searcher.getIndexReader();
    BooleanQuery bQuery = new BooleanQuery();
    BooleanQuery bQueryFieldsExpanded = new BooleanQuery();
    BooleanQuery.setMaxClauseCount(Integer.MAX_VALUE);
    //*****************************************************************
    //**************** Compute the PRF for field (i)******************* 
    //*****************************************************************
    TotalHitCountCollector collector = new TotalHitCountCollector();
    searcher.search(query.parse(), collector);
    TopDocs hits = searcher.search(query.parse(), Math.max(1, collector.getTotalHits())); // Compute PRF set

    //                System.err.println(hits.totalHits + " total matching documents for field " + query.getFields()[i] + ".");
    Query expandedQuery = null;
    MagdyQueryReduction qe = new MagdyQueryReduction(hits, ir, PatentQuery.getFields()[source], Nbr_Docs,
            Nbr_Terms);

    for (int i = 1; i < PatentQuery.getFields().length; i++) {
        if (query.getQueries()[i] != null && !query.getQueries()[i].equals("") && (i != 4 || i != 6)
                && query.getBoosts().get(PatentQuery.getFields()[i]) != 0) {
            QueryParser qp = new QueryParser(Version.LUCENE_48, PatentQuery.getFields()[i],
                    new StandardAnalyzer(Version.LUCENE_48));
            //                BooleanQuery bQueryFields = new BooleanQuery();// Contain a field to make the PRF field by field
            Query q = qp.parse(query.getQueries()[i]);
            //                if (query.isFilter()) {
            //                    Query filter = new QueryParser(Version.LUCENE_48, PatentQuery.getFields()[0],
            //                            new StandardAnalyzer(Version.LUCENE_48)).parse(query.getQueries()[0]);
            //                    bQueryFields.add(filter, BooleanClause.Occur.MUST);
            //                }
            //                if (!(q instanceof BooleanQuery) || ((BooleanQuery) q).getClauses().length > 0) {
            //                    bQueryFields.add(q, BooleanClause.Occur.MUST);
            //                }
            if (expandedQuery == null) {
                expandedQuery = qe.reduceQuery(q, PatentQuery.getFields()[i]);
            } else {
                BooleanQuery bq = ((BooleanQuery) expandedQuery).clone();
                BooleanQuery bq2 = new BooleanQuery();
                for (BooleanClause bc : bq.clauses()) {
                    TermQuery tq = (TermQuery) bc.getQuery();
                    Term term = new Term(PatentQuery.getFields()[i], tq.getTerm().text());
                    TermQuery tq2 = new TermQuery(term);
                    tq2.setBoost(tq.getBoost());
                    bq2.add(tq2, BooleanClause.Occur.SHOULD);
                }
                expandedQuery = bq2;
            }
            bQueryFieldsExpanded.add(expandedQuery, BooleanClause.Occur.SHOULD);// Compute the new expanded query based on PRF set
            //                System.err.println("Expanded Query: " + expandedQuery);
            //                hits = searcher.search(expandedQuery, 100);
            //                System.err.println(hits.totalHits + " total matching documents"+ query.getFields()[i] + ".");
        }
    }
    if (query.isFilter()) {
        Query q = new QueryParser(Version.LUCENE_48, PatentQuery.getFields()[0],
                new StandardAnalyzer(Version.LUCENE_48)).parse(query.getQueries()[0]);
        q.setBoost(query.getBoosts().get(PatentQuery.getFields()[0]));
        bQuery.add(q, BooleanClause.Occur.MUST);
    }
    bQuery.add(bQueryFieldsExpanded, BooleanClause.Occur.MUST);
    //        TopDocs hits = searcher.search(bQuery, 100);
    //                System.err.println(hits.totalHits + " total matching documents.");
    return bQuery;
}

From source file:dcu.com.ie.synset.PatentSynSetQueryExpansion.java

@Override
public Query expandQuery(PatentQuery query) throws ParseException, IOException {
    BooleanQuery bQuery = new BooleanQuery();
    BooleanQuery bQueryFieldsExpanded = new BooleanQuery();
    BooleanQuery.setMaxClauseCount(Integer.MAX_VALUE);
    Query expandedQuery = null;//from   w w w  . j  a  v  a 2s. c om
    for (int i = 1; i < PatentQuery.getFields().length; i++) {
        if (query.getQueries()[i] != null && !query.getQueries()[i].equals("") && (i != 4 || i != 6)
                && query.getBoosts().get(PatentQuery.getFields()[i]) != 0) {
            QueryParser qp = new QueryParser(Version.LUCENE_48, PatentQuery.getFields()[i],
                    new StandardAnalyzer(Version.LUCENE_48));
            Query q = qp.parse(query.getQueries()[i]);
            if (expandedQuery == null) {
                BooleanQuery bq;
                if (q instanceof BooleanQuery) {
                    bq = ((BooleanQuery) q).clone();
                } else {
                    bq = new BooleanQuery();
                    bq.add(q, BooleanClause.Occur.SHOULD);
                }

                BooleanQuery bq2 = new BooleanQuery();
                for (BooleanClause bc : bq.clauses()) {
                    TermQuery tq = (TermQuery) bc.getQuery();
                    bq2.add(tq, BooleanClause.Occur.SHOULD);
                    //                        System.err.println(tq.getTerm().text());
                    List<Map.Entry<String, Double>> l = synset.getSynSeyList(tq.getTerm().text(), Nbr_Terms);
                    for (Map.Entry<String, Double> e : l) {
                        //                            System.err.println("\t" + e.getKey() + " -> " + e.getValue());
                        Term term = new Term(PatentQuery.getFields()[i], e.getKey());
                        TermQuery tq2 = new TermQuery(term);
                        float boost = tq.getBoost();
                        if (weigth) {
                            boost *= e.getValue().floatValue();
                        }
                        tq2.setBoost(boost);
                        bq2.add(tq2, BooleanClause.Occur.SHOULD);
                    }
                }
                expandedQuery = bq2;
            } else {
                BooleanQuery bq = ((BooleanQuery) expandedQuery).clone();
                BooleanQuery bq2 = new BooleanQuery();
                for (BooleanClause bc : bq.clauses()) {
                    TermQuery tq = (TermQuery) bc.getQuery();
                    Term term = new Term(PatentQuery.getFields()[i], tq.getTerm().text());
                    TermQuery tq2 = new TermQuery(term);
                    tq2.setBoost(tq.getBoost());
                    bq2.add(tq2, BooleanClause.Occur.SHOULD);
                }
                expandedQuery = bq2;
            }
            bQueryFieldsExpanded.add(expandedQuery, BooleanClause.Occur.SHOULD);

        }
    }
    if (query.isFilter()) {
        Query q = new QueryParser(Version.LUCENE_48, PatentQuery.getFields()[0],
                new StandardAnalyzer(Version.LUCENE_48)).parse(query.getQueries()[0]);
        q.setBoost(query.getBoosts().get(PatentQuery.getFields()[0]));
        bQuery.add(q, BooleanClause.Occur.MUST);
    }
    bQuery.add(bQueryFieldsExpanded, BooleanClause.Occur.MUST);
    //        TopDocs hits = searcher.search(bQuery, 100);
    //                System.err.println(hits.totalHits + " total matching documents.");
    return bQuery;
}

From source file:de.blizzy.documentr.search.GetInaccessibleDocIdsTask.java

License:Open Source License

@Override
public BitSet call() throws IOException {
    List<String> roles = userStore.listRoles();
    BooleanQuery allRolesQuery = new BooleanQuery();
    for (String role : roles) {
        TermQuery roleQuery = new TermQuery(new Term(PageIndex.VIEW_RESTRICTION_ROLE, role));
        allRolesQuery.add(roleQuery, BooleanClause.Occur.SHOULD);
    }/*from  ww w . j  a va  2s.  c  o m*/
    AbstractDocIdsCollector collector = new InaccessibleDocIdsCollector(permission, authentication,
            permissionEvaluator);
    searcher.search(allRolesQuery, collector);
    return collector.getDocIds();
}

From source file:de.blizzy.documentr.search.GetInaccessibleDocIdsTaskTest.java

License:Open Source License

@Test
public void call() throws IOException {
    when(userStore.listRoles()).thenReturn(Lists.newArrayList("reader", "editor")); //$NON-NLS-1$ //$NON-NLS-2$

    BooleanQuery query = new BooleanQuery();
    query.add(new TermQuery(new Term(PageIndex.VIEW_RESTRICTION_ROLE, "reader")), BooleanClause.Occur.SHOULD); //$NON-NLS-1$
    query.add(new TermQuery(new Term(PageIndex.VIEW_RESTRICTION_ROLE, "editor")), BooleanClause.Occur.SHOULD); //$NON-NLS-1$

    task.call();//from w ww  .jav  a 2s.  com

    verify(searcher).search(eq(query), Matchers.any(InaccessibleDocIdsCollector.class));
}