Example usage for org.apache.solr.common SolrDocumentList getNumFound

List of usage examples for org.apache.solr.common SolrDocumentList getNumFound

  1. HOME
  2. Java
  3. org.apache.solr
  4. org.apache.solr.common.*
  5. SolrDocumentList
  6. getNumFound

Introduction

In this page you can find the example usage for org.apache.solr.common SolrDocumentList getNumFound.

Prototype

public long getNumFound()

Source Link

Usage

From source file:org.apache.jackrabbit.oak.plugins.index.solr.query.SolrQueryIndex.java

License:Apache License

private AbstractIterator<SolrResultRow> getIterator(final Filter filter, final IndexPlan plan,
        final String parent, final int parentDepth, final OakSolrConfiguration configuration,
        final SolrServer solrServer, final LMSEstimator estimator) {
    return new AbstractIterator<SolrResultRow>() {
        public Collection<FacetField> facetFields = new LinkedList<FacetField>();
        private final Set<String> seenPaths = Sets.newHashSet();
        private final Deque<SolrResultRow> queue = Queues.newArrayDeque();
        private int offset = 0;
        private boolean noDocs = false;
        private long numFound = 0;

        @Override//from  www.  ja va2  s .c  o  m
        protected SolrResultRow computeNext() {
            if (!queue.isEmpty() || loadDocs()) {
                return queue.remove();
            }
            return endOfData();
        }

        private SolrResultRow convertToRow(SolrDocument doc) {
            String path = String.valueOf(doc.getFieldValue(configuration.getPathField()));
            if ("".equals(path)) {
                path = "/";
            }
            if (!parent.isEmpty()) {
                path = getAncestorPath(path, parentDepth);
                // avoid duplicate entries
                if (seenPaths.contains(path)) {
                    return null;
                }
                seenPaths.add(path);
            }

            float score = 0f;
            Object scoreObj = doc.get("score");
            if (scoreObj != null) {
                score = (Float) scoreObj;
            }
            return new SolrResultRow(path, score, doc, facetFields);

        }

        /**
         * Loads the Solr documents in batches
         * @return true if any document is loaded
         */
        private boolean loadDocs() {

            if (noDocs) {
                return false;
            }

            try {
                if (log.isDebugEnabled()) {
                    log.debug("converting filter {}", filter);
                }
                SolrQuery query = FilterQueryParser.getQuery(filter, plan, configuration);
                if (numFound > 0) {
                    long rows = configuration.getRows();
                    long maxQueries = numFound / 2;
                    if (maxQueries > configuration.getRows()) {
                        // adjust the rows to avoid making more than 3 Solr requests for this particular query
                        rows = maxQueries;
                        query.setParam("rows", String.valueOf(rows));
                    }
                    long newOffset = configuration.getRows() + offset * rows;
                    if (newOffset >= numFound) {
                        return false;
                    }
                    query.setParam("start", String.valueOf(newOffset));
                    offset++;
                }
                if (log.isDebugEnabled()) {
                    log.debug("sending query {}", query);
                }
                QueryResponse queryResponse = solrServer.query(query);

                if (log.isDebugEnabled()) {
                    log.debug("getting response {}", queryResponse.getHeader());
                }

                SolrDocumentList docs = queryResponse.getResults();

                if (docs != null) {

                    numFound = docs.getNumFound();

                    estimator.update(filter, docs);

                    Map<String, Map<String, List<String>>> highlighting = queryResponse.getHighlighting();
                    for (SolrDocument doc : docs) {
                        // handle highlight
                        if (highlighting != null) {
                            Object pathObject = doc.getFieldValue(configuration.getPathField());
                            if (pathObject != null && highlighting.get(String.valueOf(pathObject)) != null) {
                                Map<String, List<String>> value = highlighting.get(String.valueOf(pathObject));
                                for (Map.Entry<String, List<String>> entry : value.entrySet()) {
                                    // all highlighted values end up in 'rep:excerpt', regardless of field match
                                    for (String v : entry.getValue()) {
                                        doc.addField(QueryImpl.REP_EXCERPT, v);
                                    }
                                }
                            }
                        }
                        SolrResultRow row = convertToRow(doc);
                        if (row != null) {
                            queue.add(row);
                        }
                    }
                }

                // get facets
                List<FacetField> returnedFieldFacet = queryResponse.getFacetFields();
                if (returnedFieldFacet != null) {
                    facetFields.addAll(returnedFieldFacet);
                }

                // filter facets on doc paths
                if (!facetFields.isEmpty() && docs != null) {
                    for (SolrDocument doc : docs) {
                        String path = String.valueOf(doc.getFieldValue(configuration.getPathField()));
                        // if facet path doesn't exist for the calling user, filter the facet for this doc
                        for (FacetField ff : facetFields) {
                            if (!filter.isAccessible(path + "/" + ff.getName())) {
                                filterFacet(doc, ff);
                            }
                        }
                    }
                }

                // handle spellcheck
                SpellCheckResponse spellCheckResponse = queryResponse.getSpellCheckResponse();
                if (spellCheckResponse != null && spellCheckResponse.getSuggestions() != null
                        && spellCheckResponse.getSuggestions().size() > 0) {
                    putSpellChecks(spellCheckResponse, queue, filter, configuration, solrServer);
                    noDocs = true;
                }

                // handle suggest
                NamedList<Object> response = queryResponse.getResponse();
                Map suggest = (Map) response.get("suggest");
                if (suggest != null) {
                    Set<Map.Entry<String, Object>> suggestEntries = suggest.entrySet();
                    if (!suggestEntries.isEmpty()) {
                        putSuggestions(suggestEntries, queue, filter, configuration, solrServer);
                        noDocs = true;
                    }
                }

            } catch (Exception e) {
                if (log.isWarnEnabled()) {
                    log.warn("query via {} failed.", solrServer, e);
                }
            }

            return !queue.isEmpty();
        }

    };
}

From source file:org.apache.jackrabbit.oak.plugins.index.solr.query.SolrQueryIndex.java

License:Apache License

private void putSpellChecks(SpellCheckResponse spellCheckResponse, final Deque<SolrResultRow> queue,
        Filter filter, OakSolrConfiguration configuration, SolrServer solrServer) throws SolrServerException {
    List<SpellCheckResponse.Suggestion> suggestions = spellCheckResponse.getSuggestions();
    Collection<String> alternatives = new ArrayList<String>(suggestions.size());
    for (SpellCheckResponse.Suggestion suggestion : suggestions) {
        alternatives.addAll(suggestion.getAlternatives());
    }/*from ww w. j  a v a2s  .com*/

    // ACL filter spellcheck results
    for (String alternative : alternatives) {
        SolrQuery solrQuery = new SolrQuery();
        solrQuery.setParam("q", alternative);
        solrQuery.setParam("df", configuration.getCatchAllField());
        solrQuery.setParam("q.op", "AND");
        solrQuery.setParam("rows", "100");
        QueryResponse suggestQueryResponse = solrServer.query(solrQuery);
        SolrDocumentList results = suggestQueryResponse.getResults();
        if (results != null && results.getNumFound() > 0) {
            for (SolrDocument doc : results) {
                if (filter.isAccessible(String.valueOf(doc.getFieldValue(configuration.getPathField())))) {
                    queue.add(new SolrResultRow(alternative));
                    break;
                }
            }
        }
    }
}

From source file:org.apache.jackrabbit.oak.plugins.index.solr.query.SolrQueryIndex.java

License:Apache License

private void putSuggestions(Set<Map.Entry<String, Object>> suggestEntries, final Deque<SolrResultRow> queue,
        Filter filter, OakSolrConfiguration configuration, SolrServer solrServer) throws SolrServerException {
    Collection<SimpleOrderedMap<Object>> retrievedSuggestions = new HashSet<SimpleOrderedMap<Object>>();
    for (Map.Entry<String, Object> suggester : suggestEntries) {
        SimpleOrderedMap<Object> suggestionResponses = ((SimpleOrderedMap) suggester.getValue());
        for (Map.Entry<String, Object> suggestionResponse : suggestionResponses) {
            SimpleOrderedMap<Object> suggestionResults = ((SimpleOrderedMap) suggestionResponse.getValue());
            for (Map.Entry<String, Object> suggestionResult : suggestionResults) {
                if ("suggestions".equals(suggestionResult.getKey())) {
                    ArrayList<SimpleOrderedMap<Object>> suggestions = ((ArrayList<SimpleOrderedMap<Object>>) suggestionResult
                            .getValue());
                    if (!suggestions.isEmpty()) {
                        for (SimpleOrderedMap<Object> suggestion : suggestions) {
                            retrievedSuggestions.add(suggestion);
                        }/*  ww  w  . ja  v a2  s  .c o  m*/
                    }
                }
            }
        }
    }

    // ACL filter suggestions
    for (SimpleOrderedMap<Object> suggestion : retrievedSuggestions) {
        SolrQuery solrQuery = new SolrQuery();
        solrQuery.setParam("q", String.valueOf(suggestion.get("term")));
        solrQuery.setParam("df", configuration.getCatchAllField());
        solrQuery.setParam("q.op", "AND");
        solrQuery.setParam("rows", "100");
        QueryResponse suggestQueryResponse = solrServer.query(solrQuery);
        SolrDocumentList results = suggestQueryResponse.getResults();
        if (results != null && results.getNumFound() > 0) {
            for (SolrDocument doc : results) {
                if (filter.isAccessible(String.valueOf(doc.getFieldValue(configuration.getPathField())))) {
                    queue.add(new SolrResultRow(suggestion.get("term").toString(),
                            Double.parseDouble(suggestion.get("weight").toString())));
                    break;
                }
            }
        }
    }
}

From source file:org.apache.metron.solr.dao.SolrSearchDao.java

License:Apache License

protected SearchResponse buildSearchResponse(SearchRequest searchRequest, QueryResponse solrResponse) {

    SearchResponse searchResponse = new SearchResponse();
    SolrDocumentList solrDocumentList = solrResponse.getResults();
    searchResponse.setTotal(solrDocumentList.getNumFound());

    // search hits --> search results
    List<SearchResult> results = solrDocumentList.stream().map(solrDocument -> SolrUtilities
            .getSearchResult(solrDocument, searchRequest.getFields(), accessConfig.getIndexSupplier()))
            .collect(Collectors.toList());
    searchResponse.setResults(results);//from  w ww  .  j a  v  a2 s.  c o m

    // handle facet fields
    List<String> facetFields = searchRequest.getFacetFields();
    if (facetFields != null) {
        searchResponse.setFacetCounts(getFacetCounts(facetFields, solrResponse));
    }

    if (LOG.isDebugEnabled()) {
        String response;
        try {
            response = JSONUtils.INSTANCE.toJSON(searchResponse, false);
        } catch (JsonProcessingException e) {
            response = e.getMessage();
        }
        LOG.debug("Built search response; response={}", response);
    }
    return searchResponse;
}

From source file:org.apache.nutch.searcher.SolrBean.java

License:Apache License

public Hits search(Query query) throws IOException {
    // filter query string
    //    final BooleanQuery bQuery = filters.filter(query);

    //    final SolrQuery solrQuery = new SolrQuery(stringify(bQuery));
    final SolrQuery solrQuery = new SolrQuery();

    solrQuery.set("q", query.getQuery());
    String a = query.getParams().getSortField();
    solrQuery.setRows(query.getParams().getNumHits());

    if (query.getParams().getSortField() == null) {
        //      solrQuery.setFields(query.getParams().getDedupField(), "score", searchUID);
        query.getParams().setSortField("score");
    } else {//w ww.  j a  va  2s . c om
        //      solrQuery.setFields(query.getParams().getDedupField(), query
        //          .getParams().getSortField(), searchUID);
        //      solrQuery.setSortField(query.getParams().getSortField(), query
        //          .getParams().isReverse() ? ORDER.asc : ORDER.desc);

        solrQuery.setSort(query.getParams().getSortField(),
                query.getParams().isReverse() ? ORDER.asc : ORDER.desc);
    }

    solrQuery.set("fl", "id,url,title,tstamp,type,content,segment,score");
    solrQuery.setHighlight(true);
    solrQuery.set("hl.fl", "title,content");
    solrQuery.set("hl.simple.pre", "<span class=highlight>");
    solrQuery.set("hl.simple.post", "</span>");
    solrQuery.set("defType", "edismax");
    solrQuery.set("qf", "title^4 content");

    QueryResponse response;
    try {
        response = solr.query(solrQuery);
    } catch (final SolrServerException e) {
        throw makeIOException(e);
    }

    final SolrDocumentList docList = response.getResults();

    Map<String, Map<String, List<String>>> highlights = response.getHighlighting();

    int qtime = response.getQTime();

    final Hit[] hitArr = new Hit[docList.size()];
    for (int i = 0; i < hitArr.length; i++) {
        final SolrDocument solrDoc = docList.get(i);

        String url = (String) solrDoc.getFieldValue("url");
        String title = (String) solrDoc.getFieldValue("title");
        String content = (String) solrDoc.getFieldValue("content");

        final Object raw = solrDoc.getFirstValue(query.getParams().getSortField());
        WritableComparable sortValue;

        if (raw instanceof Integer) {
            sortValue = new IntWritable(((Integer) raw).intValue());
        } else if (raw instanceof Float) {
            sortValue = new FloatWritable(((Float) raw).floatValue());
        } else if (raw instanceof String) {
            sortValue = new Text((String) raw);
        } else if (raw instanceof Long) {
            sortValue = new LongWritable(((Long) raw).longValue());
        } else {
            throw new RuntimeException("Unknown sort value type!");
        }

        final String dedupValue = (String) solrDoc.getFirstValue(query.getParams().getDedupField());

        final String uniqueKey = (String) solrDoc.getFirstValue(searchUID);

        //    hitArr[i] = new Hit(uniqueKey, sortValue, dedupValue);
        SolrHit hit = new SolrHit(uniqueKey, sortValue, dedupValue);
        SolrHitDetails details = buildDetails(solrDoc);
        details.setHit(hit);
        hit.setHitDetails(details);

        hit.setTitleHighlighted(title);
        int len = (content.length() > 100 ? 100 : content.length());
        Summary.Fragment f = new Summary.Fragment(content.substring(0, len));
        Summary summary = new Summary();
        summary.add(f);
        hit.setSummary(summary);

        String titleHighlighted = "";
        if (highlights.containsKey(url)) {
            Map<String, List<String>> snippets = highlights.get(url);
            if (snippets.containsKey("title")) {
                titleHighlighted = snippets.get("title").get(0);
                hit.setTitleHighlighted(titleHighlighted);
            }

            if (snippets.containsKey("content")) {
                f = new Summary.Fragment(snippets.get("content").get(0));
                summary = new Summary();
                summary.add(f);
                hit.setSummary(summary);
            }
        }

        hitArr[i] = hit;
    }

    return new Hits(docList.getNumFound(), hitArr);
}

From source file:org.apache.nutch.searcher.SolrBean.java

License:Apache License

public HitDetails getDetails(Hit hit) throws IOException {
    //    SolrHit h = (SolrHit) hit;
    //    return h.getHitDetails();
    QueryResponse response;/* w w  w .  j ava  2 s  .  c om*/
    try {
        String url = hit.getUniqueKey();
        url.replace(":", "\\:");
        SolrQuery solrQuery = new SolrQuery(searchUID + ":\"" + url + "\"");
        solrQuery.set("fl", "id,url,title,tstamp,type,content,segment,score");
        response = solr.query(solrQuery);
    } catch (final SolrServerException e) {
        throw makeIOException(e);
    }

    final SolrDocumentList docList = response.getResults();
    if (docList.getNumFound() == 0) {
        return null;
    }

    return buildDetails(docList.get(0));
}

From source file:org.apache.nutch.searcher.SolrSearchBean.java

License:Apache License

public Hits search(Query query) throws IOException {
    // filter query string
    final BooleanQuery bQuery = filters.filter(query);

    final SolrQuery solrQuery = new SolrQuery(stringify(bQuery));

    solrQuery.setRows(query.getParams().getNumHits());

    if (query.getParams().getSortField() == null) {
        solrQuery.setFields(query.getParams().getDedupField(), "score", searchUID);
        query.getParams().setSortField("score");
    } else {/*from  ww  w  .ja  va 2 s  . c  om*/
        solrQuery.setFields(query.getParams().getDedupField(), query.getParams().getSortField(), searchUID);
        solrQuery.setSortField(query.getParams().getSortField(),
                query.getParams().isReverse() ? ORDER.asc : ORDER.desc);
    }

    QueryResponse response;
    try {
        response = solr.query(solrQuery);
    } catch (final SolrServerException e) {
        throw SolrWriter.makeIOException(e);
    }

    final SolrDocumentList docList = response.getResults();

    final Hit[] hitArr = new Hit[docList.size()];
    for (int i = 0; i < hitArr.length; i++) {
        final SolrDocument solrDoc = docList.get(i);

        final Object raw = solrDoc.getFirstValue(query.getParams().getSortField());
        WritableComparable sortValue;

        if (raw instanceof Integer) {
            sortValue = new IntWritable(((Integer) raw).intValue());
        } else if (raw instanceof Float) {
            sortValue = new FloatWritable(((Float) raw).floatValue());
        } else if (raw instanceof String) {
            sortValue = new Text((String) raw);
        } else if (raw instanceof Long) {
            sortValue = new LongWritable(((Long) raw).longValue());
        } else {
            throw new RuntimeException("Unknown sort value type!");
        }

        final String dedupValue = (String) solrDoc.getFirstValue(query.getParams().getDedupField());

        final String uniqueKey = (String) solrDoc.getFirstValue(searchUID);

        hitArr[i] = new Hit(uniqueKey, sortValue, dedupValue);
    }

    return new Hits(docList.getNumFound(), hitArr);
}

From source file:org.apache.nutch.searcher.SolrSearchBean.java

License:Apache License

public HitDetails getDetails(Hit hit) throws IOException {
    QueryResponse response;/*  w ww .  ja v a 2 s. c o  m*/
    try {
        response = solr.query(new SolrQuery(searchUID + ":\"" + hit.getUniqueKey() + "\""));
    } catch (final SolrServerException e) {
        throw SolrWriter.makeIOException(e);
    }

    final SolrDocumentList docList = response.getResults();
    if (docList.getNumFound() == 0) {
        return null;
    }

    return buildDetails(docList.get(0));
}

From source file:org.apache.ranger.solr.SolrAccessAuditsService.java

License:Apache License

public VXAccessAuditList searchXAccessAudits(SearchCriteria searchCriteria) {

    // Make call to Solr
    SolrClient solrClient = solrMgr.getSolrClient();

    if (solrClient == null) {
        logger.warn("Solr client is null, so not running the query.");
        throw restErrorUtil.createRESTException("Error connecting to search engine", MessageEnums.ERROR_SYSTEM);
    }//from   w  ww. j av a2 s  .  com

    VXAccessAuditList returnList = new VXAccessAuditList();
    List<VXAccessAudit> xAccessAuditList = new ArrayList<VXAccessAudit>();

    QueryResponse response = solrUtil.searchResources(searchCriteria, searchFields, sortFields, solrClient);
    if (response == null) {
        logger.warn("Error running search query. searchCriteria=" + searchCriteria.toString());
        throw restErrorUtil.createRESTException("Error running search query", MessageEnums.ERROR_SYSTEM);
    }
    SolrDocumentList docs = response.getResults();
    int i;
    for (i = 0; i < docs.size(); i++) {
        SolrDocument doc = docs.get(i);

        VXAccessAudit vXAccessAudit = populateViewBean(doc);
        xAccessAuditList.add(vXAccessAudit);
    }

    returnList.setPageSize(searchCriteria.getMaxRows());
    returnList.setResultSize(i);
    returnList.setTotalCount((int) docs.getNumFound());
    returnList.setStartIndex((int) docs.getStart());
    returnList.setVXAccessAudits(xAccessAuditList);
    return returnList;
}

From source file:org.apache.sentry.tests.e2e.solr.db.integration.TestSolrDocLevelOperations.java

License:Apache License

@Test
public void testDocLevelOperations() throws Exception {
    setupCollectionWithDocSecurity(TEST_COLLECTION_NAME1);

    createDocument(TEST_COLLECTION_NAME1);

    CloudSolrServer server = getCloudSolrServer(TEST_COLLECTION_NAME1);
    try {//from w  w  w  . j  a v  a2  s . c om
        // queries
        SolrQuery query = new SolrQuery();
        query.setQuery("*:*");

        // as admin
        setAuthenticationUser(ADMIN_USER);
        QueryResponse rsp = server.query(query);
        SolrDocumentList docList = rsp.getResults();
        assertEquals(NUM_DOCS, docList.getNumFound());

        // as user0
        setAuthenticationUser("user0");
        grantCollectionPrivilege(TEST_COLLECTION_NAME1, ADMIN_USER, "role0", SearchConstants.QUERY);
        rsp = server.query(query);
        docList = rsp.getResults();
        assertEquals(NUM_DOCS / 4, rsp.getResults().getNumFound());

        //as user1
        setAuthenticationUser("user1");
        grantCollectionPrivilege(TEST_COLLECTION_NAME1, ADMIN_USER, "role1", SearchConstants.QUERY);
        rsp = server.query(query);
        docList = rsp.getResults();
        assertEquals(NUM_DOCS / 4, rsp.getResults().getNumFound());
        docList = rsp.getResults();
        assertEquals(NUM_DOCS / 4, rsp.getResults().getNumFound());

        //as user2
        setAuthenticationUser("user2");
        grantCollectionPrivilege(TEST_COLLECTION_NAME1, ADMIN_USER, "role2", SearchConstants.QUERY);
        rsp = server.query(query);
        docList = rsp.getResults();
        assertEquals(NUM_DOCS / 4, rsp.getResults().getNumFound());

        //as user3
        setAuthenticationUser("user3");
        grantCollectionPrivilege(TEST_COLLECTION_NAME1, ADMIN_USER, "role3", SearchConstants.QUERY);
        rsp = server.query(query);
        docList = rsp.getResults();
        assertEquals(NUM_DOCS / 4, rsp.getResults().getNumFound());
    } finally {
        server.shutdown();
    }

    deleteCollection(TEST_COLLECTION_NAME1);
}