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

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

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

Introduction

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

Prototype

public SolrQuery setRows(Integer rows)

Source Link

Usage

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)
 */// w  w  w  .  jav  a 2  s  .c o  m
@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)
 *///from  w  w  w  .j a  v  a 2s  . c om
@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()
 *///w  w w .jav a  2 s.com
//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/*w  w w . j  av  a2s  .c om*/
 */
@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

/**
 * @see au.org.ala.biocache.dao.SearchDAO#findTaxonCountForUid(au.org.ala.biocache.dto.BreakdownRequestParams, String)
 * @deprecated use {@link #calculateBreakdown(BreakdownRequestParams)} instead
 *//*from  www  .j  av  a  2 s  .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

/**
 * Perform SOLR query - takes a SolrQuery and search params
 *
 * @param solrQuery//from   w w w.  j a  v  a2 s .c  o m
 * @param requestParams
 * @return
 * @throws SolrServerException
 */
private QueryResponse runSolrQuery(SolrQuery solrQuery, SearchRequestParams requestParams)
        throws SolrServerException {

    if (requestParams.getFormattedFq() != null) {
        for (String fq : requestParams.getFormattedFq()) {
            if (StringUtils.isNotEmpty(fq)) {
                solrQuery.addFilterQuery(fq);
            }
        }
    }

    //include null facets
    solrQuery.setFacetMissing(true);
    solrQuery.setRows(requestParams.getPageSize());
    solrQuery.setStart(requestParams.getStart());
    solrQuery.setSortField(requestParams.getSort(), ORDER.valueOf(requestParams.getDir()));
    if (logger.isDebugEnabled()) {
        logger.debug("runSolrQuery: " + solrQuery.toString());
    }
    QueryResponse qr = query(solrQuery, queryMethod); // can throw exception
    if (logger.isDebugEnabled()) {
        logger.debug("runSolrQuery: " + solrQuery.toString() + " qtime:" + qr.getQTime());
        if (qr.getResults() == null) {
            logger.debug("no results");
        } else {
            logger.debug("matched records: " + qr.getResults().getNumFound());
        }
    }
    return qr;
}

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/*w  w w. j  av a 2  s .co  m*/
 */
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/*from   w w  w.  j  ava  2 s.  c  o  m*/
 * @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/* w w w  . j  a  v a  2  s.  c om*/
 * @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;
}

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

License:Open Source License

/**
 * Returns the count of distinct values for the facets.  Uses groups for group counts.
 * Supports foffset and flimit for paging. Supports fsort 'count' or 'index'.
 * <p/>//from  w  ww . j  av a  2  s. com
 * TODO work out whether or not we should allow facet ranges to be downloaded....
 */
public List<FacetResultDTO> getFacetCounts(SpatialSearchRequestParams searchParams) throws Exception {
    Collection<FacetResultDTO> facetResults = new ArrayList<FacetResultDTO>();

    queryFormatUtils.formatSearchQuery(searchParams);
    String queryString = searchParams.getFormattedQuery();
    searchParams.setFacet(false);
    searchParams.setPageSize(0);

    //get facet group counts
    SolrQuery query = initSolrQuery(searchParams, false, null);
    query.setQuery(queryString);
    query.setFields(null);
    query.setRows(0);
    searchParams.setPageSize(0);

    //exclude multivalue fields
    Set<IndexFieldDTO> fields = getIndexedFields();
    List<String> multivalueFields = new ArrayList<String>();
    for (String facet : searchParams.getFacets()) {
        boolean added = false;
        for (IndexFieldDTO f : fields) {
            if (f.getName().equals(facet) && !f.isMultivalue()) {
                query.add("group.field", facet);
                added = true;
            }
        }
        if (!added) {
            multivalueFields.add(facet);
        }
    }

    if (multivalueFields.size() > 0) {
        facetResults.addAll(getMultivalueFacetCounts(query, searchParams, multivalueFields));
    }

    if (multivalueFields.size() < searchParams.getFacets().length) {
        //now use the supplied facets to add groups to the query

        // facet totals are slow, so only fetch when foffset == 0 and flimit != -1
        Map<String, Integer> ngroups = new HashMap<String, Integer>();
        GroupResponse groupResponse = null;
        if (searchParams.getFlimit() != -1 && searchParams.getFoffset() == 0) {
            query.add("group", "true");
            query.add("group.ngroups", "true");
            query.add("group.limit", "0");

            QueryResponse response = runSolrQuery(query, searchParams);
            groupResponse = response.getGroupResponse();
            for (GroupCommand gc : groupResponse.getValues()) {
                ngroups.put(gc.getName(), gc.getNGroups());
            }
        }

        //include paged facets when flimit > 0 or flimit == -1
        if (searchParams.getFlimit() != 0) {
            searchParams.setFacet(true);
            SolrQuery facetQuery = initSolrQuery(searchParams, false, null);
            facetQuery.setQuery(queryString);
            facetQuery.setFields(null);
            facetQuery.setSortField(searchParams.getSort(), ORDER.valueOf(searchParams.getDir()));
            QueryResponse qr = runSolrQuery(facetQuery, searchParams);
            SearchResultDTO searchResults = processSolrResponse(searchParams, qr, facetQuery,
                    OccurrenceIndex.class);
            facetResults = searchResults.getFacetResults();
            if (facetResults != null) {
                for (FacetResultDTO fr : facetResults) {
                    if (searchParams.getFlimit() == -1) {
                        fr.setCount(fr.getFieldResult().size());
                    } else {
                        Integer count = ngroups.get(fr.getFieldName());
                        if (count != null)
                            fr.setCount(count);
                    }
                }
            }
        } else if (groupResponse != null) {
            //only return group counts
            for (GroupCommand gc : groupResponse.getValues()) {
                facetResults.add(new FacetResultDTO(gc.getName(), null, gc.getNGroups()));
            }
        }
    }

    return new ArrayList<FacetResultDTO>(facetResults);
}