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

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

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

Introduction

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

Prototype

public static int getMaxClauseCount()

Source Link

Document

Return the maximum number of clauses permitted, 1024 by default.

Usage

From source file:com.sindicetech.siren.qparser.keyword.builders.BooleanQueryNodeBuilder.java

License:Open Source License

public Query build(final QueryNode queryNode) throws QueryNodeException {
    final BooleanQueryNode booleanNode = (BooleanQueryNode) queryNode;

    final BooleanQuery bQuery = new BooleanQuery();
    final List<QueryNode> children = booleanNode.getChildren();

    if (children != null) {

        for (final QueryNode child : children) {
            final Object obj = child.getTag(QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID);

            if (obj != null) {
                final Query query = (Query) obj;

                try {
                    final QueryNode mod;
                    if (child instanceof DatatypeQueryNode) {
                        mod = ((DatatypeQueryNode) child).getChild();
                    } else {
                        mod = child;/*w  w w  . j a va2  s  .c o  m*/
                    }
                    bQuery.add(query, getModifierValue(mod));

                } catch (final TooManyClauses ex) {

                    throw new QueryNodeException(new MessageImpl(QueryParserMessages.TOO_MANY_BOOLEAN_CLAUSES,
                            BooleanQuery.getMaxClauseCount(),
                            queryNode.toQueryString(new EscapeQuerySyntaxImpl())), ex);

                }

            }

        }

    }

    return bQuery;

}

From source file:com.sindicetech.siren.qparser.tree.builders.BooleanQueryNodeBuilder.java

License:Open Source License

private final BooleanSpanQuery buildBooleanSpanQuery(BooleanQueryNode booleanNode) throws QueryNodeException {
    // check if the node has a slop
    int slop = this.DEFAULT_SLOP;
    if (booleanNode.getTag(SlopPropertyParser.SLOP_PROPERTY) != null) {
        slop = (Integer) booleanNode.getTag(SlopPropertyParser.SLOP_PROPERTY);
    }//w ww. j a  va  2 s  .  c  o m

    // check if the node has a inOrder flag
    boolean inOrder = this.DEFAULT_INORDER;
    if (booleanNode.getTag(InOrderPropertyParser.IN_ORDER_PROPERTY) != null) {
        int tag = (Integer) booleanNode.getTag(InOrderPropertyParser.IN_ORDER_PROPERTY);
        inOrder = tag == 0 ? false : true;
    }

    // build the query and add clauses
    final BooleanSpanQuery bsq = new BooleanSpanQuery(slop, inOrder);
    for (final QueryNode child : booleanNode.getChildren()) {
        final Object obj = child.getTag(QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID);
        try {
            bsq.add(new NodeSpanQuery((NodeQuery) obj), this.getNodeModifierValue(child));
        } catch (final BooleanQuery.TooManyClauses ex) {
            throw new QueryNodeException(new MessageImpl(QueryParserMessages.TOO_MANY_BOOLEAN_CLAUSES,
                    BooleanQuery.getMaxClauseCount(), booleanNode.toQueryString(new EscapeQuerySyntaxImpl())),
                    ex);
        }
    }

    // check if the node has a node range constraint
    if (booleanNode.getTag(RangePropertyParser.RANGE_PROPERTY) != null) {
        final int[] range = (int[]) booleanNode.getTag(RangePropertyParser.RANGE_PROPERTY);
        bsq.setNodeConstraint(range[0], range[1]);
    }

    return bsq;
}

From source file:com.sindicetech.siren.qparser.tree.builders.BooleanQueryNodeBuilder.java

License:Open Source License

private final BooleanQuery buildBooleanQuery(BooleanQueryNode booleanNode) throws QueryNodeException {
    // build the query and add clauses
    final BooleanQuery bq = new BooleanQuery(true);

    for (final QueryNode child : booleanNode.getChildren()) {
        final Object obj = child.getTag(QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID);
        try {//from w w w  . j  av a  2 s  .  co m
            Query q = (Query) obj;
            if (obj instanceof NodeQuery) {
                // wrap the query into a LuceneProxyNodeQuery
                q = new LuceneProxyNodeQuery((NodeQuery) q);
            }
            bq.add(q, this.getLuceneModifierValue(child));
        } catch (final BooleanQuery.TooManyClauses ex) {
            throw new QueryNodeException(new MessageImpl(QueryParserMessages.TOO_MANY_BOOLEAN_CLAUSES,
                    BooleanQuery.getMaxClauseCount(), booleanNode.toQueryString(new EscapeQuerySyntaxImpl())),
                    ex);
        }
    }

    return bq;
}

From source file:com.sindicetech.siren.qparser.tree.builders.TwigQueryNodeBuilder.java

License:Open Source License

@Override
public TwigQuery build(final QueryNode queryNode) throws QueryNodeException {
    final TwigQueryNode twigNode = (TwigQueryNode) queryNode;
    final List<QueryNode> children = twigNode.getChildren();
    final TwigQuery query = new TwigQuery();

    // check if the node has a level constraint
    if (twigNode.getTag(LevelPropertyParser.LEVEL_PROPERTY) != null) {
        query.setLevelConstraint((Integer) twigNode.getTag(LevelPropertyParser.LEVEL_PROPERTY));
    }// w  w w  .  j  a v a2  s.  c o  m

    // check if the node has a node range constraint
    if (twigNode.getTag(RangePropertyParser.RANGE_PROPERTY) != null) {
        final int[] range = (int[]) twigNode.getTag(RangePropertyParser.RANGE_PROPERTY);
        query.setNodeConstraint(range[0], range[1]);
    }

    // process root query
    this.processRoot(twigNode, query);

    // process child and descendant queries
    try {
        this.processChildren(children, query);
    } catch (final TooManyClauses ex) {
        throw new QueryNodeException(new MessageImpl(QueryParserMessages.TOO_MANY_BOOLEAN_CLAUSES,
                BooleanQuery.getMaxClauseCount(), twigNode.toQueryString(new EscapeQuerySyntaxImpl())), ex);
    }

    return query;
}

From source file:de.ilias.services.lucene.search.RPCSearchHandler.java

License:Open Source License

/**
 * Multi field searcher/*from   ww  w  .  jav  a2  s  .  c  o  m*/
 * Searches in all defined fields.
 * @todo allow configuration of searchable fields.
 * 
 * 
 * @param clientKey
 * @param query
 */
public String search(String clientKey, String queryString, int pageNumber) {

    LuceneSettings luceneSettings;
    LocalSettings.setClientKey(clientKey);
    IndexSearcher searcher;
    FieldInfo fieldInfo;
    String rewrittenQuery;

    logger.info("Query is: " + queryString);

    try {

        long start = new java.util.Date().getTime();

        fieldInfo = FieldInfo.getInstance(LocalSettings.getClientKey());
        luceneSettings = LuceneSettings.getInstance(LocalSettings.getClientKey());

        // Append doctype
        searcher = SearchHolder.getInstance().getSearcher();

        // Rewrite query
        QueryRewriter rewriter = new QueryRewriter(QueryRewriter.MODE_SEARCH, queryString);
        rewrittenQuery = rewriter.rewrite();

        Vector<Occur> occurs = new Vector<Occur>();
        for (int i = 0; i < fieldInfo.getFieldSize(); i++) {
            occurs.add(BooleanClause.Occur.SHOULD);
        }

        MultiFieldQueryParser multiParser = new MultiFieldQueryParser(fieldInfo.getFieldsAsStringArray(),
                new StandardAnalyzer());

        if (luceneSettings.getDefaultOperator() == LuceneSettings.OPERATOR_AND) {
            multiParser.setDefaultOperator(Operator.AND);
        } else {
            multiParser.setDefaultOperator(Operator.OR);
        }

        BooleanQuery.setMaxClauseCount(10000);
        BooleanQuery query = (BooleanQuery) multiParser.parse(rewrittenQuery);
        logger.info("Max clauses allowed: " + BooleanQuery.getMaxClauseCount());

        //BooleanQuery query = (BooleanQuery) MultiFieldQueryParser.parse(rewrittenQuery,
        //      fieldInfo.getFieldsAsStringArray(),
        //      occurs.toArray(new Occur[0]),
        //      new StandardAnalyzer());

        for (Object f : fieldInfo.getFields()) {
            logger.info(((String) f).toString());
        }

        TopDocCollector collector = new TopDocCollector(1000);
        long s_start = new java.util.Date().getTime();
        searcher.search(query, collector);
        long s_end = new java.util.Date().getTime();
        ScoreDoc[] hits = collector.topDocs().scoreDocs;

        SearchResultWriter writer = new SearchResultWriter(hits);
        writer.setOffset(SearchHolder.SEARCH_LIMIT * (pageNumber - 1));
        writer.write();

        long end = new java.util.Date().getTime();
        logger.info("Total time: " + (end - start));
        logger.info("Query time: " + (s_end - s_start));

        return writer.toXML();
    } catch (ConfigurationException e) {
        logger.error(e);
    } catch (IOException e) {
        logger.warn(e);
    } catch (ParseException e) {
        logger.info(e);
    } catch (Exception e) {

        StringWriter writer = new StringWriter();
        e.printStackTrace(new PrintWriter(writer));
        logger.error(writer.toString());
    }
    return "";
}

From source file:edu.cmu.lti.oaqa.knn4qa.cand_providers.LuceneCandidateProvider.java

License:Apache License

@Override
public CandidateInfo getCandidates(int queryNum, Map<String, String> queryData, int maxQty) throws Exception {

    ArrayList<CandidateEntry> resArr = new ArrayList<CandidateEntry>();

    String queryID = queryData.get(ID_FIELD_NAME);
    if (null == queryID) {
        throw new Exception(
                String.format("Query id (%s) is undefined for query # %d", ID_FIELD_NAME, queryNum));
    }//from w ww  .  j  av a  2s. co m

    String text = queryData.get(TEXT_FIELD_NAME);
    if (null == text) {
        throw new Exception(String.format("Query (%s) is undefined for query # %d", TEXT_FIELD_NAME, queryNum));
    }

    String query = text.trim();

    ArrayList<String> toks = new ArrayList<String>();
    for (String s : mSpaceSplit.split(query)) {
        toks.add(s);
    }
    if (2 * toks.size() > BooleanQuery.getMaxClauseCount()) {
        // This a heuristic, but it should work fine in many cases
        BooleanQuery.setMaxClauseCount(2 * toks.size());
    }

    int numFound = 0;

    if (!query.isEmpty()) {
        // QueryParser cannot be shared among threads!
        QueryParser parser = new QueryParser(TEXT_FIELD_NAME, mAnalyzer);
        parser.setDefaultOperator(QueryParser.OR_OPERATOR);

        Query queryParsed = parser.parse(query);

        TopDocs hits = mSearcher.search(queryParsed, maxQty);
        numFound = hits.totalHits;
        ScoreDoc[] scoreDocs = hits.scoreDocs;

        for (ScoreDoc oneHit : scoreDocs) {
            Document doc = mSearcher.doc(oneHit.doc);
            String id = doc.get(ID_FIELD_NAME);
            float score = oneHit.score;

            resArr.add(new CandidateEntry(id, score));
        }
    }

    CandidateEntry[] results = resArr.toArray(new CandidateEntry[resArr.size()]);
    Arrays.sort(results);

    return new CandidateInfo(numFound, results);
}

From source file:edu.cmu.lti.oaqa.knn4qa.cand_providers.TranRecSortByProb.java

License:Apache License

@Override
public CandidateInfo getCandidates(int queryNum, Map<String, String> queryData, int maxQty) throws Exception {
    ArrayList<CandidateEntry> resArr = new ArrayList<CandidateEntry>();

    String queryID = queryData.get(ID_FIELD_NAME);
    if (null == queryID) {
        throw new Exception(
                String.format("Query id (%s) is undefined for query # %d", ID_FIELD_NAME, queryNum));
    }//from   w ww  .  j av  a2 s .co m

    String text = queryData.get(TEXT_FIELD_NAME);
    if (null == text) {
        throw new Exception(String.format("Query (%s) is undefined for query # %d", TEXT_FIELD_NAME, queryNum));
    }

    String origQuery = text.trim();
    int numFound = 0;

    if (!origQuery.isEmpty()) {
        StringBuffer queryToks = new StringBuffer();
        int tokQty = 0;

        for (String w : origQuery.split("\\s+"))
            if (!w.isEmpty()) {
                tokQty++;
                queryToks.append(w + " ");

                final WordEntry we = mFieldIndex.getWordEntry(w);
                if (we != null) {
                    GizaOneWordTranRecs rec0 = mAnswToQuestTran.getTranProbs(we.mWordId);
                    if (rec0 != null) {
                        TranRecSortByProb rec[] = new TranRecSortByProb[rec0.mDstIds.length];
                        for (int i = 0; i < rec0.mDstIds.length; ++i)
                            rec[i] = new TranRecSortByProb(rec0.mDstIds[i], rec0.mProbs[i]);
                        Arrays.sort(rec);
                        int qty = mTopTranQty;
                        for (int i = 0; i < Math.min(rec.length, qty); ++i) {
                            int dstId = rec[i].mDstWorId;
                            if (dstId != we.mWordId) {
                                queryToks.append(mFieldIndex.getWord(dstId)
                                        + (mUseWeights ? "^" + String.format("%.3f", rec[i].mProb) : "") + " ");
                                ++tokQty;
                            } else {
                                // If we skip a word, b/c it's the same as the query word
                                // we will get one more candidate so that exactly Math.min(mTopTranQty, rec.length)
                                // words were added
                                ++qty;
                            }
                        }
                    }
                }
            }

        synchronized (lock) { // this is a static lock, it will block all instance of this class
            if (tokQty > BooleanQuery.getMaxClauseCount()) {
                BooleanQuery.setMaxClauseCount(tokQty);
            }
        }

        String luceneQuery = queryToks.toString().trim();
        if (!luceneQuery.isEmpty()) {
            // QueryParser cannot be shared among threads!
            QueryParser parser = new QueryParser(TEXT_FIELD_NAME, mAnalyzer);
            parser.setDefaultOperator(QueryParser.OR_OPERATOR);

            Query queryParsed = parser.parse(luceneQuery);

            //System.out.println("The resulting query: " + luceneQuery.toString());

            TopDocs hits = mSearcher.search(queryParsed, maxQty);
            numFound = hits.totalHits;
            ScoreDoc[] scoreDocs = hits.scoreDocs;

            for (ScoreDoc oneHit : scoreDocs) {
                Document doc = mSearcher.doc(oneHit.doc);
                String id = doc.get(ID_FIELD_NAME);
                float score = oneHit.score;

                resArr.add(new CandidateEntry(id, score));
            }
        }
    }

    CandidateEntry[] results = resArr.toArray(new CandidateEntry[resArr.size()]);
    Arrays.sort(results);

    return new CandidateInfo(numFound, results);
}

From source file:lucene.LuceneCandidateProvider.java

License:Apache License

public ResEntry[] getCandidates(int queryNum, String query, int maxQty) throws Exception {
    ArrayList<String> toks = new ArrayList<String>();
    for (String s : mSpaceSplit.split(query)) {
        toks.add(s);/*from  www . j  a va 2  s.c o  m*/
    }
    if (2 * toks.size() > BooleanQuery.getMaxClauseCount()) {
        // This a heuristic, but it should work fine in many cases
        BooleanQuery.setMaxClauseCount(2 * toks.size());
    }

    ArrayList<ResEntry> resArr = new ArrayList<ResEntry>();

    Query queryParsed = mParser.parse(query);

    TopDocs hits = mSearcher.search(queryParsed, maxQty);
    ScoreDoc[] scoreDocs = hits.scoreDocs;

    for (ScoreDoc oneHit : scoreDocs) {
        Document doc = mSearcher.doc(oneHit.doc);
        String id = doc.get(UtilConst.FIELD_ID);
        float score = oneHit.score;

        resArr.add(new ResEntry(id, score));
    }

    ResEntry[] results = resArr.toArray(new ResEntry[resArr.size()]);
    Arrays.sort(results);

    return results;
}

From source file:nl.uva.DataHandler.Retrieval.java

private ScoreDoc[] searchIndex(String qText, Filter filter) throws IOException, Throwable {
    log.info("size of query: " + qText.length());
    boolean retry = true;
    ScoreDoc[] hits = null;/*ww  w. ja  v  a 2  s . com*/
    while (retry) {
        try {
            retry = false;
            Query q = this.queryCreator(qText);
            TopScoreDocCollector collector = TopScoreDocCollector.create(hitsPerReq);
            this.iSearcher.search(q, filter, collector);
            //                this.iSearcher.search(q, collector);
            hits = collector.topDocs().scoreDocs;
            return hits;
        }
        //            catch (BooleanQuery.TooManyClauses e)
        catch (Exception e) {
            // Double the number of boolean queries allowed.
            // The default is in org.apache.lucene.search.BooleanQuery and is 1024.
            String defaultQueries = Integer.toString(BooleanQuery.getMaxClauseCount());
            int oldQueries = Integer
                    .parseInt(System.getProperty("org.apache.lucene.maxClauseCount", defaultQueries));
            int newQueries = oldQueries * 2;
            log.error("Too many hits for query..., changing maxClauseCount to: " + newQueries);
            //                log.error("Too many hits for query: " + oldQueries + ".  Increasing to " + newQueries, e);
            System.setProperty("org.apache.lucene.maxClauseCount", Integer.toString(newQueries));
            BooleanQuery.setMaxClauseCount(newQueries);
            retry = true;
        }
    }
    return hits;
}

From source file:org.alfresco.repo.search.impl.lucene.AbstractLuceneQueryParser.java

License:Open Source License

/**
 * /*from  ww w.  j  a v a2  s  .com*/
 * @param mpq MultiPhraseQuery
 * @return boolean
 */
private boolean exceedsTermCount(MultiPhraseQuery mpq) {
    int termCount = 0;
    for (Iterator<?> iter = mpq.getTermArrays().iterator(); iter.hasNext(); /**/) {
        Term[] arr = (Term[]) iter.next();
        termCount += arr.length;
        if (termCount > BooleanQuery.getMaxClauseCount()) {
            return true;
        }
    }
    return false;
}