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

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

Introduction

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

Prototype

public SolrQuery setFacetLimit(int lim) 

Source Link

Document

set the facet limit

Usage

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/*ww w.jav a  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

private List<FacetResultDTO> getMultivalueFacetCounts(SolrQuery query, SpatialSearchRequestParams searchParams,
        List<String> facet) throws Exception {
    for (String s : facet) {
        query.addFacetField(s);/*from   ww w  . j a va 2  s. c o  m*/
    }

    int flimit = searchParams.getFlimit();
    query.setFacetLimit(-1);

    QueryResponse response = runSolrQuery(query, searchParams);
    SearchResultDTO searchResults = processSolrResponse(searchParams, response, query, OccurrenceIndex.class);

    //include paged facets when flimit > 0
    Collection<FacetResultDTO> facetResults = new ArrayList<FacetResultDTO>();
    if (searchParams.getFlimit() > 0) {

        facetResults = searchResults.getFacetResults();
        if (facetResults != null) {
            for (FacetResultDTO fr : facetResults) {
                if (fr.getFieldResult() != null && fr.getFieldResult().size() > 0) {
                    for (FacetField ff : response.getFacetFields()) {
                        fr.setCount(0);
                        if (ff != null && StringUtils.equals(ff.getName(), fr.getFieldName())) {
                            fr.setCount(ff.getValueCount());
                        }
                    }
                    //sort and apply limit and offset
                    Collections.sort(fr.getFieldResult(), new Comparator<FieldResultDTO>() {
                        @Override
                        public int compare(FieldResultDTO o1, FieldResultDTO o2) {
                            long result = o1.getCount() - o2.getCount();
                            if (result == 0) {
                                return o1.getLabel() != null ? o1.getLabel().compareTo(o2.getLabel())
                                        : (o2.getLabel() == null ? 0 : 1);
                            } else {
                                return result > 0 ? -1 : 1;
                            }
                        }
                    });
                    int from = Math.min(fr.getFieldResult().size() - 1, searchParams.getFoffset());
                    int to = Math.min(fr.getFieldResult().size(),
                            searchParams.getFoffset() + searchParams.getFlimit());
                    fr.setFieldResult(new ArrayList(fr.getFieldResult().subList(from, to)));
                }
            }
        }
    } else {
        //only return totals counts
        for (FacetField ff : response.getFacetFields()) {
            facetResults.add(new FacetResultDTO(ff.getName(), null, ff.getValueCount()));
        }
    }

    query.setFacetLimit(flimit);

    return new ArrayList<FacetResultDTO>(facetResults);
}

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

License:Open Source License

@Cacheable(cacheName = "legendCache")
public List<LegendItem> getLegend(SpatialSearchRequestParams searchParams, String facetField,
        String[] cutpoints) throws Exception {
    List<LegendItem> legend = new ArrayList<LegendItem>();

    queryFormatUtils.formatSearchQuery(searchParams);
    if (logger.isInfoEnabled()) {
        logger.info("search query: " + searchParams.getFormattedQuery());
    }//from   w  w w .  j a  v  a  2 s .  c  o  m
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    solrQuery.setQuery(searchParams.getFormattedQuery());
    solrQuery.setRows(0);
    solrQuery.setFacet(true);

    //is facet query?
    if (cutpoints == null) {
        //special case for the decade
        if (DECADE_FACET_NAME.equals(facetField))
            initDecadeBasedFacet(solrQuery, "occurrence_year");
        else
            solrQuery.addFacetField(facetField);
    } else {
        solrQuery.addFacetQuery("-" + facetField + ":[* TO *]");

        for (int i = 0; i < cutpoints.length; i += 2) {
            solrQuery.addFacetQuery(facetField + ":[" + cutpoints[i] + " TO " + cutpoints[i + 1] + "]");
        }
    }

    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(-1);//MAX_DOWNLOAD_SIZE);  // unlimited = -1

    solrQuery.setFacetMissing(true);

    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(facetField) && (facetEntries != null) && (facetEntries.size() > 0)) {
                int i = 0;
                for (i = 0; i < facetEntries.size(); i++) {
                    FacetField.Count fcount = facetEntries.get(i);
                    if (fcount.getCount() > 0) {
                        String fq = facetField + ":\"" + fcount.getName() + "\"";
                        if (fcount.getName() == null) {
                            fq = "-" + facetField + ":[* TO *]";
                        }
                        legend.add(new LegendItem(fcount.getName(), fcount.getCount(), fq));
                    }
                }
                break;
            }
        }
    }
    //check if we have query based facets
    Map<String, Integer> facetq = qr.getFacetQuery();
    if (facetq != null && facetq.size() > 0) {
        for (Entry<String, Integer> es : facetq.entrySet()) {
            legend.add(new LegendItem(es.getKey(), es.getValue(), es.getKey()));
        }
    }

    //check to see if we have a date range facet
    List<FacetField> facetDates = qr.getFacetDates();
    if (facetDates != null && !facetDates.isEmpty()) {
        FacetField ff = facetDates.get(0);
        String firstDate = null;
        for (FacetField.Count facetEntry : ff.getValues()) {
            String startDate = facetEntry.getName();
            if (firstDate == null) {
                firstDate = startDate;
            }
            String finishDate;
            if (DECADE_PRE_1850_LABEL.equals(startDate)) {
                startDate = "*";
                finishDate = firstDate;
            } else {
                int startYear = Integer.parseInt(startDate.substring(0, 4));
                finishDate = (startYear - 1) + "-12-31T23:59:59Z";
            }
            legend.add(new LegendItem(facetEntry.getName(), facetEntry.getCount(),
                    "occurrence_year:[" + startDate + " TO " + finishDate + "]"));
        }
    }
    return legend;
}

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

License:Open Source License

public FacetField getFacet(SpatialSearchRequestParams searchParams, String facet) throws Exception {
    queryFormatUtils.formatSearchQuery(searchParams);
    if (logger.isInfoEnabled()) {
        logger.info("search query: " + searchParams.getFormattedQuery());
    }//from   ww w  . ja  v a 2  s . com
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    solrQuery.setQuery(searchParams.getFormattedQuery());
    solrQuery.setRows(0);
    solrQuery.setFacet(true);
    solrQuery.addFacetField(facet);
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(-1); //MAX_DOWNLOAD_SIZE);  // unlimited = -1

    QueryResponse qr = runSolrQuery(solrQuery, searchParams.getFormattedFq(), 1, 0, "score", "asc");
    return qr.getFacetFields().get(0);
}

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

License:Open Source License

public Map<String, Integer> getOccurrenceCountsForTaxa(List<String> taxa) throws Exception {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQueryType("standard");
    solrQuery.setRows(0);/*from   w ww.java 2 s  .  c o  m*/
    solrQuery.setFacet(true);
    solrQuery.setFacetLimit(taxa.size());
    StringBuilder sb = new StringBuilder();
    Map<String, Integer> counts = new HashMap<String, Integer>();
    Map<String, String> lftToGuid = new HashMap<String, String>();
    for (String lsid : taxa) {
        //get the lft and rgt value for the taxon
        String[] values = searchUtils.getTaxonSearch(lsid);
        //first value is the search string
        if (sb.length() > 0)
            sb.append(" OR ");
        sb.append(values[0]);
        lftToGuid.put(values[0], lsid);
        //add the query part as a facet
        solrQuery.add("facet.query", values[0]);
    }
    solrQuery.setQuery(sb.toString());

    //solrQuery.add("facet.query", "confidence:" + os.getRange());
    QueryResponse qr = runSolrQuery(solrQuery, null, 1, 0, "score", "asc");
    Map<String, Integer> facetQueries = qr.getFacetQuery();
    for (String facet : facetQueries.keySet()) {
        //add all the counts based on the query value that was substituted
        String lsid = lftToGuid.get(facet);
        Integer count = facetQueries.get(facet);
        if (lsid != null && count != null)
            counts.put(lsid, count);
    }
    if (logger.isDebugEnabled()) {
        logger.debug(facetQueries);
    }
    return counts;
}

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

License:Open Source License

private List<FacetField.Count> extractFacet(String queryString, String[] filterQueries, String facetName)
        throws Exception {
    SolrQuery query = new SolrQuery(queryString);
    query.setFacet(true);/*from  ww  w.j  a  v  a 2s  .c  o  m*/
    query.addFacetField(facetName);
    query.setRows(0);
    query.setFacetLimit(200000);
    query.setStart(0);
    query.setFacetMinCount(1);
    query.setFacetSort("index");
    //query.setFacet
    if (filterQueries != null) {
        for (String fq : filterQueries)
            query.addFilterQuery(fq);
    }
    QueryResponse response = server.query(query);
    List<FacetField.Count> fc = response.getFacetField(facetName).getValues();
    if (fc == null) {
        fc = new ArrayList<FacetField.Count>();
    }
    return fc;
}

From source file:com.doculibre.constellio.services.FacetServicesImpl.java

License:Open Source License

public static SolrQuery toSolrQuery(SimpleSearch simpleSearch, int start, int row,
        boolean includeSingleValueFacets, boolean notIncludedOnly, List<String> customFieldFacets,
        List<String> customQueryFacets, ConstellioUser user) {
    String solrServerName = simpleSearch.getCollectionName();
    RecordCollectionServices collectionServices = ConstellioSpringUtils.getRecordCollectionServices();
    RecordCollection collection = collectionServices.get(solrServerName);
    SolrServices solrServices = ConstellioSpringUtils.getSolrServices();
    Boolean usesDisMax = solrServices.usesDisMax(collection);
    SolrQuery query;
    if (!collection.isOpenSearch()) {
        query = SearchServicesImpl.toSolrQuery(simpleSearch, usesDisMax, true, includeSingleValueFacets,
                notIncludedOnly);//from w ww .j  a v a  2  s.  com
    } else {
        query = SearchServicesImpl.toSolrQuery(simpleSearch, usesDisMax, false, true, false);
    }

    query.setParam(ConstellioSolrQueryParams.COLLECTION_NAME, simpleSearch.getCollectionName());
    query.setParam(ConstellioSolrQueryParams.LUCENE_QUERY,
            simpleSearch.getLuceneQuery(includeSingleValueFacets, true));
    query.setParam(ConstellioSolrQueryParams.SIMPLE_SEARCH, simpleSearch.toSimpleParams().toString());
    if (user != null) {
        query.setParam(ConstellioSolrQueryParams.USER_ID, "" + user.getId());
    }

    if (StringUtils.isEmpty(query.getQuery())) {
        query.setQuery(SimpleSearch.SEARCH_ALL);
        query.setRequestHandler("/elevate");
    }

    query.set("shards.qt", "/elevate");
    query.setRequestHandler("/elevate");

    query.setRows(row);
    query.setStart(start);
    query.setHighlight(true);
    query.setHighlightFragsize(100);
    query.setHighlightSnippets(2);

    query.setFacet(true);
    query.setFacetLimit(400);
    query.setFacetMinCount(1);

    if (collection.isOpenSearch()) {
        query.setParam("openSearchURL", collection.getOpenSearchURL());
        Locale locale = simpleSearch.getSingleSearchLocale();
        if (locale != null) {
            query.setParam("lang", locale.getLanguage());
        }
    } else {
        for (CollectionFacet collectionFacet : collection.getCollectionFacets()) {
            if (customFieldFacets == null && collectionFacet.isFieldFacet()) {
                IndexField indexField = collectionFacet.getFacetField();
                String indexFieldName = indexField.getName();
                if (!notIncludedOnly) {
                    query.addFacetField(indexFieldName);
                } else {
                    SearchedFacet searchedFacet = simpleSearch.getSearchedFacet(indexFieldName);
                    if (searchedFacet != null) {
                        if (!searchedFacet.getIncludedValues().isEmpty()) {
                            StringBuffer sbEx = new StringBuffer();
                            sbEx.append("{!ex=dt}");
                            //                                sbEx.append("{!ex=");
                            //                                boolean first = true;
                            //                                for (String includedValue : searchedFacet.getIncludedValues()) {
                            //                                    if (first) {
                            //                                        first = false;
                            //                                    } else {
                            //                                        sbEx.append(",");
                            //                                    }
                            //                                    sbEx.append(includedValue); 
                            //                                }
                            //                                sbEx.append("}");
                            //                                query.setParam("facet.field", sbEx.toString() + indexFieldName);
                            query.addFacetField(sbEx.toString() + indexFieldName);
                        } else {
                            query.addFacetField(indexFieldName);
                        }
                    }
                }
            } else if (customQueryFacets == null && collectionFacet.isQueryFacet()) {
                // Modification Rida, remplacement de collectionFacet.getLabels() par
                // collectionFacet.getLabelledValues()
                // for (I18NLabel valueLabels : collectionFacet.getLabels()) {
                for (I18NLabel valueLabels : collectionFacet.getLabelledValues()) {
                    String facetQuery = valueLabels.getKey();
                    query.addFacetQuery(facetQuery);
                }
            }
        }
        if (customFieldFacets != null) {
            for (String facetField : customFieldFacets) {
                if (!notIncludedOnly) {
                    query.addFacetField(facetField);
                } else {
                    StringBuffer sbEx = new StringBuffer();
                    sbEx.append("{!ex=dt}");
                    //                        sbEx.append("{!ex=");
                    //                        boolean first = true;
                    //                        for (String includedValue : searchedFacet.getIncludedValues()) {
                    //                            if (first) {
                    //                                first = false;
                    //                            } else {
                    //                                sbEx.append(",");
                    //                            }
                    //                            sbEx.append(includedValue); 
                    //                        }
                    //                        sbEx.append("}");
                    query.setParam("facet.field", sbEx.toString() + facetField);
                }
            }
        }

        if (customQueryFacets != null) {
            for (String facetQuery : customQueryFacets) {
                query.addFacetQuery(facetQuery);
            }
        }
    }

    return query;
}

From source file:com.frank.search.solr.core.DefaultQueryParser.java

License:Apache License

private boolean enableFaceting(SolrQuery solrQuery, FacetQuery query) {
    FacetOptions facetOptions = query.getFacetOptions();
    if (facetOptions == null || !facetOptions.hasFacets()) {
        return false;
    }/*from   w  w  w.java  2 s. c o m*/
    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(facetOptions.getFacetMinCount());
    solrQuery.setFacetLimit(facetOptions.getPageable().getPageSize());
    if (facetOptions.getPageable().getPageNumber() > 0) {
        int offset = Math.max(0, facetOptions.getPageable().getOffset());
        solrQuery.set(FacetParams.FACET_OFFSET, offset);
    }
    if (FacetOptions.FacetSort.INDEX.equals(facetOptions.getFacetSort())) {
        solrQuery.setFacetSort(FacetParams.FACET_SORT_INDEX);
    }
    return true;
}

From source file:com.github.fengtan.sophie.tables.DocumentsTable.java

License:Open Source License

/**
 * Get a list of remote facets keyed by field name.
 * //from   w  w  w.  jav a  2  s .c  o m
 * @param fields
 *            Fields.
 * @return List of facets keyed by field name.
 * @throws SophieException
 *             If facets could not be fetched.
 */
private Map<String, FacetField> getRemoteFacets(List<FieldInfo> fields) throws SophieException {
    // Prepare query.
    SolrQuery query = getBaseQuery(0, 0);
    query.setFacet(true);
    query.setFacetSort("index");
    query.setFacetLimit(FACET_LIMIT);
    query.setFacetMissing(true);

    // For each field, determine whether Solr can generate a facet (fq works
    // only on indexed fields). If yes, then list that field in the query.
    for (FieldInfo field : fields) {
        if (SolrUtils.getFlags(field).contains(FieldFlag.INDEXED)) {
            query.addFacetField(field.getName());
        }
    }

    // Send query.
    Map<String, FacetField> facets = new HashMap<String, FacetField>();
    try {
        for (FacetField facet : Sophie.client.query(query).getFacetFields()) {
            facets.put(facet.getName(), facet);
        }
    } catch (SolrServerException | IOException | SolrException e) {
        throw new SophieException("Unable to fetch remote facets", e);
    }

    // Return facets keyed by field name.
    return facets;
}

From source file:com.googlecode.solrgeonames.server.GeoServlet.java

License:Open Source License

/**
 * Prepare a 'suggest' query response//from w w  w  . j a v a  2 s  .  c o  m
 *
 * @param request The incoming request
 * @param response The response object
 * @throws IOException If errors found
 */
private QueryResponse runQuery(String query, int start, int rows, String fields, String filter, String[] facets,
        int facetLimit) throws Exception {
    SolrQuery q = new SolrQuery();
    q.setQuery(query);
    q.setStart(start);
    q.setRows(rows);
    q.setFields(fields);
    if (filter != null) {
        q.setFilterQueries(filter);
    }
    if (facets != null) {
        q.setFacet(true);
        q.setFacetLimit(facetLimit);
        q.addFacetField(facets);
    } else {
        q.setFacet(false);
    }
    return solrServer.query(q);
}