Example usage for org.apache.lucene.search BooleanQuery 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.hrstc.lucene.queryexpansion.GenerateClassCodesQuery.java

public static Query generateQuery(Set<String> codes) {
    BooleanQuery bquery = new BooleanQuery();
    for (String code : codes) {
        // in case you would like to ignore case sensitivity,
        // you could use this statement:
        // Pattern pattern = Pattern.compile("\\s+", Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(code);
        // check all occurance
        while (matcher.find()) {
            PhraseQuery pq = new PhraseQuery();
            PhraseQuery section = new PhraseQuery();
            section.add(new Term(PatentDocument.Classification, matcher.group(1)));
            bquery.add(section, BooleanClause.Occur.SHOULD);

            PhraseQuery classification = new PhraseQuery();
            classification.add(new Term(PatentDocument.Classification, matcher.group(1) + matcher.group(2)));
            bquery.add(classification, BooleanClause.Occur.SHOULD);

            PhraseQuery subclass = new PhraseQuery();
            subclass.add(new Term(PatentDocument.Classification,
                    matcher.group(1) + matcher.group(2) + matcher.group(3)));
            bquery.add(subclass, BooleanClause.Occur.SHOULD);

            PhraseQuery mainGroup = new PhraseQuery();
            mainGroup.add(new Term(PatentDocument.Classification,
                    matcher.group(1) + matcher.group(2) + matcher.group(3) + matcher.group(4) + "NICTA00"));
            bquery.add(mainGroup, BooleanClause.Occur.SHOULD);

            PhraseQuery subGroup = new PhraseQuery();
            subGroup.add(new Term(PatentDocument.Classification, matcher.group(1) + matcher.group(2)
                    + matcher.group(3) + matcher.group(4) + "NICTA" + matcher.group(5)));
            bquery.add(subGroup, BooleanClause.Occur.SHOULD);

        }/*from ww  w  . j a v  a 2  s  . com*/
    }

    return bquery;
}

From source file:com.hrstc.lucene.queryexpansion.PatentClassCodeBasedQueryExpansion.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 ww  .j  a va 2 s.com*/
 *
 * @param query
 *
 * @return expandedQuery
 *
 * @throws IOException
 * @throws ParseException
 */
@Override
public Query expandQuery(PatentQuery query) throws ParseException, IOException {
    BooleanQuery bQuery = new BooleanQuery();
    BooleanQuery bQueryFieldsExpanded = new BooleanQuery();
    BooleanQuery.setMaxClauseCount(Integer.MAX_VALUE);
    //********************************************************************
    //**************** Get the sec of definition codes ******************* 
    //********************************************************************
    TotalHitCountCollector collector = new TotalHitCountCollector();
    Query codesQuery = GenerateClassCodesQuery.generateQuery(query.getFullClassCodes());
    //        System.err.println(codesQuery);
    classCodesSearcher.search(codesQuery, collector);
    IndexReader ir = classCodesSearcher.getIndexReader();
    TopDocs hits = classCodesSearcher.search(codesQuery, Math.max(1, collector.getTotalHits())); // Compute PRF set
    //                System.err.println("Found " + hits.totalHits
    //                        + " document(s)  that matched query '"
    //                        + codesQuery + "':");
    //                for (ScoreDoc scoreDoc : hits.scoreDocs) {
    //                    System.out.println("----------");
    //                    Document doc = classCodesSearcher.doc(scoreDoc.doc);
    //                    System.out.println(scoreDoc.score + "\t" + doc.get(PatentDocument.Classification) + "\t" + doc.get(PatentDocument.Title));// + "\t" + doc.get("type") + "\t" + doc.get("num") + "\t" + doc.get("lang"));
    ////            System.out.println(explanation.toString());
    //                }
    //                System.out.println("*************************************");
    Query expandedQuery = null;
    ClassCodeBasedQueryExpansion queryExpansion = new ClassCodeBasedQueryExpansion(hits, ir, parameters,
            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);
            }

            //                System.err.println(hits.totalHits + " total matching documents for field " + query.getFields()[i] + ".");
            if (expandedQuery == null) {
                expandedQuery = queryExpansion.expandQuery(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);
    //        hits = searcher.search(bQuery, 100);
    //                System.err.println(hits.totalHits + " total matching documents.");
    return bQuery;
}

From source file:com.hrstc.lucene.queryexpansion.PatentRocchioQueryExpansion.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 )/*from w ww. j a  va2 s  .co m*/
 *
 * @param query
 *
 * @return expandedQuery
 *
 * @throws IOException
 * @throws ParseException
 */
@Override
public Query expandQuery(PatentQuery query) throws ParseException, IOException {
    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);
    IndexReader ir = searcher.getIndexReader();
    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;
    RocchioQueryExpansion queryExpansion = new RocchioQueryExpansion(hits, ir, parameters, 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 = queryExpansion.expandQuery(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:com.hrstc.lucene.queryreduction.PatentClassCodeBasedQueryReduction.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 ww. jav a 2  s .c o  m
 *
 * @param query
 *
 * @return expandedQuery
 *
 * @throws IOException
 * @throws ParseException
 */
@Override
public Query expandQuery(PatentQuery query) throws ParseException, IOException {
    BooleanQuery bQuery = new BooleanQuery();
    BooleanQuery bQueryFieldsExpanded = new BooleanQuery();
    BooleanQuery.setMaxClauseCount(Integer.MAX_VALUE);
    //********************************************************************
    //**************** Get the sec of definition codes ******************* 
    //********************************************************************
    TotalHitCountCollector collector = new TotalHitCountCollector();
    Query codesQuery = GenerateClassCodesQuery.generateQuery(query.getFullClassCodes());
    //        System.err.println(codesQuery);
    classCodesSearcher.search(codesQuery, collector);
    IndexReader ir = classCodesSearcher.getIndexReader();
    TopDocs hits = classCodesSearcher.search(codesQuery, Math.max(1, collector.getTotalHits())); // Compute PRF set
    //                System.err.println("Found " + hits.totalHits
    //                        + " document(s)  that matched query '"
    //                        + codesQuery + "':");
    //                for (ScoreDoc scoreDoc : hits.scoreDocs) {
    //                    System.out.println("----------");
    //                    Document doc = classCodesSearcher.doc(scoreDoc.doc);
    //                    System.out.println(scoreDoc.score + "\t" + doc.get(PatentDocument.Classification) + "\t" + doc.get(PatentDocument.Title));// + "\t" + doc.get("type") + "\t" + doc.get("num") + "\t" + doc.get("lang"));
    ////            System.out.println(explanation.toString());
    //                }
    //                System.out.println("*************************************");
    Query expandedQuery = null;
    ClassCodeBasedQueryReduction queryExpansion = new ClassCodeBasedQueryReduction(hits, ir, 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);
            }

            //                System.err.println(hits.totalHits + " total matching documents for field " + query.getFields()[i] + ".");
            if (expandedQuery == null) {
                expandedQuery = queryExpansion.expandQuery(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);
    //        hits = searcher.search(bQuery, 100);
    //                System.err.println(hits.totalHits + " total matching documents.");
    return bQuery;
}

From source file:com.hrstc.lucene.queryreduction.PatentRocchioQueryReduction.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 )/*ww  w.  j a v a2 s.c  om*/
 *
 * @param query
 *
 * @return expandedQuery
 *
 * @throws IOException
 * @throws ParseException
 */
@Override
public Query expandQuery(PatentQuery query) throws ParseException, IOException {
    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);
    IndexReader ir = searcher.getIndexReader();
    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;
    RocchioQueryReduction queryExpansion = new RocchioQueryReduction(hits, ir, parameters, 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 = queryExpansion.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:com.hyeb.service.SearchServiceImpl.java

License:Open Source License

@SuppressWarnings("unchecked")
@Transactional(readOnly = true)// ww w.  j  a  v a 2  s  .c  o  m
public Page<Article> search(String keyword, Pageable pageable) {
    if (StringUtils.isEmpty(keyword)) {
        return new Page<Article>();
    }
    if (pageable == null) {
        pageable = new Pageable();
    }
    try {
        String text = QueryParser.escape(keyword);
        QueryParser titleParser = new QueryParser("title", new IKAnalyzer());
        titleParser.setDefaultOperator(QueryParser.AND_OPERATOR);
        Query titleQuery = titleParser.parse(text);
        FuzzyQuery titleFuzzyQuery = new FuzzyQuery(new Term("title", text), FUZZY_QUERY_MINIMUM_SIMILARITY);
        Query contentQuery = new TermQuery(new Term("content", text));
        Query isPublicationQuery = new TermQuery(new Term("isPublication", "true"));
        BooleanQuery textQuery = new BooleanQuery();
        BooleanQuery query = new BooleanQuery();
        textQuery.add(titleQuery, Occur.SHOULD);
        textQuery.add(titleFuzzyQuery, Occur.SHOULD);
        textQuery.add(contentQuery, Occur.SHOULD);
        query.add(isPublicationQuery, Occur.MUST);
        query.add(textQuery, Occur.MUST);
        FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
        FullTextQuery fullTextQuery = fullTextEntityManager.createFullTextQuery(query, Article.class);
        fullTextQuery.setSort(new Sort(new SortField[] { new SortField("isTop", SortField.Type.STRING, true),
                new SortField(null, SortField.Type.SCORE),
                new SortField("createDate", SortField.Type.LONG, true) }));
        fullTextQuery.setFirstResult((pageable.getPageNumber() - 1) * pageable.getPageSize());
        fullTextQuery.setMaxResults(pageable.getPageSize());
        return new Page<Article>(fullTextQuery.getResultList(), fullTextQuery.getResultSize(), pageable);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    return new Page<Article>();
}

From source file:com.hyeb.service.SearchServiceImpl.java

License:Open Source License

@SuppressWarnings("unchecked")
@Transactional(readOnly = true)/*from  w w w .ja  va 2  s . com*/
public Page<Product> search(String keyword, BigDecimal startPrice, BigDecimal endPrice, OrderType orderType,
        Pageable pageable) {
    if (StringUtils.isEmpty(keyword)) {
        return new Page<Product>();
    }
    if (pageable == null) {
        pageable = new Pageable();
    }
    try {
        String text = QueryParser.escape(keyword);
        TermQuery snQuery = new TermQuery(new Term("sn", text));
        Query keywordQuery = new QueryParser("keyword", new IKAnalyzer()).parse(text);
        QueryParser nameParser = new QueryParser("name", new IKAnalyzer());
        nameParser.setDefaultOperator(QueryParser.AND_OPERATOR);
        Query nameQuery = nameParser.parse(text);
        FuzzyQuery nameFuzzyQuery = new FuzzyQuery(new Term("name", text), FUZZY_QUERY_MINIMUM_SIMILARITY);
        TermQuery introductionQuery = new TermQuery(new Term("introduction", text));
        TermQuery isMarketableQuery = new TermQuery(new Term("isMarketable", "true"));
        TermQuery isListQuery = new TermQuery(new Term("isList", "true"));
        TermQuery isGiftQuery = new TermQuery(new Term("isGift", "false"));
        BooleanQuery textQuery = new BooleanQuery();
        BooleanQuery query = new BooleanQuery();
        textQuery.add(snQuery, Occur.SHOULD);
        textQuery.add(keywordQuery, Occur.SHOULD);
        textQuery.add(nameQuery, Occur.SHOULD);
        textQuery.add(nameFuzzyQuery, Occur.SHOULD);
        textQuery.add(introductionQuery, Occur.SHOULD);
        query.add(isMarketableQuery, Occur.MUST);
        query.add(isListQuery, Occur.MUST);
        query.add(isGiftQuery, Occur.MUST);
        query.add(textQuery, Occur.MUST);
        if (startPrice != null && endPrice != null && startPrice.compareTo(endPrice) > 0) {
            BigDecimal temp = startPrice;
            startPrice = endPrice;
            endPrice = temp;
        }
        if (startPrice != null && startPrice.compareTo(new BigDecimal(0)) >= 0 && endPrice != null
                && endPrice.compareTo(new BigDecimal(0)) >= 0) {
            NumericRangeQuery<Double> numericRangeQuery = NumericRangeQuery.newDoubleRange("price",
                    startPrice.doubleValue(), endPrice.doubleValue(), true, true);
            query.add(numericRangeQuery, Occur.MUST);
        } else if (startPrice != null && startPrice.compareTo(new BigDecimal(0)) >= 0) {
            NumericRangeQuery<Double> numericRangeQuery = NumericRangeQuery.newDoubleRange("price",
                    startPrice.doubleValue(), null, true, false);
            query.add(numericRangeQuery, Occur.MUST);
        } else if (endPrice != null && endPrice.compareTo(new BigDecimal(0)) >= 0) {
            NumericRangeQuery<Double> numericRangeQuery = NumericRangeQuery.newDoubleRange("price", null,
                    endPrice.doubleValue(), false, true);
            query.add(numericRangeQuery, Occur.MUST);
        }
        FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(entityManager);
        FullTextQuery fullTextQuery = fullTextEntityManager.createFullTextQuery(query, Product.class);
        SortField[] sortFields = null;
        if (orderType == OrderType.priceAsc) {
            sortFields = new SortField[] { new SortField("price", SortField.Type.DOUBLE, false),
                    new SortField("createDate", SortField.Type.LONG, true) };
        } else if (orderType == OrderType.priceDesc) {
            sortFields = new SortField[] { new SortField("price", SortField.Type.DOUBLE, true),
                    new SortField("createDate", SortField.Type.LONG, true) };
        } else if (orderType == OrderType.salesDesc) {
            sortFields = new SortField[] { new SortField("sales", SortField.Type.INT, true),
                    new SortField("createDate", SortField.Type.LONG, true) };
        } else if (orderType == OrderType.scoreDesc) {
            sortFields = new SortField[] { new SortField("score", SortField.Type.INT, true),
                    new SortField("createDate", SortField.Type.LONG, true) };
        } else if (orderType == OrderType.dateDesc) {
            sortFields = new SortField[] { new SortField("createDate", SortField.Type.LONG, true) };
        } else {
            sortFields = new SortField[] { new SortField("isTop", SortField.Type.STRING, true),
                    new SortField(null, SortField.Type.SCORE),
                    new SortField("modifyDate", SortField.Type.LONG, true) };
        }
        fullTextQuery.setSort(new Sort(sortFields));
        fullTextQuery.setFirstResult((pageable.getPageNumber() - 1) * pageable.getPageSize());
        fullTextQuery.setMaxResults(pageable.getPageSize());
        return new Page<Product>(fullTextQuery.getResultList(), fullTextQuery.getResultSize(), pageable);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return new Page<Product>();
}

From source file:com.ibm.watson.developer_cloud.professor_languo.pipeline.primary_search.BoostQueryGenerator.java

License:Open Source License

private Query createBoostQuery(Question question, Analyzer analyzer) throws SearchException {
    List<String> tokens;
    StackExchangeQuestion queryQuestion = (StackExchangeQuestion) question;
    String title = queryQuestion.getTitleText();
    List<TermQuery> termQueries = new ArrayList<TermQuery>();
    BooleanQuery query = new BooleanQuery();

    try {//from  ww  w .  j  a  v a  2 s.c o  m
        tokens = AnalyzerUtils.collectTokens(analyzer, title);
        for (String token : tokens) {
            TermQuery tqTitle = new TermQuery(
                    new Term(IndexDocumentFieldName.THREAD_TITLE.toString(), token.trim()));
            tqTitle.setBoost(2);
            TermQuery tqText = new TermQuery(
                    new Term(IndexDocumentFieldName.THREAD_TEXT.toString(), token.trim()));
            TermQuery tqAccAnswerText = new TermQuery(
                    new Term(IndexDocumentFieldName.ACCEPTED_ANSWER_TEXT.toString(), token.trim()));
            TermQuery tqTopAnswerText = new TermQuery(
                    new Term(IndexDocumentFieldName.TOP_VOTED_ANSWER_TEXT.toString(), token.trim()));
            TermQuery tqTags = new TermQuery(
                    new Term(IndexDocumentFieldName.THREAD_TAGS.toString(), token.trim()));
            tqTags.setBoost(2);

            termQueries.add(tqTitle);// TODO:
            termQueries.add(tqText);
            termQueries.add(tqAccAnswerText);
            termQueries.add(tqTopAnswerText);
            termQueries.add(tqTags);
        }
        for (TermQuery q : termQueries)
            query.add(q, Occur.SHOULD);
    } catch (IOException e) {
        throw new SearchException(e);
    }
    return query;
}

From source file:com.ibm.watson.developer_cloud.professor_languo.pipeline.primary_search.NaiveFreeQueryGenerator.java

License:Open Source License

/**
 * Create a simple query where each field of the question is a single term
 *//*from w ww.j av a 2 s  .com*/
@Override
public Query generateQuery(Question question) throws SearchException {

    // All non-alphanumeric characters are removed, since they interfere
    // with REST calls
    StackExchangeQuestion stackQuestion = (StackExchangeQuestion) question;
    String title = stackQuestion.getTitleText().trim().replaceAll("[^\\p{IsAlphabetic}^\\p{IsDigit} ]", "");

    // Create a boolean query where we will add terms for the search
    BooleanQuery query = new BooleanQuery();

    // Add the search terms to the query
    // Each term should appear in the search but doesn't have to

    // title is used a free query with no field attached to it
    query.add(new TermQuery(new Term("", title)), BooleanClause.Occur.SHOULD);

    return query;
}

From source file:com.ibm.watson.developer_cloud.professor_languo.pipeline.primary_search.NaiveQueryGenerator.java

License:Open Source License

private Query createNaiveQuery(Question question, Analyzer analyzer) throws SearchException {
    List<String> tokens;
    StackExchangeQuestion queryQuestion = (StackExchangeQuestion) question;
    String title = queryQuestion.getTitleText();
    List<TermQuery> termQueries = new ArrayList<TermQuery>();
    BooleanQuery query = new BooleanQuery();

    try {//  w w  w  . ja  v a 2 s  .  c  o  m
        tokens = AnalyzerUtils.collectTokens(analyzer, title);
        for (String token : tokens)
            termQueries
                    .add(new TermQuery(new Term(IndexDocumentFieldName.THREAD_TITLE.toString(), token.trim())));// TODO:
        for (TermQuery q : termQueries)
            query.add(q, Occur.SHOULD);
    } catch (IOException e) {
        throw new SearchException(e);
    }
    return query;
}