Example usage for org.apache.solr.client.solrj SolrQuery SolrQuery

List of usage examples for org.apache.solr.client.solrj SolrQuery SolrQuery

  1. HOME
  2. Java
  3. org.apache.solr
  4. org.apache.solr.client.solrj.*
  5. SolrQuery
  6. SolrQuery

Introduction

In this page you can find the example usage for org.apache.solr.client.solrj SolrQuery SolrQuery.

Prototype

public SolrQuery()

Source Link

Usage

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

private List<OccurrencePoint> getPoints(SpatialSearchRequestParams searchParams, PointType pointType, int max)
        throws Exception {
    List<OccurrencePoint> points = new ArrayList<OccurrencePoint>(); // new OccurrencePoint(PointType.POINT);
    queryFormatUtils.formatSearchQuery(searchParams);
    if (logger.isInfoEnabled()) {
        logger.info("search query: " + searchParams.getFormattedQuery());
    }/*from   w  ww. jav  a  2  s  .  c o m*/
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    solrQuery.setQuery(searchParams.getFormattedQuery());
    solrQuery.setRows(0);
    solrQuery.setFacet(true);
    solrQuery.addFacetField(pointType.getLabel());
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(max); // unlimited = -1

    QueryResponse qr = runSolrQuery(solrQuery, searchParams.getFormattedFq(), 1, 0, "score", "asc");
    List<FacetField> facets = qr.getFacetFields();

    if (facets != null) {
        for (FacetField facet : facets) {
            List<FacetField.Count> facetEntries = facet.getValues();
            if (facet.getName().contains(pointType.getLabel()) && (facetEntries != null)
                    && (facetEntries.size() > 0)) {

                for (FacetField.Count fcount : facetEntries) {
                    if (StringUtils.isNotEmpty(fcount.getName()) && fcount.getCount() > 0) {
                        OccurrencePoint point = new OccurrencePoint(pointType);
                        point.setCount(fcount.getCount());
                        String[] pointsDelimited = StringUtils.split(fcount.getName(), ',');
                        List<Float> coords = new ArrayList<Float>();

                        for (String coord : pointsDelimited) {
                            try {
                                Float decimalCoord = Float.parseFloat(coord);
                                coords.add(decimalCoord);
                            } catch (NumberFormatException numberFormatException) {
                                logger.warn("Error parsing Float for Lat/Long: "
                                        + numberFormatException.getMessage(), numberFormatException);
                            }
                        }

                        if (!coords.isEmpty()) {
                            Collections.reverse(coords); // must be long, lat order
                            point.setCoordinates(coords);
                            points.add(point);
                        }
                    }
                }
            }
        }
    }
    return points;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * @see au.org.ala.biocache.dao.SearchDAO#getFacetPointsShort(au.org.ala.biocache.dto.SpatialSearchRequestParams, String)
 *///from w w w.j ava2s . c om
@Override
public FacetField getFacetPointsShort(SpatialSearchRequestParams searchParams, String pointType)
        throws Exception {
    queryFormatUtils.formatSearchQuery(searchParams);
    if (logger.isInfoEnabled()) {
        logger.info("search query: " + searchParams.getFormattedQuery());
    }
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setRequestHandler("standard");
    solrQuery.setQuery(searchParams.getFormattedQuery());
    solrQuery.setRows(0);
    solrQuery.setFacet(true);
    solrQuery.addFacetField(pointType);
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(searchParams.getFlimit());//MAX_DOWNLOAD_SIZE);  // unlimited = -1

    QueryResponse qr = runSolrQuery(solrQuery, searchParams.getFormattedFq(), 0, 0, "_docid_", "asc");
    List<FacetField> facets = qr.getFacetFields();

    //return first facet, there should only be 1
    if (facets != null && facets.size() > 0) {
        return facets.get(0);
    }
    return null;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * @see au.org.ala.biocache.dao.SearchDAO#getOccurrences(au.org.ala.biocache.dto.SpatialSearchRequestParams, au.org.ala.biocache.dto.PointType, String)
 */// w  ww .  j  av a2s .c  o m
@Override
public List<OccurrencePoint> getOccurrences(SpatialSearchRequestParams searchParams, PointType pointType,
        String colourBy) throws Exception {

    List<OccurrencePoint> points = new ArrayList<OccurrencePoint>();
    searchParams.setPageSize(100);

    String queryString = "";
    queryFormatUtils.formatSearchQuery(searchParams);
    queryString = searchParams.getFormattedQuery();

    if (logger.isInfoEnabled()) {
        logger.info("search query: " + queryString);
    }
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    solrQuery.setQuery(queryString);
    solrQuery.setRows(0);
    solrQuery.setFacet(true);
    solrQuery.addFacetField(pointType.getLabel());
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(MAX_DOWNLOAD_SIZE); // unlimited = -1

    QueryResponse qr = runSolrQuery(solrQuery, searchParams);
    SearchResultDTO searchResults = processSolrResponse(searchParams, qr, solrQuery, OccurrenceIndex.class);
    List<OccurrenceIndex> ocs = searchResults.getOccurrences();

    if (!ocs.isEmpty() && ocs.size() > 0) {

        for (OccurrenceIndex oc : ocs) {

            List<Float> coords = new ArrayList<Float>();
            coords.add(oc.getDecimalLongitude().floatValue());
            coords.add(oc.getDecimalLatitude().floatValue());

            OccurrencePoint point = new OccurrencePoint();
            point.setCoordinates(coords);

            point.setOccurrenceUid(oc.getUuid());

            points.add(point);
        }
    }

    return points;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * http://ala-biocache1.vm.csiro.au:8080/solr/select?q=*:*&rows=0&facet=true&facet.field=data_provider_id&facet.field=data_provider&facet.sort=data_provider_id
 *
 * @see au.org.ala.biocache.dao.SearchDAO#getDataProviderCounts()
 *///from   www . j  av a 2s . c o m
//IS THIS BEING USED BY ANYTHING??
@Override
public List<DataProviderCountDTO> getDataProviderCounts() throws Exception {

    List<DataProviderCountDTO> dpDTOs = new ArrayList<DataProviderCountDTO>(); // new OccurrencePoint(PointType.POINT);
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    solrQuery.setQuery("*:*");
    solrQuery.setRows(0);
    solrQuery.setFacet(true);
    solrQuery.addFacetField("data_provider_uid");
    solrQuery.addFacetField("data_provider");
    solrQuery.setFacetMinCount(1);
    QueryResponse qr = runSolrQuery(solrQuery, null, 1, 0, "data_provider", "asc");
    List<FacetField> facets = qr.getFacetFields();

    if (facets != null && facets.size() == 2) {

        FacetField dataProviderIdFacet = facets.get(0);
        FacetField dataProviderNameFacet = facets.get(1);

        List<FacetField.Count> dpIdEntries = dataProviderIdFacet.getValues();
        List<FacetField.Count> dpNameEntries = dataProviderNameFacet.getValues();

        if (dpIdEntries != null) {
            for (int i = 0; i < dpIdEntries.size(); i++) {

                FacetField.Count dpIdEntry = dpIdEntries.get(i);
                FacetField.Count dpNameEntry = dpNameEntries.get(i);

                String dataProviderId = dpIdEntry.getName();
                String dataProviderName = dpNameEntry.getName();
                long count = dpIdEntry.getCount();

                if (count > 0) {
                    DataProviderCountDTO dto = new DataProviderCountDTO(dataProviderId, dataProviderName,
                            count);
                    dpDTOs.add(dto);
                }
            }
        }
    }
    if (logger.isInfoEnabled()) {
        logger.info("Find data providers = " + dpDTOs.size());
    }
    return dpDTOs;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * @see au.org.ala.biocache.dao.SearchDAO#findRecordByStateFor(java.lang.String)
 * IS THIS BEGIN USED OR NECESSARY/*from   ww  w  . java  2 s.co m*/
 */
@Override
public List<FieldResultDTO> findRecordByStateFor(String query) throws Exception {
    List<FieldResultDTO> fDTOs = new ArrayList<FieldResultDTO>(); // new OccurrencePoint(PointType.POINT);
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    solrQuery.setQuery(query);
    solrQuery.setRows(0);
    solrQuery.setFacet(true);
    solrQuery.addFacetField("state");
    solrQuery.setFacetMinCount(1);
    QueryResponse qr = runSolrQuery(solrQuery, null, 1, 0, "data_provider", "asc");
    List<FacetField> facets = qr.getFacetFields();
    FacetField ff = qr.getFacetField("state");
    if (ff != null) {
        for (Count count : ff.getValues()) {
            //only start adding counts when we hit a decade with some results.
            if (count.getCount() > 0) {
                FieldResultDTO f = new FieldResultDTO(count.getName(), count.getCount());
                fDTOs.add(f);
            }
        }
    }
    return fDTOs;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * Calculates the breakdown of the supplied query based on the supplied params
 *//*from ww w  .ja  va 2 s .c o m*/
public TaxaRankCountDTO calculateBreakdown(BreakdownRequestParams queryParams) throws Exception {
    if (logger.isDebugEnabled()) {
        logger.debug("Attempting to find the counts for " + queryParams);
    }
    TaxaRankCountDTO trDTO = null;
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    queryFormatUtils.formatSearchQuery(queryParams);
    solrQuery.setQuery(queryParams.getFormattedQuery());
    queryParams.setPageSize(0);
    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetSort("count");
    solrQuery.setFacetLimit(-1);

    //add the rank:name as a fq if necessary
    if (StringUtils.isNotEmpty(queryParams.getName()) && StringUtils.isNotEmpty(queryParams.getRank())) {
        queryParams.setFormattedFq((String[]) ArrayUtils.addAll(queryParams.getFormattedFq(),
                new String[] { queryParams.getRank() + ":" + queryParams.getName() }));
    }
    //add the ranks as facets
    if (queryParams.getLevel() == null) {
        List<String> ranks = queryParams.getRank() != null
                ? searchUtils.getNextRanks(queryParams.getRank(), queryParams.getName() == null)
                : searchUtils.getRanks();
        for (String r : ranks) {
            solrQuery.addFacetField(r);
        }
    } else {
        //the user has supplied the "exact" level at which to perform the breakdown
        solrQuery.addFacetField(queryParams.getLevel());
    }
    QueryResponse qr = runSolrQuery(solrQuery, queryParams);
    if (queryParams.getMax() != null && queryParams.getMax() > 0) {
        //need to get the return level that the number of facets are <=max ranks need to be processed in reverse order until max is satisfied
        if (qr.getResults().getNumFound() > 0) {
            List<FacetField> ffs = qr.getFacetFields();
            //reverse the facets so that they are returned in rank reverse order species, genus, family etc
            Collections.reverse(ffs);
            for (FacetField ff : ffs) {
                //logger.debug("Handling " + ff.getName());
                trDTO = new TaxaRankCountDTO(ff.getName());
                if (ff.getValues() != null && ff.getValues().size() <= queryParams.getMax()) {
                    List<FieldResultDTO> fDTOs = new ArrayList<FieldResultDTO>();
                    for (Count count : ff.getValues()) {
                        if (count.getCount() > 0) {
                            FieldResultDTO f = new FieldResultDTO(count.getName(), count.getCount());
                            fDTOs.add(f);
                        }
                    }
                    trDTO.setTaxa(fDTOs);
                    break;
                }
            }

        }
    } else if (queryParams.getRank() != null || queryParams.getLevel() != null) {
        //just want to process normally the rank to facet on will start with the highest rank and then go down until one exists for
        if (qr.getResults().getNumFound() > 0) {
            List<FacetField> ffs = qr.getFacetFields();
            for (FacetField ff : ffs) {
                trDTO = new TaxaRankCountDTO(ff.getName());
                if (ff != null && ff.getValues() != null) {
                    List<Count> counts = ff.getValues();
                    if (counts.size() > 0) {
                        List<FieldResultDTO> fDTOs = new ArrayList<FieldResultDTO>();
                        for (Count count : counts) {
                            if (count.getCount() > 0) {
                                FieldResultDTO f = new FieldResultDTO(count.getName(), count.getCount());
                                fDTOs.add(f);
                            }
                        }
                        trDTO.setTaxa(fDTOs);
                        break;
                    }
                }
            }
        }

    }
    return trDTO;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * @see au.org.ala.biocache.dao.SearchDAO#findTaxonCountForUid(au.org.ala.biocache.dto.BreakdownRequestParams, String)
 * @deprecated use {@link #calculateBreakdown(BreakdownRequestParams)} instead
 *//*from   ww w . java  2s .  c o  m*/
@Deprecated
public TaxaRankCountDTO findTaxonCountForUid(BreakdownRequestParams breakdownParams, String query)
        throws Exception {
    TaxaRankCountDTO trDTO = null;
    List<String> ranks = breakdownParams.getLevel() == null
            ? searchUtils.getNextRanks(breakdownParams.getRank(), breakdownParams.getName() == null)
            : new ArrayList<String>();
    if (breakdownParams.getLevel() != null)
        ranks.add(breakdownParams.getLevel());
    if (ranks != null && ranks.size() > 0) {
        SolrQuery solrQuery = new SolrQuery();
        solrQuery.setQueryType("standard");
        solrQuery.setQuery(query);
        solrQuery.setRows(0);
        solrQuery.setFacet(true);
        solrQuery.setFacetMinCount(1);
        solrQuery.setFacetSort("count");
        solrQuery.setFacetLimit(-1); //we want all facets
        for (String r : ranks) {
            solrQuery.addFacetField(r);
        }
        QueryResponse qr = runSolrQuery(solrQuery,
                queryFormatUtils.getQueryContextAsArray(breakdownParams.getQc()), 1, 0,
                breakdownParams.getRank(), "asc");
        if (qr.getResults().size() > 0) {
            for (String r : ranks) {
                trDTO = new TaxaRankCountDTO(r);
                FacetField ff = qr.getFacetField(r);
                if (ff != null && ff.getValues() != null) {
                    List<Count> counts = ff.getValues();
                    if (counts.size() > 0) {
                        List<FieldResultDTO> fDTOs = new ArrayList<FieldResultDTO>();
                        for (Count count : counts) {
                            FieldResultDTO f = new FieldResultDTO(count.getName(), count.getCount());
                            fDTOs.add(f);
                        }
                        trDTO.setTaxa(fDTOs);
                        break;
                    }
                }
            }
        }
    }
    return trDTO;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * Helper method to create SolrQuery object and add facet settings
 *
 * @return solrQuery the SolrQuery//from ww w. j a  va 2  s. com
 */
protected SolrQuery initSolrQuery(SearchRequestParams searchParams, boolean substituteDefaultFacetOrder,
        Map<String, String[]> extraSolrParams) {

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    boolean rangeAdded = false;
    // Facets
    solrQuery.setFacet(searchParams.getFacet());
    if (searchParams.getFacet()) {
        for (String facet : searchParams.getFacets()) {
            if (facet.equals("date") || facet.equals("decade")) {
                String fname = facet.equals("decade") ? OCCURRENCE_YEAR_INDEX_FIELD : "occurrence_" + facet;
                initDecadeBasedFacet(solrQuery, fname);
            } else if (facet.equals("uncertainty")) {
                Map<String, String> rangeMap = rangeBasedFacets.getRangeMap("uncertainty");
                for (String range : rangeMap.keySet()) {
                    solrQuery.add("facet.query", range);
                }
            } else if (facet.endsWith(RANGE_SUFFIX)) {
                //this facte need to have it ranges included.
                if (!rangeAdded) {
                    solrQuery.add("facet.range.other", "before");
                    solrQuery.add("facet.range.other", "after");
                }
                String field = facet.replaceAll(RANGE_SUFFIX, "");
                StatsIndexFieldDTO details = getRangeFieldDetails(field);
                if (details != null) {
                    solrQuery.addNumericRangeFacet(field, details.getStart(), details.getEnd(),
                            details.getGap());
                }
            } else {
                solrQuery.addFacetField(facet);

                if ("".equals(searchParams.getFsort()) && substituteDefaultFacetOrder
                        && FacetThemes.getFacetsMap().containsKey(facet)) {
                    //now check if the sort order is different to supplied
                    String thisSort = FacetThemes.getFacetsMap().get(facet).getSort();
                    if (!searchParams.getFsort().equalsIgnoreCase(thisSort))
                        solrQuery.add("f." + facet + ".facet.sort", thisSort);
                }

            }
        }

        solrQuery.setFacetMinCount(1);
        solrQuery.setFacetLimit(searchParams.getFlimit());
        //include this so that the default fsort is still obeyed.
        String fsort = "".equals(searchParams.getFsort()) ? "count" : searchParams.getFsort();
        solrQuery.setFacetSort(fsort);
        if (searchParams.getFoffset() > 0)
            solrQuery.add("facet.offset", Integer.toString(searchParams.getFoffset()));
        if (StringUtils.isNotEmpty(searchParams.getFprefix()))
            solrQuery.add("facet.prefix", searchParams.getFprefix());
    }

    solrQuery.setRows(10);
    solrQuery.setStart(0);

    if (searchParams.getFl().length() > 0) {
        solrQuery.setFields(searchParams.getFl());
    }

    //add the extra SOLR params
    if (extraSolrParams != null) {
        //automatically include the before and after params...
        if (!rangeAdded) {
            solrQuery.add("facet.range.other", "before");
            solrQuery.add("facet.range.other", "after");
        }
        for (String key : extraSolrParams.keySet()) {
            String[] values = extraSolrParams.get(key);
            solrQuery.add(key, values);
        }
    }
    return solrQuery;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * Get a distinct list of species and their counts using a facet search
 *
 * @param queryString/* www.  j  a v  a  2 s.  com*/
 * @param pageSize
 * @param sortField
 * @param sortDirection
 * @return
 * @throws SolrServerException
 */
protected List<TaxaCountDTO> getSpeciesCounts(String queryString, List<String> filterQueries,
        List<String> facetFields, Integer pageSize, Integer startIndex, String sortField, String sortDirection)
        throws SolrServerException {

    List<TaxaCountDTO> speciesCounts = new ArrayList<TaxaCountDTO>();
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    solrQuery.setQuery(queryString);

    if (filterQueries != null && filterQueries.size() > 0) {
        //solrQuery.addFilterQuery("(" + StringUtils.join(filterQueries, " OR ") + ")");
        for (String fq : filterQueries) {
            solrQuery.addFilterQuery(fq);
        }
    }
    solrQuery.setRows(0);
    solrQuery.setFacet(true);
    solrQuery.setFacetSort(sortField);
    for (String facet : facetFields) {
        solrQuery.addFacetField(facet);
        if (logger.isDebugEnabled()) {
            logger.debug("adding facetField: " + facet);
        }
    }
    //set the facet starting point based on the paging information
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(pageSize); // unlimited = -1 | pageSize
    solrQuery.add("facet.offset", Integer.toString(startIndex));
    if (logger.isDebugEnabled()) {
        logger.debug("getSpeciesCount query :" + solrQuery.getQuery());
    }
    QueryResponse qr = runSolrQuery(solrQuery, null, 1, 0, "score", sortDirection);
    if (logger.isInfoEnabled()) {
        logger.info("SOLR query: " + solrQuery.getQuery() + "; total hits: " + qr.getResults().getNumFound());
    }
    List<FacetField> facets = qr.getFacetFields();
    java.util.regex.Pattern p = java.util.regex.Pattern.compile("\\|");

    if (facets != null && facets.size() > 0) {
        if (logger.isDebugEnabled()) {
            logger.debug("Facets: " + facets.size() + "; facet #1: " + facets.get(0).getName());
        }
        for (FacetField facet : facets) {
            List<FacetField.Count> facetEntries = facet.getValues();
            if ((facetEntries != null) && (facetEntries.size() > 0)) {

                for (FacetField.Count fcount : facetEntries) {
                    TaxaCountDTO tcDTO = null;
                    String name = fcount.getName() != null ? fcount.getName() : "";
                    if (fcount.getFacetField().getName().equals(NAMES_AND_LSID)) {
                        String[] values = p.split(name, 5);

                        if (values.length >= 5) {
                            if (!"||||".equals(name)) {
                                tcDTO = new TaxaCountDTO(values[0], fcount.getCount());
                                tcDTO.setGuid(StringUtils.trimToNull(values[1]));
                                tcDTO.setCommonName(values[2]);
                                tcDTO.setKingdom(values[3]);
                                tcDTO.setFamily(values[4]);
                                if (StringUtils.isNotEmpty(tcDTO.getGuid()))
                                    tcDTO.setRank(searchUtils.getTaxonSearch(tcDTO.getGuid())[1].split(":")[0]);
                            }
                        } else {
                            if (logger.isDebugEnabled()) {
                                logger.debug("The values length: " + values.length + " :" + name);
                            }
                            tcDTO = new TaxaCountDTO(name, fcount.getCount());
                        }
                        //speciesCounts.add(i, tcDTO);
                        if (tcDTO != null && tcDTO.getCount() > 0)
                            speciesCounts.add(tcDTO);
                    } else if (fcount.getFacetField().getName().equals(COMMON_NAME_AND_LSID)) {
                        String[] values = p.split(name, 6);

                        if (values.length >= 5) {
                            if (!"|||||".equals(name)) {
                                tcDTO = new TaxaCountDTO(values[1], fcount.getCount());
                                tcDTO.setGuid(StringUtils.trimToNull(values[2]));
                                tcDTO.setCommonName(values[0]);
                                //cater for the bug of extra vernacular name in the result
                                tcDTO.setKingdom(values[values.length - 2]);
                                tcDTO.setFamily(values[values.length - 1]);
                                if (StringUtils.isNotEmpty(tcDTO.getGuid()))
                                    tcDTO.setRank(searchUtils.getTaxonSearch(tcDTO.getGuid())[1].split(":")[0]);
                            }
                        } else {
                            if (logger.isDebugEnabled()) {
                                logger.debug("The values length: " + values.length + " :" + name);
                            }
                            tcDTO = new TaxaCountDTO(name, fcount.getCount());
                        }
                        //speciesCounts.add(i, tcDTO);
                        if (tcDTO != null && tcDTO.getCount() > 0) {
                            speciesCounts.add(tcDTO);
                        }
                    }
                }
            }
        }
    }

    return speciesCounts;
}

From source file:au.org.ala.biocache.dao.SearchDAOImpl.java

License:Open Source License

/**
 * Obtains a list and facet count of the source uids for the supplied query.
 *
 * @param searchParams/*from   ww w. j a  v  a2 s  .  c  o m*/
 * @return
 * @throws Exception
 */
public Map<String, Integer> getSourcesForQuery(SpatialSearchRequestParams searchParams) throws Exception {

    Map<String, Integer> uidStats = new HashMap<String, Integer>();
    SolrQuery solrQuery = new SolrQuery();
    queryFormatUtils.formatSearchQuery(searchParams);
    if (logger.isInfoEnabled()) {
        logger.info("The query : " + searchParams.getFormattedQuery());
    }
    solrQuery.setQuery(searchParams.getFormattedQuery());
    solrQuery.setQueryType("standard");
    solrQuery.setRows(0);
    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(1);
    solrQuery.addFacetField("data_provider_uid");
    solrQuery.addFacetField("data_resource_uid");
    solrQuery.addFacetField("collection_uid");
    solrQuery.addFacetField("institution_uid");
    QueryResponse qr = runSolrQuery(solrQuery, searchParams.getFormattedFq(), 1, 0, "score", "asc");
    //now cycle through and get all the facets
    List<FacetField> facets = qr.getFacetFields();
    for (FacetField facet : facets) {
        if (facet.getValues() != null) {
            for (FacetField.Count ffc : facet.getValues()) {
                if (ffc.getCount() > 0) {
                    uidStats.put(ffc.getName() != null ? ffc.getName() : "", new Integer((int) ffc.getCount()));
                }
            }
        }
    }
    return uidStats;
}