Examples with Hits org.apache.lucene.search.Hits used on opensource projects

Example 1 with Hits

use of org.apache.lucene.search.Hits in project jforum2 by rafaelsteil.

the class LuceneSearch method performSearch.

private SearchResult performSearch(SearchArgs args, LuceneResultCollector resultCollector, Filter filter) {
    SearchResult result;
    try {
        StringBuffer criteria = new StringBuffer(256);
        this.filterByForum(args, criteria);
        this.filterByKeywords(args, criteria);
        this.filterByDateRange(args, criteria);
        Query query = new QueryParser("", new StandardAnalyzer()).parse(criteria.toString());
        if (logger.isDebugEnabled()) {
            logger.debug("Generated query: " + query);
        }
        Hits hits = filter == null ? this.search.search(query, this.getSorter(args)) : this.search.search(query, filter, this.getSorter(args));
        if (hits != null && hits.length() > 0) {
            result = new SearchResult(resultCollector.collect(args, hits, query), hits.length());
        } else {
            result = new SearchResult(new ArrayList(), 0);
        }
    } catch (Exception e) {
        throw new SearchException(e);
    }
    return result;
}

Example 2 with Hits

use of org.apache.lucene.search.Hits in project Openfire by igniterealtime.

the class WordMatchRouter method checkForHits.

/**
     * Returns true if the query string matches results in the request map.
     *
     * @param requestMap the map of request meta data. Each map key is a String with a value
     *      of a list of Strings.
     * @param queryString the query to test against the map.
     * @return true if the query string matches the request.
     */
public boolean checkForHits(Map<String, List<String>> requestMap, String queryString) {
    // Enable stemming.
    setStemmingEnabled(true);
    boolean foundMatch = false;
    try {
        // Create an in-memory directory.
        RAMDirectory dir = new RAMDirectory();
        // Index the message.
        IndexWriter writer = new IndexWriter(dir, analyzer, true);
        BooleanQuery booleanQuery = new BooleanQuery();
        Document doc = new Document();
        for (String key : requestMap.keySet()) {
            List<String> keyValue = requestMap.get(key);
            if (keyValue != null) {
                StringBuilder builder = new StringBuilder();
                for (String value : keyValue) {
                    if (ModelUtil.hasLength(value)) {
                        builder.append(value);
                        builder.append(" ");
                    }
                }
                // Add to Search Indexer
                doc.add(new Field(key, builder.toString(), Field.Store.YES, Field.Index.TOKENIZED));
                QueryParser parser = new QueryParser(key, analyzer);
                Query query = parser.parse(queryString);
                booleanQuery.add(query, BooleanClause.Occur.MUST);
            }
        }
        writer.addDocument(doc);
        writer.close();
        // Create a searcher, try to find a match.
        IndexSearcher searcher = new IndexSearcher(dir);
        Hits hits = searcher.search(booleanQuery);
        // Check to see if a match was found.
        if (hits.length() > 0) {
            foundMatch = true;
        }
        searcher.close();
    } catch (Exception e) {
        Log.error(e.getMessage(), e);
    }
    return foundMatch;
}

Example 3 with Hits

use of org.apache.lucene.search.Hits in project Openfire by igniterealtime.

the class ArchiveSearcher method luceneSearch.

/**
     * Searches the Lucene index for all archived conversations using the specified search.
     *
     * @param search the search.
     * @return the collection of conversations that match the search.
     */
private Collection<Conversation> luceneSearch(ArchiveSearch search) {
    try {
        IndexSearcher searcher = archiveIndexer.getSearcher();
        final StandardAnalyzer analyzer = new StandardAnalyzer();
        // Create the query based on the search terms.
        Query query = new QueryParser("text", analyzer).parse(search.getQueryString());
        // See if the user wants to sort on something other than relevance. If so, we need
        // to tell Lucene to do sorting. Default to a null sort so that it has no
        // effect if sorting hasn't been selected.
        Sort sort = null;
        if (search.getSortField() != ArchiveSearch.SortField.relevance) {
            if (search.getSortField() == ArchiveSearch.SortField.date) {
                sort = new Sort("date", search.getSortOrder() == ArchiveSearch.SortOrder.descending);
            }
        }
        // See if we need to filter on date. Default to a null filter so that it has
        // no effect if date filtering hasn't been selected.
        Filter filter = null;
        if (search.getDateRangeMin() != null || search.getDateRangeMax() != null) {
            String min = null;
            if (search.getDateRangeMin() != null) {
                min = DateTools.dateToString(search.getDateRangeMin(), DateTools.Resolution.DAY);
            }
            String max = null;
            if (search.getDateRangeMax() != null) {
                max = DateTools.dateToString(search.getDateRangeMax(), DateTools.Resolution.DAY);
            }
            // ENT-271: don't include upper or lower bound if these elements are null
            filter = new RangeFilter("date", min, max, min != null, max != null);
        }
        // See if we need to match external conversations. This will only be true
        // when less than two conversation participants are specified and external
        // wildcard matching is enabled.
        Collection<JID> participants = search.getParticipants();
        if (search.getParticipants().size() < 2 && search.isExternalWildcardMode()) {
            TermQuery externalQuery = new TermQuery(new Term("external", "true"));
            // Add this query to the existing query.
            BooleanQuery booleanQuery = new BooleanQuery();
            booleanQuery.add(query, BooleanClause.Occur.MUST);
            booleanQuery.add(externalQuery, BooleanClause.Occur.MUST);
            query = booleanQuery;
        }
        // See if we need to restrict the search to certain users.
        if (!participants.isEmpty()) {
            if (participants.size() == 1) {
                String jid = participants.iterator().next().toBareJID();
                Query participantQuery = new QueryParser("jid", analyzer).parse(jid);
                // Add this query to the existing query.
                BooleanQuery booleanQuery = new BooleanQuery();
                booleanQuery.add(query, BooleanClause.Occur.MUST);
                booleanQuery.add(participantQuery, BooleanClause.Occur.MUST);
                query = booleanQuery;
            } else // Otherwise there are two participants.
            {
                Iterator<JID> iter = participants.iterator();
                String participant1 = iter.next().toBareJID();
                String participant2 = iter.next().toBareJID();
                BooleanQuery participantQuery = new BooleanQuery();
                participantQuery.add(new QueryParser("jid", analyzer).parse(participant1), BooleanClause.Occur.MUST);
                participantQuery.add(new QueryParser("jid", analyzer).parse(participant2), BooleanClause.Occur.MUST);
                // Add this query to the existing query.
                BooleanQuery booleanQuery = new BooleanQuery();
                booleanQuery.add(query, BooleanClause.Occur.MUST);
                booleanQuery.add(participantQuery, BooleanClause.Occur.MUST);
                query = booleanQuery;
            }
        }
        Hits hits = searcher.search(query, filter, sort);
        int startIndex = search.getStartIndex();
        int endIndex = startIndex + search.getNumResults() - 1;
        // The end index can't be after the end of the results.
        if (endIndex > hits.length() - 1) {
        // endIndex = hits.length() - 1;
        // TODO: We need to determine if this is necessary.
        }
        // If the start index is positioned after the end, return an empty list.
        if (((endIndex - startIndex) + 1) <= 0) {
            return Collections.emptyList();
        } else // Otherwise return the results.
        {
            return new LuceneQueryResults(hits, startIndex, endIndex);
        }
    } catch (ParseException pe) {
        Log.error(pe.getMessage(), pe);
        return Collections.emptySet();
    } catch (IOException ioe) {
        Log.error(ioe.getMessage(), ioe);
        return Collections.emptySet();
    }
}