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:es.ua.labidiomas.corpus.searcher.Searcher.java

/**
 * Prepares the query with all the search criteria.
 *
 * @param analyzer/*w  ww.  j  a v  a 2s  .  c  om*/
 * @param params
 * @return a boolean query which contains all the search criteria.
 * @throws org.apache.lucene.queryparser.classic.ParseException
 */
public BooleanQuery prepareQuery(SearchConfiguration params) throws ParseException {

    BooleanQuery searchQuery = new BooleanQuery();
    SpanQuery query;
    if (params.getOptions().isTitle()) {
        query = _prepareQuery(params.getSearchNodes(), "title", params.getOptions().isOrder(),
                params.getOptions().isDistance());
    } else {
        query = _prepareQuery(params.getSearchNodes(), "text", params.getOptions().isOrder(),
                params.getOptions().isDistance());
    }
    if (params.isLetterSearch()) {
        return _prepareLetterQuery(params, query);
    } else {
        searchQuery.add(query, BooleanClause.Occur.MUST);
        searchQuery.add(_prepareDiscourseQuery(params), BooleanClause.Occur.MUST);
        return searchQuery;
    }
}

From source file:es.ua.labidiomas.corpus.searcher.Searcher.java

private BooleanQuery _prepareDiscourseQuery(SearchConfiguration params) throws ParseException {
    BooleanQuery discourseBooleanQuery = new BooleanQuery();
    QueryParser discourseParser = new QueryParser(Version.LUCENE_47, "discourse", analyzer);
    Query discourseQuery = discourseParser.parse(params.getDiscoursesAsString());
    discourseBooleanQuery.add(discourseQuery, BooleanClause.Occur.MUST);

    return discourseBooleanQuery;
}

From source file:es.ua.labidiomas.corpus.searcher.Searcher.java

private BooleanQuery _prepareLetterQuery(SearchConfiguration params, SpanQuery query) throws ParseException {
    BooleanQuery searchQuery = new BooleanQuery();

    SpanQuery prefixQUery = new SpanMultiTermQueryWrapper(
            new PrefixQuery(new Term("text", params.getSort().getLetter())));

    SpanNearQuery spanNear1 = new SpanNearQuery(new SpanQuery[] { query, prefixQUery },
            params.getSort().getPosition() - 1, true);

    if (params.getSort().getPosition() != 1) {
        SpanNearQuery spanNear2 = new SpanNearQuery(new SpanQuery[] { query, prefixQUery },
                params.getSort().getPosition() - 2, true);

        SpanNotQuery textQUery = new SpanNotQuery(spanNear1, spanNear2);

        searchQuery.add(textQUery, BooleanClause.Occur.MUST);
    } else {//w  w  w. j  a  v a2  s.c o  m
        searchQuery.add(spanNear1, BooleanClause.Occur.MUST);
    }

    searchQuery.add(_prepareDiscourseQuery(params), BooleanClause.Occur.MUST);

    return searchQuery;
}

From source file:es.unizar.iaaa.crawler.butler.index.SearchFiles.java

License:Apache License

/**
 * Simple command-line based search demo.
 *///from   w w w  .  j a va  2s.  c  o  m
public ArrayList<SearchResult> search(String dir, String queryS) throws Exception {

    String index = dir + "index";

    IndexReader reader = DirectoryReader.open(FSDirectory.open(new File(index)));
    IndexSearcher searcher = new IndexSearcher(reader);
    Analyzer analyzer = new EnglishAnalyzer();

    // para cada necesidad se preprocesa y se lanza una query

    String line = queryS;

    line = line.trim();
    // quiamos signos de puntuacion para el prefiltrado
    line = line.replace(".", " ");
    line = line.replace(",", " ");
    line = line.replace("(", " ");
    line = line.replace(")", " ");
    line = line.replace(";", " ");
    line = line.replace(":", " ");
    line = line.replace("-", " ");

    // quitamos palabrasvacias de signifcado y expanimos la consulta
    // semanticamente

    Query queryMultiple = null;
    BooleanQuery query = new BooleanQuery();// valor este de la caja de
    // consulta

    // Consulta generica sobre todos los indices
    if (!line.equals("")) {
        String[] fields = { "content" };
        // DEBE APARECER EN EL TITULO ALGO SOBRE ESTO
        BooleanClause.Occur[] flags = { BooleanClause.Occur.SHOULD };
        queryMultiple = MultiFieldQueryParser.parse(line, fields, flags, analyzer);
        query.add(queryMultiple, BooleanClause.Occur.SHOULD);

    }

    ArrayList<SearchResult> result = doPagingSearch(dir, searcher, query);

    reader.close();
    return result;
}

From source file:extractor.InformationUnit.java

void extractAge() throws Exception {
    int numDocs = reader.numDocs();

    for (int i = 0; i < numDocs; i++) {
        String docName = reader.document(i).get(PaperIndexer.FIELD_NAME);

        TermQuery docNameConstraintQuery = new TermQuery(new Term(PaperIndexer.FIELD_NAME, docName));

        QueryParser parser = new QueryParser(contentFieldName, analyzer);
        Query q = parser.parse("participant AND age");

        BooleanQuery bq = new BooleanQuery();
        bq.add(docNameConstraintQuery, BooleanClause.Occur.MUST);
        bq.add(q, BooleanClause.Occur.MUST);

        TopDocs topDocs = searcher.search(bq, 5);
        HashMap<String, InformationUnit> evidenceMap = new HashMap<>();

        for (ScoreDoc sd : topDocs.scoreDocs) {
            Document d = paraReader.document(sd.doc);
            String content = d.get(contentFieldName);
            //System.out.println(content);

            String[] tokens = content.split("\\s+");
            for (String token : tokens) {
                if (isNumber(token)) {
                    InformationUnit iu = evidenceMap.get(token);
                    if (iu == null)
                        iu = new InformationUnit(token);
                    iu.weight++;//from  www . j a  va  2s .c o  m
                    evidenceMap.put(token, iu);
                }
            }
        }

        int numEvidences = evidenceMap.size();
        if (numEvidences == 0)
            continue;

        ArrayList<InformationUnit> iuList = new ArrayList<>(numEvidences);
        for (Map.Entry<String, InformationUnit> e : evidenceMap.entrySet()) {
            iuList.add(e.getValue());
        }
        Collections.sort(iuList);
        System.out.println("Age of population for Doc: " + docName + " is: " + iuList.get(0).desc);
    }
}

From source file:eyeskyhigh.lucene.demo.SearchFiles.java

License:Apache License

/** Simple command-line based search demo. */
public static void main(String[] args) throws Exception {
    String usage = "Usage:\tjava org.apache.lucene.demo.SearchFiles [-index dir] [-field f] [-repeat n] [-queries file] [-raw] [-norms field] [-paging hitsPerPage]";
    usage += "\n\tSpecify 'false' for hitsPerPage to use streaming instead of paging search.";
    if (args.length > 0 && ("-h".equals(args[0]) || "-help".equals(args[0]))) {
        System.out.println(usage);
        System.exit(0);//from ww w  .  ja v  a  2 s  .c o  m
    }

    String index = "index";
    String field = "contents";
    String queries = null;
    int repeat = 0;
    boolean raw = false;
    String normsField = null;
    boolean paging = true;
    int hitsPerPage = 10;

    for (int i = 0; i < args.length; i++) {
        if ("-index".equals(args[i])) {
            index = args[i + 1];
            i++;
        } else if ("-field".equals(args[i])) {
            field = args[i + 1];
            i++;
        } else if ("-queries".equals(args[i])) {
            queries = args[i + 1];
            i++;
        } else if ("-repeat".equals(args[i])) {
            repeat = Integer.parseInt(args[i + 1]);
            i++;
        } else if ("-raw".equals(args[i])) {
            raw = true;
        } else if ("-norms".equals(args[i])) {
            normsField = args[i + 1];
            i++;
        } else if ("-paging".equals(args[i])) {
            if (args[i + 1].equals("false")) {
                paging = false;
            } else {
                hitsPerPage = Integer.parseInt(args[i + 1]);
                if (hitsPerPage == 0) {
                    paging = false;
                }
            }
            i++;
        }
    }
    Analyzer analyzer = new StandardAnalyzer();
    IndexWriter writer = new IndexWriter(index, analyzer, IndexWriter.MaxFieldLength.LIMITED);
    IndexReader reader = IndexReader.open(index);

    if (normsField != null)
        reader = new OneNormsReader(reader, normsField);

    Searcher searcher = new IndexSearcher(reader);

    BufferedReader in = null;
    if (queries != null) {
        in = new BufferedReader(new FileReader(queries));
    } else {
        in = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
    }
    //      QueryParser parser = new QueryParser(field, analyzer);
    //      parser.setAllowLeadingWildcard(true);
    while (true) {
        if (queries == null) // prompt the user
            System.out.println("Enter query: ");

        String line1 = in.readLine();//, line2 = in.readLine();

        if (line1 == null || line1.length() == -1)
            break;

        line1 = line1.trim();
        if (line1.length() == 0)
            break;

        Query query;
        //      query = parser.parse(QueryParser.escape(line1));
        //      System.out.println(QueryParser.escape(line));
        //      query = new TermQuery(new Term(field, line1));
        query = new BooleanQuery();
        //      ((BooleanQuery)query).add(new PrefixQuery(new Term(field, line1)), BooleanClause.Occur.SHOULD);
        //      ((BooleanQuery)query).add(new PrefixQuery(new Term(field, line2)), BooleanClause.Occur.SHOULD);
        ((BooleanQuery) query).add(new WildcardQuery(new Term(field, line1)), BooleanClause.Occur.SHOULD);
        //      ((BooleanQuery)query).add(new WildcardQuery(new Term(field, line2)), BooleanClause.Occur.SHOULD);
        //      query = new WildcardQuery(new Term(field, line1));
        System.out.println("Searching for: " + query.toString(field));

        if (repeat > 0) { // repeat & time as benchmark
            Date start = new Date();
            for (int i = 0; i < repeat; i++) {
                //          searcher.search(query, null, 100);
            }
            Date end = new Date();
            System.out.println("Time: " + (end.getTime() - start.getTime()) + "ms");
        }

        if (paging) {
            doPagingSearch(in, searcher, query, hitsPerPage, raw, queries == null);
        } else {
            doStreamingSearch(searcher, query);
        }
    }
    reader.close();
    writer.close();
}

From source file:ezbake.intentQuery.sampleapp.elastic.DataAccessImpl.java

License:Apache License

/**
 * Helper method to generate the Boolean Query that represents the predicates OR'ed then AND'ed together.
 * (inner list is OR'ed; outer is AND'ed)
 * //from   w  ww.ja v  a  2 s.c om
 * @param predicates - the predicates to perform the search
 * @return BooleanQuery
 * @throws DataAccessException
 */
private BooleanQuery generateQueryFromPredicates(List<List<BinaryPredicate>> predicates)
        throws DataAccessException {
    Iterator<List<BinaryPredicate>> i1 = predicates.iterator();

    // create the query to AND the term lists into
    BooleanQuery andQuery = new BooleanQuery();

    while (i1.hasNext()) {
        List<BinaryPredicate> l = i1.next();
        Iterator<BinaryPredicate> i2 = l.iterator();

        // TODO: this is using the Lucene way to create the query; can we do it using ES API???
        BooleanQuery orQuery = new BooleanQuery();

        // create our query to OR the terms into
        while (i2.hasNext()) {
            BinaryPredicate predicate = i2.next();
            // get the comparison operator
            switch (predicate.getOperator()) {

            case EQ: // equals
                // TODO: what happens if someone sends down 'foo' EQ 1? we
                // shouldn't presume that they are always string values...
                BooleanQuery equalQuery = new BooleanQuery();
                equalQuery.add(
                        new TermQuery(
                                new Term(predicate.getColumnName(), predicate.getValue().getStringValue())),
                        BooleanClause.Occur.MUST);
                orQuery.add(equalQuery, null);
                break;
            case NE: // not equal
                BooleanQuery notEqualQuery = new BooleanQuery();
                notEqualQuery.add(
                        new TermQuery(
                                new Term(predicate.getColumnName(), predicate.getValue().getStringValue())),
                        BooleanClause.Occur.MUST_NOT);
                orQuery.add(notEqualQuery, null);
                break;
            case LT: // less than
                BooleanQuery lessThanQuery = new BooleanQuery();
                lessThanQuery.add(NumericRangeQuery.newLongRange(predicate.getColumnName(), Long.MIN_VALUE,
                        predicate.getValue().getLongValue(), true, false), BooleanClause.Occur.MUST);
                orQuery.add(lessThanQuery, null);
                break;
            case LE: // less than or equals
                BooleanQuery lessThanOrEqualQuery = new BooleanQuery();
                lessThanOrEqualQuery.add(NumericRangeQuery.newLongRange(predicate.getColumnName(),
                        Long.MIN_VALUE, predicate.getValue().getLongValue(), true, true),
                        BooleanClause.Occur.MUST);
                orQuery.add(lessThanOrEqualQuery, null);
                break;
            case GE: // greater than or equals
                BooleanQuery greaterThanOrEqualsQuery = new BooleanQuery();
                greaterThanOrEqualsQuery.add(
                        NumericRangeQuery.newLongRange(predicate.getColumnName(),
                                predicate.getValue().getLongValue(), Long.MAX_VALUE, true, true),
                        BooleanClause.Occur.MUST);
                orQuery.add(greaterThanOrEqualsQuery, null);
                break;
            case GT: // greater than
                BooleanQuery greaterThanQuery = new BooleanQuery();
                greaterThanQuery.add(
                        NumericRangeQuery.newLongRange(predicate.getColumnName(),
                                predicate.getValue().getLongValue(), Long.MAX_VALUE, false, true),
                        BooleanClause.Occur.MUST);
                orQuery.add(greaterThanQuery, null);
                break;
            default:
                String message = "This is not a valid predicate comparison operator: "
                        + predicate.getOperator().name();
                throw new DataAccessException(message);
            }
        }

        andQuery.add(orQuery, BooleanClause.Occur.MUST);
    }

    return andQuery;
}

From source file:feedback.RelevanceModelIId.java

public TRECQuery expandQuery() throws Exception {

    // The calling sequence has to make sure that the top docs are already
    // reranked by KL-div
    // Now reestimate relevance model on the reranked docs this time
    // for QE.//from ww  w. ja  va 2s  . c  o m
    computeKDE();

    List<RetrievedDocTermInfo> termStats = new ArrayList<>();
    for (Map.Entry<String, RetrievedDocTermInfo> e : retrievedDocsTermStats.termStats.entrySet()) {
        RetrievedDocTermInfo w = e.getValue();
        if (w.wt > 0)
            w = w;
        w.wt = w.wt * (float) Math.log(reader.numDocs()
                / (float) reader.docFreq(new Term(TrecDocIndexer.FIELD_ANALYZED_CONTENT, w.wvec.getWord())));
        termStats.add(w);
    }
    Collections.sort(termStats);

    TRECQuery expandedQuery = new TRECQuery(this.trecQuery);
    Set<Term> origTerms = new HashSet<Term>();
    this.trecQuery.luceneQuery.extractTerms(origTerms);
    expandedQuery.luceneQuery = new BooleanQuery();
    HashMap<String, String> origQueryWordStrings = new HashMap<>();

    for (Term t : origTerms) {
        origQueryWordStrings.put(t.text(), t.text());
        TermQuery tq = new TermQuery(t);
        tq.setBoost(1 - fbweight);
        ((BooleanQuery) expandedQuery.luceneQuery).add(tq, BooleanClause.Occur.SHOULD);
    }

    int nTermsAdded = 0;
    for (RetrievedDocTermInfo selTerm : termStats) {
        String thisTerm = selTerm.wvec.getWord();
        if (origQueryWordStrings.get(thisTerm) != null)
            continue;
        TermQuery tq = new TermQuery(new Term(TrecDocIndexer.FIELD_ANALYZED_CONTENT, thisTerm));
        ((BooleanQuery) expandedQuery.luceneQuery).add(tq, BooleanClause.Occur.SHOULD);
        tq.setBoost(fbweight);
        nTermsAdded++;
        if (nTermsAdded >= nterms)
            break;
    }

    return expandedQuery;
}

From source file:fi.nationallibrary.ndl.solr.schema.RangeField.java

License:Apache License

@Override
public Query getRangeQuery(QParser parser, SchemaField field, String start, String end, boolean minInclusive,
        boolean maxInclusive) {
    SchemaField startField = subField(field, 0);
    SchemaField endField = subField(field, 1);
    BooleanQuery result = new BooleanQuery();

    result.add(startField.getType().getRangeQuery(parser, startField, null, end, minInclusive, maxInclusive),
            BooleanClause.Occur.MUST);// w  w w . j av a2 s  .  co  m
    result.add(endField.getType().getRangeQuery(parser, endField, start, null, minInclusive, maxInclusive),
            BooleanClause.Occur.MUST);

    return result;
}

From source file:fr.paris.lutece.portal.service.search.LuceneSearchEngine.java

License:Open Source License

/**
 * Return search results//from   w  ww. jav a 2s.  c  o  m
 * 
 * @param strQuery The search query
 * @param request The HTTP request
 * @return Results as a collection of SearchResult
 */
public List<SearchResult> getSearchResults(String strQuery, HttpServletRequest request) {
    ArrayList<SearchItem> listResults = new ArrayList<SearchItem>();
    ArrayList<Filter> listFilter = new ArrayList<Filter>();
    Searcher searcher = null;
    boolean bFilterResult = false;
    LuteceUser user = null;
    String[] typeFilter = request.getParameterValues(PARAMETER_TYPE_FILTER);
    String strDateAfter = request.getParameter(PARAMETER_DATE_AFTER);
    String strDateBefore = request.getParameter(PARAMETER_DATE_BEFORE);
    boolean bDateAfter = false;
    boolean bDateBefore = false;
    Filter allFilter = null;
    String strTagFilter = request.getParameter(PARAMETER_TAG_FILTER);

    if (SecurityService.isAuthenticationEnable()) {
        user = SecurityService.getInstance().getRegisteredUser(request);

        Filter[] filtersRole = null;

        if (user != null) {
            String[] userRoles = SecurityService.getInstance().getRolesByUser(user);

            if (userRoles != null) {
                filtersRole = new Filter[userRoles.length + 1];

                for (int i = 0; i < userRoles.length; i++) {
                    Query queryRole = new TermQuery(new Term(SearchItem.FIELD_ROLE, userRoles[i]));
                    filtersRole[i] = new CachingWrapperFilter(new QueryWrapperFilter(queryRole));
                }
            } else {
                bFilterResult = true;
            }
        } else {
            filtersRole = new Filter[1];
        }

        if (!bFilterResult) {
            Query queryRole = new TermQuery(new Term(SearchItem.FIELD_ROLE, Page.ROLE_NONE));
            filtersRole[filtersRole.length - 1] = new CachingWrapperFilter(new QueryWrapperFilter(queryRole));
            listFilter.add(new ChainedFilter(filtersRole, ChainedFilter.OR));
        }
    }

    if (StringUtils.isNotBlank(strDateAfter) || StringUtils.isNotBlank(strDateBefore)) {
        String strAfter = null;
        String strBefore = null;

        if (StringUtils.isNotBlank(strDateAfter)) {
            Date dateAfter = DateUtil.formatDate(strDateAfter, request.getLocale());
            strAfter = DateTools.dateToString(dateAfter, Resolution.DAY);
            bDateAfter = true;
        }

        if (StringUtils.isNotBlank(strDateBefore)) {
            Date dateBefore = DateUtil.formatDate(strDateBefore, request.getLocale());
            strBefore = DateTools.dateToString(dateBefore, Resolution.DAY);
            bDateBefore = true;
        }

        Query queryDate = new TermRangeQuery(SearchItem.FIELD_DATE, strAfter, strBefore, bDateAfter,
                bDateBefore);
        listFilter.add(new CachingWrapperFilter(new QueryWrapperFilter(queryDate)));
    }

    if ((typeFilter != null) && (typeFilter.length > 0)
            && !typeFilter[0].equals(SearchService.TYPE_FILTER_NONE)) {
        Filter[] filtersType = new Filter[typeFilter.length];

        for (int i = 0; i < typeFilter.length; i++) {
            Query queryType = new TermQuery(new Term(SearchItem.FIELD_TYPE, typeFilter[i]));
            filtersType[i] = new CachingWrapperFilter(new QueryWrapperFilter(queryType));
        }

        listFilter.add(new ChainedFilter(filtersType, ChainedFilter.OR));
    }

    if (!listFilter.isEmpty()) {
        allFilter = new ChainedFilter(listFilter.toArray(new Filter[1]), ChainedFilter.AND);
    }

    try {
        searcher = new IndexSearcher(IndexationService.getDirectoryIndex(), true);

        Query query = null;

        if (StringUtils.isNotBlank(strTagFilter)) {
            BooleanQuery bQuery = new BooleanQuery();
            QueryParser parser = new QueryParser(IndexationService.LUCENE_INDEX_VERSION,
                    SearchItem.FIELD_METADATA, IndexationService.getAnalyser());

            Query queryMetaData = parser.parse((strQuery != null) ? strQuery : "");
            bQuery.add(queryMetaData, BooleanClause.Occur.SHOULD);

            parser = new QueryParser(IndexationService.LUCENE_INDEX_VERSION, SearchItem.FIELD_SUMMARY,
                    IndexationService.getAnalyser());

            Query querySummary = parser.parse((strQuery != null) ? strQuery : "");
            bQuery.add(querySummary, BooleanClause.Occur.SHOULD);
            query = bQuery;
        } else {
            QueryParser parser = new QueryParser(IndexationService.LUCENE_INDEX_VERSION,
                    SearchItem.FIELD_CONTENTS, IndexationService.getAnalyser());

            String operator = request.getParameter(PARAMETER_DEFAULT_OPERATOR);

            if (StringUtils.isNotEmpty(operator) && operator.equals(PARAMETER_OPERATOR_AND)) {
                parser.setDefaultOperator(QueryParser.AND_OPERATOR);
            }

            query = parser.parse((strQuery != null) ? strQuery : "");
        }

        // Get results documents
        TopDocs topDocs = searcher.search(query, allFilter, MAX_RESPONSES);
        ScoreDoc[] hits = topDocs.scoreDocs;

        for (int i = 0; i < hits.length; i++) {
            int docId = hits[i].doc;
            Document document = searcher.doc(docId);
            SearchItem si = new SearchItem(document);

            if ((!bFilterResult) || (si.getRole().equals(Page.ROLE_NONE))
                    || (SecurityService.getInstance().isUserInRole(request, si.getRole()))) {
                listResults.add(si);
            }
        }

        searcher.close();
    } catch (Exception e) {
        AppLogService.error(e.getMessage(), e);
    }

    return convertList(listResults);
}