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.andreig.jetty.Search.java

License:GNU General Public License

private static Query add_dbid(Query q2, String dbid) {

    BooleanQuery bq = new BooleanQuery();

    Term t = new Term("_dbid_", dbid);
    Query q = new TermQuery(t);
    bq.add(q, Occur.MUST);/*from w ww.j  a va 2s  .  c o m*/

    bq.add(q2, Occur.MUST);

    return bq;

}

From source file:com.appeligo.amazon.AmazonSearcher.java

License:Apache License

public AmazonItem getProgramPurchases(String programId) {
    Searcher searcher = getProductSearcher();
    BooleanQuery query = new BooleanQuery();
    query.add(new BooleanClause(new TermQuery(new Term("programId", programId)), Occur.MUST));
    query.add(new BooleanClause(new TermQuery(new Term("type", "product")), Occur.MUST));
    AmazonItem item = null;/*from w  w w .j a v  a2  s  .c  o  m*/
    try {
        Hits hits = searcher.search(query);
        if (hits.length() > 0) {
            item = createItem(hits.doc(0));
        }
    } catch (IOException e) {
        if (log.isWarnEnabled()) {
            log.warn("Error searching for program purchase: " + programId, e);
        }
    }
    return item;
}

From source file:com.appeligo.search.actions.SearchResults.java

License:Apache License

private Query generateLuceneQuery(String givenQuery, IndexSearcher searcher) throws ParseException {
    if (givenQuery == null) {
        givenQuery = getQuery();/*from  w ww  .java  2 s  .c  om*/
    }
    HashMap<String, Float> boost = new HashMap<String, Float>();
    boost.put("programTitle", 8.0f);
    boost.put("episodeTitle", 3.0f);
    boost.put("description", 2.0f);
    MultiFieldQueryParser parser = new MultiFieldQueryParser(
            new String[] { "text", "description", "programTitle", "episodeTitle", "credits", "genre" },
            analyzer, boost);
    parser.setDefaultOperator(Operator.AND);

    Query luceneQuery = null;
    try {
        luceneQuery = parser.parse(givenQuery);
    } catch (ParseException e) {
        log.error("Error parsing query for : " + givenQuery);
        if (log.isDebugEnabled()) {
            log.debug("Error parsing query for : " + givenQuery, e);
        }
        givenQuery = QueryParser.escape(givenQuery);
        luceneQuery = parser.parse(givenQuery);
    }
    BooleanQuery combinedQuery = new BooleanQuery();
    combinedQuery.add(luceneQuery, Occur.MUST);

    //This will move into a setting on the user.
    Query tvma = new TermQuery(new Term("tvRating", "TVMA"));
    combinedQuery.add(tvma, Occur.MUST_NOT);

    if (lineup != null) {
        //Only find programs that were on networks that are in the lineup
        TermQuery lineupQuery = new TermQuery(new Term("lineup-" + lineup, "true"));
        combinedQuery.add(lineupQuery, Occur.MUST);
    }

    if (searchType != null) {
        if (lineup == null) {
            throw new ParseException(
                    "Lineup cannot be null if searching based on date.  searchType=" + searchType);
        }
        switch (searchType) {
        case FUTURE: {
            Calendar cal = Calendar.getInstance();
            cal.add(Calendar.DAY_OF_YEAR, 14);
            Date future = cal.getTime();
            Date now = new Date();
            ConstantScoreRangeQuery dateQuery = new ConstantScoreRangeQuery("lineup-" + lineup + "-endTime",
                    DateTools.dateToString(now, DateTools.Resolution.MINUTE),
                    DateTools.dateToString(future, DateTools.Resolution.MINUTE), true, true);
            combinedQuery.add(dateQuery, Occur.MUST);
            break;
        }
        case TODAY: {
            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.HOUR_OF_DAY, cal.getActualMaximum(Calendar.HOUR_OF_DAY));
            cal.set(Calendar.MINUTE, cal.getActualMaximum(Calendar.MINUTE));
            Date future = cal.getTime();
            Date now = new Date();
            ConstantScoreRangeQuery dateQuery = new ConstantScoreRangeQuery("lineup-" + lineup + "-endTime",
                    DateTools.dateToString(now, DateTools.Resolution.MINUTE),
                    DateTools.dateToString(future, DateTools.Resolution.MINUTE), true, true);
            combinedQuery.add(dateQuery, Occur.MUST);
            break;
        }
        }
    }
    if (modifiedSince != null) {
        Date now = new Date();
        ConstantScoreRangeQuery dateQuery = new ConstantScoreRangeQuery("lastModified",
                DateTools.dateToString(modifiedSince, DateTools.Resolution.MINUTE),
                DateTools.dateToString(now, DateTools.Resolution.MINUTE), true, true);
        combinedQuery.add(dateQuery, Occur.MUST);
    }
    return combinedQuery;
}

From source file:com.appspot.socialinquirer.server.service.impl.StackExchangeServiceImpl.java

License:Apache License

/**
 * Match with keywords./* www.java 2 s .co m*/
 *
 * @param keywords the keywords
 * @param userText the user text
 * @return true, if successful
 */
public boolean matchWithKeywords(List<String> keywords, String userText) {
    MemoryIndex index = new MemoryIndex();
    index.addField("text", userText, createEnglishAnalyzer());
    QueryParser parser = new QueryParser("text", createEnglishAnalyzer());
    BooleanQuery query = new BooleanQuery();
    for (String keyword : keywords) {
        try {
            query.add(parser.parse(keyword), BooleanClause.Occur.SHOULD);
        } catch (ParseException e) {
        }
    }

    float score = index.search(query);

    return score > 0.0f;
}

From source file:com.aurel.track.lucene.search.listFields.ExternalListSearcher.java

License:Open Source License

/**
 * Gets the lucene query when no field is specified 
 * @param analyzer/*from  w  w  w .j ava 2 s . co m*/
 * @param toBeProcessedString
 * @param fieldID
 * @param locale
 * @return
 */
@Override
protected Query getNoExlplicitFieldQuery(Analyzer analyzer, String toBeProcessedString, Locale locale) {
    List<Integer> fieldIDs = getFieldIDs();
    if (fieldIDs != null && !fieldIDs.isEmpty()) {
        BooleanQuery booleanQuery = new BooleanQuery();
        for (Integer fieldID : fieldIDs) {
            Query searchabelFieldQuery = getNoFieldQuerySearchableField(analyzer, toBeProcessedString, fieldID,
                    locale);
            booleanQuery.add(searchabelFieldQuery, BooleanClause.Occur.SHOULD);
        }
        return booleanQuery;
    }
    return null;
}

From source file:com.aurel.track.lucene.search.listFields.ExternalListSearcher.java

License:Open Source License

/**
 * Gets the lucene query when no field is specified 
 * @param analyzer/*  ww  w  .  j ava  2 s  .  c o  m*/
 * @param toBeProcessedString
 * @param fieldID
 * @param locale
 * @return
 */
protected Query getNoFieldQuerySearchableField(Analyzer analyzer, String toBeProcessedString, Integer fieldID,
        Locale locale) {
    BooleanQuery booleanQuery = new BooleanQuery();
    IExternalLookupLucene externalLookupField = (IExternalLookupLucene) FieldTypeManager
            .getFieldTypeRT(fieldID);
    String[] searchableFields = externalLookupField.getSearchableFieldNames();
    if (searchableFields != null && searchableFields.length > 0) {
        for (String searchableField : searchableFields) {
            QueryParser queryParser = new QueryParser(searchableField, analyzer);
            Query externalLookupFieldQuery = null;
            String externalFieldQueryString = toBeProcessedString + " AND "
                    + LuceneUtil.EXTERNAL_INDEX_FIELDS.FIELDID + LuceneSearcher.FIELD_NAME_VALUE_SEPARATOR
                    + fieldID;
            try {
                externalLookupFieldQuery = queryParser.parse(toBeProcessedString);
                booleanQuery.add(externalLookupFieldQuery, BooleanClause.Occur.SHOULD);
            } catch (ParseException e) {
                LOGGER.error("Parsing the external lookups query string for fieldValue '"
                        + externalFieldQueryString + "' failed with " + e.getMessage());
                LOGGER.debug(ExceptionUtils.getStackTrace(e));
            }
        }
    }
    return booleanQuery;
}

From source file:com.aurel.track.lucene.search.LuceneSearcher.java

License:Open Source License

/**
 * Find the workItemIDs for a user entered query string
 * The userQueryString may or may not have explicit fields specified 
 * The further processing depends very much on whether there is explicit field specified or not
 * @param userQueryString// w ww. j  ava  2 s  . co m
 * @param external whether track+ item search or wiki search
 * @param locale
 * @param highlightedTextMap
 * @return
 */
public static int[] searchWorkItems(String userQueryString, boolean external, Locale locale,
        Map<Integer, String> highlightedTextMap) throws ParseException, BooleanQuery.TooManyClauses {
    Analyzer analyzer = LuceneUtil.getAnalyzer();
    if (userQueryString == null) {
        LOGGER.info("Query string is null");
        return null;
    } else {
        LOGGER.debug("Query string is " + userQueryString);
    }
    List<TListTypeBean> documentTypesList = IssueTypeBL.loadAllDocumentTypes();
    Set<Integer> documentTypeIDs = GeneralUtils.createIntegerSetFromBeanList(documentTypesList);
    String preprocessedQueryString = userQueryString;
    Query query = null;
    Query projectSpecificIDQuery = null;
    Map<String, Integer> compositeFieldIDByFieldName = new HashMap<String, Integer>();
    Map<String, String> fieldLabelToFieldNameMap = new HashMap<String, String>();
    List<String> fieldNames = getAllFieldNames(compositeFieldIDByFieldName, fieldLabelToFieldNameMap, locale);
    userQueryString = replaceFieldLabelsWithFieldNames(userQueryString, fieldLabelToFieldNameMap);
    if (fieldSpecified(userQueryString, fieldNames, compositeFieldIDByFieldName)) {
        //initialize the query with the SYNOPSIS as default field
        //queryParser = new QueryParser(LuceneUtil.getFieldName(SystemFields.SYNOPSYS), analyzer);
        //preprocess the query:
        // 1. by replacing the not localized lookup texts with the corresponding values: ex. Project:TryItOut -> Project:1
        // 2. by replacing the localized lookup texts with the corresponding values: ex. Status:geschlossen -> Status:10
        // 3. preprocess the localized date in lucene format. ex. EndDate:24.12.07 -> EndDate:20071224
        // 4. preprocess the localized boolean value
        // 5. preprocess composite fields pc:p1#c11 -> pc#1:12 AND pc#2:21 
        // 6. replace the text found in an attachment with the ID(s) of the workItems the attachment belongs to
        preprocessedQueryString = preprocess(analyzer, userQueryString, locale);
        //set all direct text fields as default fields 
        /*List<IntegerStringBean> directTextFieldNames = LuceneUtil.getFieldNamesForPreprocessType(LuceneUtil.PREPROCESSTYPES.DIRECT);
        String[] fieldNamesArr = new String[directTextFieldNames.size()];
        for (int i = 0; i < directTextFieldNames.size(); i++) {
           fieldNamesArr[i] = directTextFieldNames.get(i).getLabel();
        }
        BooleanClause.Occur[] orFlags = getOrFlagsArray(directTextFieldNames.size());
        try {
           //initialize the query with all direct fields as default field
           query = MultiFieldQueryParser.parse(LuceneUtil.VERSION, preprocessedQueryString, fieldNamesArr, orFlags, analyzer);
        } catch (ParseException e) {
           LOGGER.error("Parsing without explicit field for workItem fields (MultiFieldQueryParser) failed with " + e.getMessage());
           throw e;
        }*/
        QueryParser queryParser = new QueryParser(LuceneUtil.getFieldName(SystemFields.ISSUENO), analyzer);
        try {
            query = queryParser.parse(preprocessedQueryString);
        } catch (ParseException e) {
            LOGGER.warn("Parsing explicit field  for " + preprocessedQueryString + " field failed with "
                    + e.getMessage());
            LOGGER.debug(ExceptionUtils.getStackTrace(e));
            throw e;
        }
        if (query != null && LOGGER.isDebugEnabled()) {
            LOGGER.debug("The preprocessed query: " + query.toString());
        }
        Query itemTypeQuery = getItemTypeQuery(documentTypeIDs, analyzer);
        if (itemTypeQuery != null) {
            LOGGER.debug("The item type query: " + itemTypeQuery.toString());
            BooleanClause.Occur occur = null;
            if (external) {
                occur = BooleanClause.Occur.MUST;
            } else {
                occur = BooleanClause.Occur.MUST_NOT;
            }
            BooleanQuery finalQuery = new BooleanQuery();
            finalQuery.add(query, BooleanClause.Occur.MUST);
            finalQuery.add(itemTypeQuery, occur);
            query = finalQuery;
        }
    } else {
        if (isPossibleProjectSpecificID(userQueryString)) {
            TFieldBean fieldBean = FieldTypeManager.getInstance()
                    .getFieldBean(SystemFields.INTEGER_PROJECT_SPECIFIC_ISSUENO);
            if (fieldBean != null) {
                String termField = fieldBean.getName();
                Term term = new Term(termField, userQueryString);
                projectSpecificIDQuery = new TermQuery(term);
                int[] projSpecificIDResult = getQueryResults(projectSpecificIDQuery, userQueryString,
                        preprocessedQueryString, highlightedTextMap);
                if (projSpecificIDResult != null && projSpecificIDResult.length > 0) {
                    //return only if projectSpecific item numbers are found
                    return projSpecificIDResult;
                }
            }
        }
        query = preprocessNoExplicitField(analyzer, userQueryString, documentTypeIDs, external, locale);
        preprocessedQueryString = query.toString();
    }
    return getQueryResults(query, userQueryString, preprocessedQueryString, highlightedTextMap);
}

From source file:com.aurel.track.lucene.search.LuceneSearcher.java

License:Open Source License

/**
 * Preprocess a userQueryString which do not have explicit field(s) specified
 * Uses some text fields as default fields but looks for the words 
 * also in the other lookup indexes //  w w  w.jav  a  2  s.  c  om
 * @param analyzer 
 * @param toBeProcessedString a part of the user entered query string
 * @param locale 
 * @return 
 */
private static Query preprocessNoExplicitField(Analyzer analyzer, String toBeProcessedString,
        Set<Integer> itemTypeIDs, boolean external, Locale locale) throws ParseException {
    //direct workItem fields
    BooleanQuery finalQuery = new BooleanQuery();
    BooleanClause.Occur[] orFlags;
    Query workItemDirectQuery = null;
    //initialize the QueryParser with text fields as default fields
    BooleanQuery workItemQuery = new BooleanQuery();
    List<IntegerStringBean> directTextFieldNames = getFieldNamesForPreprocessType(
            LuceneUtil.PREPROCESSTYPES.DIRECT);
    String[] fieldNamesArr = new String[directTextFieldNames.size()];
    for (int i = 0; i < directTextFieldNames.size(); i++) {
        fieldNamesArr[i] = directTextFieldNames.get(i).getLabel();
    }
    orFlags = getOrFlagsArray(directTextFieldNames.size());
    try {
        workItemDirectQuery = MultiFieldQueryParser.parse(toBeProcessedString, fieldNamesArr, orFlags,
                analyzer);
    } catch (ParseException e) {
        LOGGER.warn("Parsing without explicit field for workItem fields (MultiFieldQueryParser) failed with "
                + e.getMessage());
        LOGGER.debug(ExceptionUtils.getStackTrace(e));
        throw e;
    } catch (Exception e) {
        LOGGER.warn(
                "Parsing without explicit field for workItem fields (MultiFieldQueryParser) failed with throwable "
                        + e.getMessage());
        LOGGER.debug(ExceptionUtils.getStackTrace(e));
    }
    //combine with or all occurrences LOOKUPENTITYTYPES
    if (workItemDirectQuery != null) {
        workItemQuery.add(workItemDirectQuery, BooleanClause.Occur.SHOULD);
    }
    List<ILookupFieldSearcher> lookupFieldSearchers = getLookupFieldSearchers();
    for (ILookupFieldSearcher lookupFieldSearcher : lookupFieldSearchers) {
        Query query = lookupFieldSearcher.getNoExplicitFieldQuery(analyzer, toBeProcessedString, locale);
        if (query != null) {
            workItemQuery.add(query, BooleanClause.Occur.SHOULD);
        }
    }
    finalQuery.add(workItemQuery, BooleanClause.Occur.MUST);
    Query itemTypeQuery = getItemTypeQuery(itemTypeIDs, analyzer);
    if (itemTypeQuery != null) {
        LOGGER.debug("The item type query: " + itemTypeQuery.toString());
        BooleanClause.Occur occur = null;
        if (external) {
            occur = BooleanClause.Occur.MUST;
        } else {
            occur = BooleanClause.Occur.MUST_NOT;
        }
        finalQuery.add(itemTypeQuery, occur);
    }
    return finalQuery;
}

From source file:com.baidu.rigel.biplatform.tesseract.util.QueryRequestUtil.java

License:Open Source License

/**
 * //from ww  w . j a  v a 2 s . c  o m
 * transQueryRequest2LuceneQuery queryRequest->query for lucene
 * 
 * @param query
 *            queryRequest
 * @return Query query for lucene
 * @throws ParseException
 *             ?
 */
public static Query transQueryRequest2LuceneQuery(QueryRequest query) throws ParseException {
    if (query == null || query.getWhere() == null) {
        throw new IllegalArgumentException();
    }
    BooleanQuery queryAll = new BooleanQuery();
    BooleanQuery.setMaxClauseCount(Integer.MAX_VALUE);
    // process where
    // process and condition
    Map<String, List<String>> andCondition = transQueryRequestAndList2Map(query);
    for (String fieldName : andCondition.keySet()) {
        //QueryParser parser = new QueryParser(fieldName, new StandardAnalyzer());
        BooleanQuery subQuery = new BooleanQuery();
        for (String qs : andCondition.get(fieldName)) {
            subQuery.add(new TermQuery(new Term(fieldName, qs)), Occur.SHOULD);
        }
        queryAll.add(subQuery, Occur.MUST);
    }

    return queryAll;
}

From source file:com.barchart.feed.ddf.resolver.provider.CodecHelper.java

License:BSD License

static Query buildQuerySimple(final String source) {

    final String[] termArray = source.split("\\s+");

    final BooleanQuery query = new BooleanQuery();

    for (final String termText : termArray) {

        final Term term = getBodyTerm(termText);

        if (hasWildcard(termText)) {
            AND(query, new WildcardQuery(term));
        } else {/*from  w w w  .j  ava  2s . c o m*/
            AND(query, new PrefixQuery(term));
        }

    }

    return query;

}