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.dubture.indexing.core.index.QueryBuilder.java

License:Open Source License

public static Query createPathQuery(IPath path, String referenceId) {
    IndexingCorePlugin.debug("Getting pathquery for " + path.toString());

    PrefixQuery query = new PrefixQuery(new Term(IndexField.PATH, path.toString()));
    TermQuery refQuery = new TermQuery(new Term(IndexField.TYPE, referenceId));

    BooleanQuery boolQuery = new BooleanQuery();
    boolQuery.add(query, BooleanClause.Occur.MUST);
    boolQuery.add(refQuery, BooleanClause.Occur.MUST);

    IndexingCorePlugin.debug("query: " + boolQuery.toString());
    return boolQuery;
}

From source file:com.dubture.indexing.core.index.QueryBuilder.java

License:Open Source License

public static Query createDeleteReferencesQuery(IFile file, String type) {
    BooleanQuery boolQuery = new BooleanQuery();
    String path = file.getFullPath().toString();

    boolQuery.add(new TermQuery(new Term(IndexField.PATH, path)), BooleanClause.Occur.MUST);

    boolQuery.add(new TermQuery(new Term(IndexField.FILENAME, file.getName())), BooleanClause.Occur.MUST);

    boolQuery.add(new TermQuery(new Term(IndexField.TYPE, type)), BooleanClause.Occur.MUST);

    IndexingCorePlugin.debug("Creating deleteByReference query: " + boolQuery.toString());

    return boolQuery;
}

From source file:com.duroty.application.files.manager.SearchManager.java

License:Open Source License

/**
 * DOCUMENT ME!//  w ww  .  ja v a2s  .  c om
 *
 * @param hsession DOCUMENT ME!
 * @param repositoryName DOCUMENT ME!
 * @param token DOCUMENT ME!
 * @param page DOCUMENT ME!
 * @param messagesByPage DOCUMENT ME!
 * @param order DOCUMENT ME!
 * @param orderType DOCUMENT ME!
 *
 * @return DOCUMENT ME!
 *
 * @throws FilesException DOCUMENT ME!
 */
public SearchObj simple(Session hsession, String repositoryName, String token, String folderName, int label,
        int page, int messagesByPage, int order, String orderType) throws FilesException {
    String lucenePathMessages = null;

    if (!defaultLucenePath.endsWith(File.separator)) {
        lucenePathMessages = defaultLucenePath + File.separator + repositoryName + File.separator
                + Constants.MAIL_LUCENE_MESSAGES;
    } else {
        lucenePathMessages = defaultLucenePath + repositoryName + File.separator
                + Constants.MAIL_LUCENE_MESSAGES;
    }

    Searcher searcher = null;
    SearchObj searchObj = new SearchObj();
    Sort sort = null;

    try {
        Users user = getUser(hsession, repositoryName);
        Locale locale = new Locale(user.getUseLanguage());
        TimeZone timeZone = TimeZone.getDefault();

        Date now = new Date();
        Calendar calendar = Calendar.getInstance(timeZone, locale);
        calendar.setTime(now);

        SimpleDateFormat formatter1 = new SimpleDateFormat("MMM dd", locale);
        SimpleDateFormat formatter2 = new SimpleDateFormat("HH:mm:ss", locale);
        SimpleDateFormat formatter3 = new SimpleDateFormat("MM/yy", locale);

        searcher = MailIndexer.getSearcher(lucenePathMessages);

        Query query = null;

        if (!StringUtils.isBlank(folderName) && folderName.equals(this.folderFiles)) {
            BooleanQuery booleanQuery = new BooleanQuery();

            QueryParser parser = new QueryParser(Field_subject, analyzer);
            parser.setDefaultOperator(Operator.AND);

            Query aux1 = parser.parse("Files-System");
            booleanQuery.add(aux1, BooleanClause.Occur.MUST);

            Query aux2 = SimpleQueryParser.parse(token, analyzer);
            booleanQuery.add(aux2, BooleanClause.Occur.MUST);

            /*QueryParser parser2 = new QueryParser(Field_attachments, analyzer);
            parser2.setDefaultOperator(Operator.AND); 
            Query aux3 = parser2.parse("Message Text");
            booleanQuery.add(aux3, BooleanClause.Occur.MUST_NOT);*/

            query = booleanQuery;
        } else {
            /*BooleanQuery booleanQuery = new BooleanQuery();
                    
            QueryParser parser = new QueryParser(Field_attachments, analyzer);
             parser.setDefaultOperator(Operator.AND);                
                    
            Query aux1 = parser.parse("Message Text");
             booleanQuery.add(aux1, BooleanClause.Occur.MUST_NOT);
                    
            Query aux2 = SimpleQueryParser.parse(token, analyzer);
            booleanQuery.add(aux2, BooleanClause.Occur.MUST);
                    
            query = booleanQuery;*/

            query = SimpleQueryParser.parse(token, analyzer);
        }

        Hits hits = null;

        Date searchStart = new Date();

        boolean reverse = true;

        if (orderType.equals("ASC")) {
            reverse = false;
        } else {
            reverse = true;
        }

        switch (order) {
        case ORDER_BY_SIZE:
            sort = new Sort(new SortField[] { new SortField(Field_size, SortField.STRING, reverse),
                    SortField.FIELD_SCORE });

            break;

        case ORDER_BY_DATE:
            sort = new Sort(new SortField[] { new SortField(Field_lastDate, SortField.STRING, reverse),
                    SortField.FIELD_SCORE });

            break;

        default:
            sort = new Sort(new SortField[] { new SortField(null, SortField.SCORE, !reverse) });

            break;
        }

        ChainedFilter chained = null;

        if (label > 0) {
            chained = getChainedFilter(hsession, repositoryName, label);
        }

        if (chained != null) {
            hits = searcher.search(query, chained, sort);
        } else {
            hits = searcher.search(query, sort);
        }

        Date searchEnd = new Date();

        //time in seconds
        double time = ((double) (searchEnd.getTime() - searchStart.getTime())) / (double) 1000;

        int hitsLength = hits.length();

        if (hitsLength <= 0) {
            return null;
        }

        int start = page * messagesByPage;
        int end = start + messagesByPage;

        if (end > 0) {
            end = Math.min(hitsLength, end);
        } else {
            end = hitsLength;
        }

        if (start > end) {
            throw new SearchException("Search index of bound. start > end");
        }

        Vector files = new Vector();

        for (int j = start; j < end; j++) {
            Document doc = hits.doc(j);

            if (doc != null) {
                LuceneMessage lmsg = new LuceneMessage(doc);

                Message message = getMessage(hsession, repositoryName, lmsg.getIdint());

                if (message != null) {
                    Set set = message.getAttachments();
                    if (set != null) {
                        Iterator it = set.iterator();

                        while (it.hasNext()) {
                            Attachment attachment = (Attachment) it.next();

                            String name = attachment.getAttName();
                            if (!StringUtils.isBlank(name) && !name.equals("Message Text")) {
                                AttachmentObj obj = new AttachmentObj();
                                obj.setContentType(attachment.getAttContentType());

                                obj.setScore((int) (hits.score(j) * 100));

                                Date date = message.getMesDate();

                                if (date != null) {
                                    Calendar calendar2 = Calendar.getInstance(timeZone, locale);
                                    calendar2.setTime(date);

                                    if ((calendar.get(Calendar.YEAR) == calendar2.get(Calendar.YEAR))
                                            && (calendar.get(Calendar.MONTH) == calendar2.get(Calendar.MONTH))
                                            && (calendar.get(Calendar.DATE) == calendar2.get(Calendar.DATE))) {
                                        obj.setDateStr(formatter2.format(calendar2.getTime()));
                                    } else if (calendar.get(Calendar.YEAR) == calendar2.get(Calendar.YEAR)) {
                                        obj.setDateStr(formatter1.format(calendar2.getTime()));
                                    } else {
                                        obj.setDateStr(formatter3.format(calendar2.getTime()));
                                    }
                                }

                                obj.setDate(date);

                                obj.setDate(date);
                                obj.setIdint(attachment.getAttIdint());
                                obj.setName(attachment.getAttName());
                                obj.setPart(attachment.getAttPart());

                                int size = attachment.getAttSize();
                                size /= 1024;

                                if (size > 1024) {
                                    size /= 1024;
                                    obj.setSize(size + " MB");
                                } else {
                                    obj.setSize(((size > 0) ? (size + "") : "<1") + " kB");
                                }

                                String extension = (String) this.extensions.get(attachment.getAttContentType());

                                if (StringUtils.isBlank(extension)) {
                                    extension = "generic";
                                }

                                obj.setExtension(extension);

                                if (message.isMesFlagged()) {
                                    obj.setFlagged(true);
                                } else {
                                    obj.setFlagged(false);
                                }

                                if (message.getLabMeses() != null) {
                                    Iterator it2 = message.getLabMeses().iterator();
                                    StringBuffer lab = new StringBuffer();

                                    while (it2.hasNext()) {
                                        if (lab.length() > 0) {
                                            lab.append(", ");
                                        }

                                        LabMes labMes = (LabMes) it2.next();
                                        lab.append(labMes.getId().getLabel().getLabName());
                                    }

                                    if (lab.length() > 0) {
                                        obj.setLabel(lab.toString());
                                    } else {
                                    }
                                }

                                obj.setBox(message.getMesBox());

                                obj.setMid(message.getMesName());

                                files.addElement(obj);
                            }
                        }
                    }
                }
            }
        }

        searchObj.setHits(hitsLength);
        searchObj.setTime(time);
        searchObj.setFiles(files);
    } catch (Exception ex) {
        throw new FilesException(ex);
    } finally {
        GeneralOperations.closeHibernateSession(hsession);
    }

    return searchObj;
}

From source file:com.duroty.lucene.bookmark.search.MultiFieldQueryParser.java

License:Open Source License

/**
 * <p>/*from w  ww  . j  a  v  a2  s .  co m*/
 * Parses a query which searches on the fields specified.
 * <p>
 * If x fields are specified, this effectively constructs:
 * <pre>
 * <code>
 * (field1:query) (field2:query) (field3:query)...(fieldx:query)
 * </code>
 * </pre>
 *
 * @param query Query string to parse
 * @param fields Fields to search on
 * @param analyzer Analyzer to use
 * @throws ParseException if query parsing fails
 * @throws TokenMgrError if query parsing fails
 */
public static Query parse(String query, String[] fields, Analyzer analyzer) throws ParseException {
    BooleanQuery bQuery = new BooleanQuery();

    for (int i = 0; i < fields.length; i++) {
        QueryParser qp = new QueryParser(fields[i], analyzer);
        qp.setDefaultOperator(operator);

        Query q = qp.parse(query);

        //bQuery.add(q, false, false);
        bQuery.add(q, BooleanClause.Occur.SHOULD);
    }

    return bQuery;
}

From source file:com.duroty.lucene.bookmark.search.MultiFieldQueryParser.java

License:Open Source License

/**
 * <p>//from w  w  w.  ja  va  2 s .  co m
 * Parses a query, searching on the fields specified.
 * Use this if you need to specify certain fields as required,
 * and others as prohibited.
 * <p><pre>
 * Usage:
 * <code>
 * String[] fields = {"filename", "contents", "description"};
 * int[] flags = {MultiFieldQueryParser.NORMAL FIELD,
 *                MultiFieldQueryParser.REQUIRED FIELD,
 *                MultiFieldQueryParser.PROHIBITED FIELD,};
 * parse(query, fields, flags, analyzer);
 * </code>
 * </pre>
 *<p>
 * The code above would construct a query:
 * <pre>
 * <code>
 * (filename:query) +(contents:query) -(description:query)
 * </code>
 * </pre>
 *
 * @param query Query string to parse
 * @param fields Fields to search on
 * @param flags Flags describing the fields
 * @param analyzer Analyzer to use
 * @throws ParseException if query parsing fails
 * @throws TokenMgrError if query parsing fails
 */
public static Query parse(String query, String[] fields, int[] flags, Analyzer analyzer) throws ParseException {
    BooleanQuery bQuery = new BooleanQuery();

    for (int i = 0; i < fields.length; i++) {
        QueryParser qp = new QueryParser(fields[i], analyzer);
        qp.setDefaultOperator(operator);

        Query q = qp.parse(query);
        int flag = flags[i];

        switch (flag) {
        case REQUIRED_FIELD:

            //bQuery.add(q, true, false);
            bQuery.add(q, BooleanClause.Occur.MUST);

            break;

        case PROHIBITED_FIELD:

            //bQuery.add(q, false, true);
            bQuery.add(q, BooleanClause.Occur.MUST_NOT);

            break;

        default:

            //bQuery.add(q, false, false);
            bQuery.add(q, BooleanClause.Occur.SHOULD);

            break;
        }
    }

    return bQuery;
}

From source file:com.duroty.lucene.files.search.AdvancedQueryParser.java

License:Open Source License

/**
 * DOCUMENT ME!/*from www  .j  a v a  2s  . c o m*/
 *
 * @param queryFields DOCUMENT ME!
 * @param analyzer DOCUMENT ME!
 *
 * @return DOCUMENT ME!
 *
 * @throws ParseException DOCUMENT ME!
 */
public static Query parseFlags(Hashtable queryFields, Analyzer analyzer) throws ParseException {
    if ((queryFields == null) || (queryFields.size() == 0)) {
        return null;
    }

    BooleanQuery bQuery = new BooleanQuery();
    Query simpleQuery = null;
    int control = 0;

    String label = (String) queryFields.get(Field_label);

    if ((label != null) && !label.trim().equals("")) {
        control++;

        QueryParser parser = new QueryParser(Field_label, analyzer);
        parser.setDefaultOperator(Operator.AND);

        Query aux = parser.parse(escape(label));
        simpleQuery = aux;
        bQuery.add(aux, BooleanClause.Occur.MUST);
    }

    if (control > 0) {
        if (control == 1) {
            return simpleQuery;
        } else {
            return bQuery;
        }
    } else {
        return null;
    }
}

From source file:com.duroty.lucene.mail.search.FilterQueryParser.java

License:Open Source License

/**
 * DOCUMENT ME!/*from   w  ww  .j a  va2 s . co m*/
 *
 * @param label DOCUMENT ME!
 * @param filter DOCUMENT ME!
 * @param analyzer DOCUMENT ME!
 *
 * @return DOCUMENT ME!
 *
 * @throws ParseException DOCUMENT ME!
 */
public static Query parse(Filter[] filters, Analyzer analyzer) throws ParseException {
    if ((filters != null) && (filters.length > 1)) {
        BooleanQuery bQuery = new BooleanQuery();

        for (int i = 0; i < filters.length; i++) {
            Query q = parse(filters[i], analyzer);

            if (q != null) {
                //bQuery.add(q, false, false);
                bQuery.add(q, BooleanClause.Occur.SHOULD);
            }
        }

        return bQuery;
    } else if ((filters != null) && (filters.length == 1)) {
        return parse(filters[0], analyzer);
    }

    return null;
}

From source file:com.duroty.lucene.mail.search.SimpleQueryParser.java

License:Open Source License

/**
 * DOCUMENT ME!/*from ww  w  .  j  ava  2 s . c  om*/
 *
 * @param queryString DOCUMENT ME!
 * @param analyzer DOCUMENT ME!
 *
 * @return DOCUMENT ME!
 *
 * @throws ParseException DOCUMENT ME!
 */
public static Query parse(String queryString, Analyzer analyzer) throws ParseException {
    queryString = " " + queryString.replaceAll("\\s*:\\s*", ":");

    Query query = null;

    if (queryString.indexOf(':') == -1) {
        query = MultiFieldQueryParser.parse(QueryParser.escape(queryString), messageFields, messageFlags,
                analyzer);
    } else {
        if (queryString.indexOf("hasattachments:true") > -1) {
            queryString = queryString.replaceAll("hasattachments:true", "").trim();

            BooleanQuery booleanQuery = new BooleanQuery();

            if ((queryString != null) && (queryString.length() > 0)) {
                QueryParser parser = new QueryParser("", analyzer);
                parser.setDefaultOperator(Operator.AND);

                Query aux1 = parser.parse(queryString);

                booleanQuery.add(aux1, BooleanClause.Occur.MUST);

                parser = new QueryParser(Field_has_attachments, new KeywordAnalyzer());
                parser.setDefaultOperator(Operator.AND);

                Query aux2 = parser.parse("hasattachments:true");

                booleanQuery.add(aux2, BooleanClause.Occur.MUST);

                query = booleanQuery;
            } else {
                QueryParser parser = new QueryParser(Field_has_attachments, new KeywordAnalyzer());
                parser.setDefaultOperator(Operator.AND);

                query = parser.parse("hasattachments:true");
            }
        } else {
            QueryParser parser = new QueryParser("", analyzer);
            parser.setDefaultOperator(Operator.AND);
            query = parser.parse(queryString);
        }
    }

    return query;
}

From source file:com.edgenius.wiki.search.service.AbstractSearchService.java

License:Open Source License

/**
 * /*from w w  w  .j a va2  s .  c om*/
 * @param keyword
 * @param advance
 * @return 2 elements: first is keyword query with advance query criteria. Last is highlight query.
 * @throws ParseException
 */
private Query[] createQuery(String keyword, String... advance) throws ParseException {

    //default value
    int advKeyword = 0;
    String space = null;
    int srcType = 0;
    long from = 0, to = 0;
    //group by space - need filter out some special type
    boolean groupBySpace = false;
    if (advance != null) {
        //parse all possible type
        for (String str : advance) {
            if (str.length() < 2)
                continue;

            if (str.charAt(0) == SearchService.ADV_KEYWORD_TYPE)
                advKeyword = NumberUtils.toInt(str.substring(1));

            if (str.charAt(0) == SearchService.ADV_SPACE)
                space = str.substring(1);

            if (str.charAt(0) == SearchService.ADV_SOURCE_TYPES)
                srcType = NumberUtils.toInt(str.substring(1));

            if (str.charAt(0) == SearchService.ADV_DATE_SCOPE) {
                String fromStr = str.substring(1);
                int sep = fromStr.indexOf(":");
                if (sep != -1) {
                    from = NumberUtils.toLong(fromStr.substring(0, sep));
                    to = NumberUtils.toLong(fromStr.substring(sep + 1));
                    if (from != 0 && to == 0) {
                        //from: (to is missed)
                        to = new Date().getTime();
                    }
                } else {
                    from = NumberUtils.toLong(fromStr);
                    to = new Date().getTime();
                }
            }

            if (str.charAt(0) == SearchService.ADV_GROUP_BY && NumberUtils
                    .toInt(Character.valueOf(str.charAt(1)).toString()) == SearchService.GROUP_SPACE) {
                groupBySpace = true;
            }

        }
    }

    keyword = QueryParser.escape(StringUtils.trimToEmpty(keyword));
    QueryParser parser = new QueryParser(LuceneConfig.VERSION, FieldName.CONTENT,
            searcherFactory.getAnalyzer());

    if (advKeyword == SearchService.KEYWORD_EXACT)
        keyword = "\"" + keyword + "\"";
    else if (advKeyword == SearchService.KEYWORD_ALL) {
        String[] words = keyword.split(" ");
        StringBuffer buf = new StringBuffer();
        for (String word : words) {
            buf.append("+").append(word).append(" ");
        }
        keyword = buf.toString().trim();
    }

    //highlight query on return result, could be null
    Query hlQuery = null;
    if (keyword.length() > 0) {
        //Lucene throw exception if keyword is empty
        hlQuery = parser.parse(keyword);
    }
    //date scope
    if (from != 0 && to != 0) {
        keyword += " [" + from + " TO " + to + "]";
    }
    Query keyQuery = parser.parse(keyword);

    Query spaceQuery = null;

    //space scope
    if (!StringUtils.isBlank(space)) {
        //as here is not necessary to limit search type: as only page, comment, pageTag, attachment 
        //has UNSEARCH_SPACE_UNIXNAME field, so the search type is already restrict these four types
        spaceQuery = new TermQuery(new Term(FieldName.UNSEARCH_SPACE_UNIXNAME, space.trim().toLowerCase()));
    }

    //type filter
    List<Query> typeQueries = null;
    if (srcType != 0) {
        typeQueries = new ArrayList<Query>();
        TermQuery tq;
        if ((srcType & SearchService.INDEX_PAGE) > 0) {
            tq = new TermQuery(new Term(FieldName.DOC_TYPE, SharedConstants.SEARCH_PAGE + ""));
            typeQueries.add(tq);
        }
        if ((srcType & SearchService.INDEX_SPACE) > 0 && !groupBySpace) {
            tq = new TermQuery(new Term(FieldName.DOC_TYPE, SharedConstants.SEARCH_SPACE + ""));
            typeQueries.add(tq);
        }
        if ((srcType & SearchService.INDEX_COMMENT) > 0) {
            tq = new TermQuery(new Term(FieldName.DOC_TYPE, SharedConstants.SEARCH_COMMENT + ""));
            typeQueries.add(tq);
        }
        if ((srcType & SearchService.INDEX_ROLE) > 0 && !groupBySpace) {
            tq = new TermQuery(new Term(FieldName.DOC_TYPE, SharedConstants.SEARCH_ROLE + ""));
            typeQueries.add(tq);
        }
        if ((srcType & SearchService.INDEX_USER) > 0 && !groupBySpace) {
            tq = new TermQuery(new Term(FieldName.DOC_TYPE, SharedConstants.SEARCH_USER + ""));
            typeQueries.add(tq);
        }
        if ((srcType & SearchService.INDEX_TAGONPAGE) > 0) {
            tq = new TermQuery(new Term(FieldName.DOC_TYPE, SharedConstants.SEARCH_PAGE_TAG + ""));
            typeQueries.add(tq);
        }
        if ((srcType & SearchService.INDEX_TAGONSPACE) > 0 && !groupBySpace) {
            tq = new TermQuery(new Term(FieldName.DOC_TYPE, SharedConstants.SEARCH_SPACE_TAG + ""));
            typeQueries.add(tq);
        }
        if ((srcType & SearchService.INDEX_ATTACHMENT) > 0) {
            tq = new TermQuery(new Term(FieldName.DOC_TYPE, SharedConstants.SEARCH_ATTACHMENT + ""));
            typeQueries.add(tq);
        }
        if ((srcType & SearchService.INDEX_WIDGET) > 0 && !groupBySpace) {
            tq = new TermQuery(new Term(FieldName.DOC_TYPE, SharedConstants.SEARCH_WIDGET + ""));
            typeQueries.add(tq);
        }
    }

    BooleanQuery query = new BooleanQuery();
    boolean queryIsEmpty = true;
    if (keyQuery != null) {
        queryIsEmpty = false;
        query.add(keyQuery, Occur.MUST);
    }
    if (spaceQuery != null) {
        queryIsEmpty = false;
        query.add(spaceQuery, Occur.MUST);
    }
    if (groupBySpace && (typeQueries == null || typeQueries.size() == 0)) {
        //users don't choose any special type, but sort by space, so it need give limitation on search type
        //so far - page, comment, attachment, tag on page are for Space type
        typeQueries = new ArrayList<Query>();
        TermQuery tq = new TermQuery(new Term(FieldName.DOC_TYPE, SharedConstants.SEARCH_PAGE + ""));
        typeQueries.add(tq);
        tq = new TermQuery(new Term(FieldName.DOC_TYPE, SharedConstants.SEARCH_COMMENT + ""));
        typeQueries.add(tq);
        tq = new TermQuery(new Term(FieldName.DOC_TYPE, SharedConstants.SEARCH_COMMENT + ""));
        typeQueries.add(tq);
        tq = new TermQuery(new Term(FieldName.DOC_TYPE, SharedConstants.SEARCH_PAGE_TAG + ""));
        typeQueries.add(tq);
    }

    if (typeQueries != null && typeQueries.size() > 0) {
        BooleanQuery typeQuery = new BooleanQuery();
        for (Query typeQ : typeQueries) {
            typeQuery.add(typeQ, Occur.SHOULD);
        }
        queryIsEmpty = false;
        query.add(typeQuery, Occur.MUST);
    }

    return new Query[] { queryIsEmpty ? null : query, hlQuery };
}

From source file:com.emc.query.bool.BoolQueryBuilder.java

License:Apache License

protected Query doToQuery() {
    BooleanQuery query = new BooleanQuery();

    return null;
}