Example usage 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:com.liferay.portal.search.solr.internal.SolrIndexSearcher.java

License:Open Source License

protected void addFacets(SolrQuery solrQuery, SearchContext searchContext) {
    Map<String, Facet> facets = searchContext.getFacets();

    for (Facet facet : facets.values()) {
        if (facet.isStatic()) {
            continue;
        }//from w  w  w  .  ja  v a  2 s . c  om

        FacetConfiguration facetConfiguration = facet.getFacetConfiguration();

        _facetProcessor.processFacet(solrQuery, facet);

        String facetSort = FacetParams.FACET_SORT_COUNT;

        String order = facetConfiguration.getOrder();

        if (order.equals("OrderValueAsc")) {
            facetSort = FacetParams.FACET_SORT_INDEX;
        }

        solrQuery.add("f." + facetConfiguration.getFieldName() + ".facet.sort", facetSort);
    }

    solrQuery.setFacetLimit(-1);
}

---

From source file:com.liferay.portal.search.solr.SolrIndexSearcherImpl.java

License:Open Source License

protected Hits doSearch(SearchContext searchContext, Query query) throws Exception {

    SolrQuery solrQuery = translateQuery(searchContext.getCompanyId(), query, searchContext.getSorts(),
            searchContext.getStart(), searchContext.getEnd());

    Map<String, Facet> facets = searchContext.getFacets();

    for (Facet facet : facets.values()) {
        if (facet.isStatic()) {
            continue;
        }//  w  ww  .ja v a2  s . c  om

        FacetConfiguration facetConfiguration = facet.getFacetConfiguration();

        if (facet instanceof RangeFacet) {
            solrQuery.addFacetField(facetConfiguration.getFieldName());

            JSONObject dataJSONObject = facetConfiguration.getData();

            JSONArray rangesJSONArray = dataJSONObject.getJSONArray("ranges");

            if (rangesJSONArray == null) {
                continue;
            }

            for (int i = 0; i < rangesJSONArray.length(); i++) {
                JSONObject rangeJSONObject = rangesJSONArray.getJSONObject(i);

                String range = rangeJSONObject.getString("range");

                String facetQuery = facetConfiguration.getFieldName() + StringPool.COLON + range;

                solrQuery.addFacetQuery(facetQuery);
            }
        } else {
            solrQuery.addFacetField(facetConfiguration.getFieldName());
        }
    }

    solrQuery.setFacetLimit(-1);

    QueryResponse queryResponse = _solrServer.query(solrQuery);

    boolean allResults = false;

    if (solrQuery.getRows() == 0) {
        allResults = true;
    }

    List<FacetField> facetFields = queryResponse.getFacetFields();

    if (facetFields != null) {
        for (FacetField facetField : facetFields) {
            Facet facet = facets.get(facetField.getName());

            FacetCollector facetCollector = null;

            if (facet instanceof RangeFacet) {
                facetCollector = new SolrFacetQueryCollector(facetField.getName(),
                        queryResponse.getFacetQuery());
            } else {
                facetCollector = new SolrFacetFieldCollector(facetField.getName(), facetField);
            }

            facet.setFacetCollector(facetCollector);
        }
    }

    return subset(solrQuery, query, query.getQueryConfig(), queryResponse, allResults);
}

---

From source file:com.villemos.ispace.solr.SolrProducer.java

License:Open Source License

private void configureQuery(SolrQuery query)
        throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {

    /** Set the default values. May be overridden by later settings. */
    query.setRows(endpoint.getRows());/*w w w.  ja v a  2  s.c  om*/
    query.setSortField(endpoint.getSortField(), endpoint.getSortOrder());

    /** We per default always set highlighting. */
    query.setHighlight(true).setHighlightSnippets(1);
    query.setParam("hl.fl", "withRawText");

    /** Configure facets. */
    query.setFacet(endpoint.getFacets());
    if (endpoint.getFacets() == true) {
        query.setQuery(endpoint.getQuery());
        query.setFacetSort(endpoint.getFacetsort());
        query.setFacetLimit(endpoint.getFacetlimit());
        query.setFacetPrefix(endpoint.getFacetprefix());
        query.setFacetMinCount(endpoint.getMinCount());
        query.setFacetMissing(endpoint.isFacetMissing());
    }

    query.addFacetField(endpoint.getFacetField());
}

---

From source file:com.yaotrue.learn.solr.SolrjTest.java

License:Apache License

@Test
public void testFacet() throws SolrServerException, IOException {
    SolrQuery solrQuery = new SolrQuery("*:*");
    solrQuery.setFacet(true);/*from w w w  . j a va 2s. c  o m*/
    solrQuery.addFacetQuery("sale_price:[0 TO 200]");
    solrQuery.addFacetQuery("sale_price:[201 TO 300]");
    solrQuery.addFacetQuery("sale_price:[300 TO 400]");
    solrQuery.setFacetSort("count");

    solrQuery.addFacetField("code");
    solrQuery.setFacetMinCount(0);
    solrQuery.setFacetLimit(-1);

    QueryResponse response = solrClient.query(solrQuery);
    if (response != null) {
        List<FacetField> facetFields = response.getFacetFields();
        for (FacetField facetField : facetFields) {
            List<Count> countList = null;
            if (facetField != null) {
                countList = facetField.getValues();
                if (countList != null) {
                    for (Count count : countList) {
                        System.out.println(count.getName() + count.getCount());
                    }
                }
            }
        }

        Map<String, Integer> map = response.getFacetQuery();
        for (String key : map.keySet()) {
            System.out.println(key + ":" + map.get(key));
        }
    }
}

---

From source file:datacite.oai.provider.service.MDSSearchServiceSolrImpl.java

License:Open Source License

@Override
public Pair<List<SetRecordBean>, Integer> getSets() throws ServiceException {
    SolrQuery query = new SolrQuery();
    query.setQuery("*:*");
    query.setRows(0);/*from  w ww. j a va 2  s  . c o m*/
    query.setFacet(true);
    query.setFacetLimit(-1);
    query.addFacetField("allocator_facet", "datacentre_facet");

    try {
        QueryResponse response = solrServer.query(query);

        SortedSet<String> facetValues = new TreeSet<String>();
        for (FacetField facet : response.getFacetFields()) {
            for (Count count : facet.getValues()) {
                facetValues.add(count.getName());
            }
        }

        ArrayList<SetRecordBean> sets = new ArrayList<SetRecordBean>();
        for (String facetValue : facetValues) {
            String[] parts = facetValue.split(" - ", 2);
            String symbol = parts[0];
            String name = parts[1];
            sets.add(new SetRecordBean(symbol, name));
        }

        return new Pair<List<SetRecordBean>, Integer>(sets, sets.size());

    } catch (Exception e) {
        throw new ServiceException(e);
    }

}

---

From source file:de.dlr.knowledgefinder.webapp.webservice.solr.query.AbstractSolrQueryFactory.java

License:Apache License

private void setLimitForSolrQuery(SolrQuery solrQuery, String limit) {
    try {/*from   w ww  . j a v a2 s . c  o  m*/
        int limitInt = Integer.parseInt(limit);
        if (limitInt >= 0) {
            solrQuery.setFacetLimit(limitInt);
        } else {
            solrQuery.setFacetLimit(getDefaultFacetLimit());
        }
    } catch (NumberFormatException e) {
        solrQuery.setFacetLimit(getDefaultFacetLimit());
    }
}

---

From source file:edu.cornell.mannlib.vitro.webapp.searchengine.solr.SolrConversionUtils.java

License:Open Source License

/**
 * Convert from a SearchQuery to a SolrQuery, so the Solr server may execute
 * it.//  w  w w.  ja  va  2  s .com
 */
@SuppressWarnings("deprecation")
static SolrQuery convertToSolrQuery(SearchQuery query) {
    SolrQuery solrQuery = new SolrQuery(query.getQuery());
    solrQuery.setStart(query.getStart());

    int rows = query.getRows();
    if (rows >= 0) {
        solrQuery.setRows(rows);
    }

    for (String fieldToReturn : query.getFieldsToReturn()) {
        solrQuery.addField(fieldToReturn);
    }

    Map<String, Order> sortFields = query.getSortFields();
    for (String sortField : sortFields.keySet()) {
        solrQuery.addSortField(sortField, convertToSolrOrder(sortFields.get(sortField)));
    }

    for (String filter : query.getFilters()) {
        solrQuery.addFilterQuery(filter);
    }

    if (!query.getFacetFields().isEmpty()) {
        solrQuery.setFacet(true);
    }

    for (String facetField : query.getFacetFields()) {
        solrQuery.addFacetField(facetField);
    }

    int facetLimit = query.getFacetLimit();
    if (facetLimit >= 0) {
        solrQuery.setFacetLimit(facetLimit);
    }

    int minCount = query.getFacetMinCount();
    if (minCount >= 0) {
        solrQuery.setFacetMinCount(minCount);
    }

    return solrQuery;
}

---

From source file:edu.harvard.liblab.ecru.rs.ResourceUtils.java

License:Open Source License

public static SolrQuery addFacetsToQuery(SolrQuery query, HashMap<String, List<String>> facetMap) {
    if (!facetMap.isEmpty()) {
        List<String> doFacet = facetMap.get("facet");
        if (doFacet == null || (!doFacet.isEmpty() && !doFacet.get(0).toLowerCase().equals("false"))) {
            query.setFacet(true);/*w ww  . ja v a  2  s  .c  o  m*/
            List<String> limits = facetMap.get("facet.limit");
            try {
                query.setFacetLimit(Integer.valueOf(limits.get(0)));

            } catch (Exception e) {
                // we don't care about this
            }
            query.setFacetMinCount(1);
            limits = facetMap.get("facet.mincout");
            try {
                query.setFacetLimit(Integer.valueOf(limits.get(0)));

            } catch (Exception e) {
                // we don't care about this
            }
            List<String> values = facetMap.get("facet.field");
            if (values != null && !values.isEmpty()) {
                query.addFacetField(values.toArray(new String[values.size()]));
            }
        }
    }
    return query;
}

---

From source file:edu.unc.lib.dl.search.solr.service.SolrSearchService.java

License:Apache License

/**
 * Constructs a SolrQuery object from the search state specified within a SearchRequest object. The request may
 * optionally request to retrieve facet results in addition to search results.
 * //from   w  ww .  j av  a  2 s . com
 * @param searchRequest
 * @param isRetrieveFacetsRequest
 * @return
 */
protected SolrQuery generateSearch(SearchRequest searchRequest) {
    SearchState searchState = (SearchState) searchRequest.getSearchState();
    SolrQuery solrQuery = new SolrQuery();
    StringBuilder termQuery = new StringBuilder();

    // Generate search term query string
    addSearchFields(searchState, termQuery);

    // Add range Fields to the query
    addRangeFields(searchState, termQuery);

    // No query terms given, make it an everything query
    StringBuilder query = new StringBuilder();
    if (termQuery.length() == 0) {
        query.append("*:* ");
    } else {
        query.append('(').append(termQuery).append(')');
    }

    // Add access restrictions to query
    try {
        addAccessRestrictions(query, searchRequest.getAccessGroups());
    } catch (AccessRestrictionException e) {
        // If the user doesn't have any access groups, they don't have access to anything, return null.
        LOG.debug("User had no access groups", e);
        return null;
    }

    // Add query
    solrQuery.setQuery(query.toString());

    if (searchState.getResultFields() != null) {
        for (String field : searchState.getResultFields()) {
            String solrFieldName = solrSettings.getFieldName(field);
            if (solrFieldName != null)
                solrQuery.addField(solrFieldName);
        }
    }

    if (searchState.getRollup() != null && searchState.getRollup()) {
        solrQuery.set(GroupParams.GROUP, true);
        if (searchState.getRollupField() == null)
            solrQuery.set(GroupParams.GROUP_FIELD, solrSettings.getFieldName(SearchFieldKeys.ROLLUP_ID.name()));
        else
            solrQuery.set(GroupParams.GROUP_FIELD, solrSettings.getFieldName(searchState.getRollupField()));

        solrQuery.set(GroupParams.GROUP_TOTAL_COUNT, true);
        if (searchState.getFacetsToRetrieve() != null && searchState.getFacetsToRetrieve().size() > 0) {
            solrQuery.set(GroupParams.GROUP_FACET, true);
        }
    }

    // Add sort parameters
    List<SearchSettings.SortField> sortFields = searchSettings.sortTypes.get(searchState.getSortType());
    if (sortFields != null) {
        for (int i = 0; i < sortFields.size(); i++) {
            SearchSettings.SortField sortField = sortFields.get(i);
            SolrQuery.ORDER sortOrder = SolrQuery.ORDER.valueOf(sortField.getSortOrder());
            if (!searchState.getSortNormalOrder())
                sortOrder = sortOrder.reverse();
            solrQuery.addSort(solrSettings.getFieldName(sortField.getFieldName()), sortOrder);
        }
    }

    // Set requested resource types
    String resourceTypeFilter = this.getResourceTypeFilter(searchState.getResourceTypes());
    if (resourceTypeFilter != null) {
        solrQuery.addFilterQuery(resourceTypeFilter);
    }

    // Turn on faceting
    if (searchRequest.isRetrieveFacets()) {
        solrQuery.setFacet(true);
        solrQuery.setFacetMinCount(1);
        if (searchState.getBaseFacetLimit() != null)
            solrQuery.setFacetLimit(searchState.getBaseFacetLimit());

        if (searchState.getFacetsToRetrieve() != null) {
            // Add facet fields
            for (String facetName : searchState.getFacetsToRetrieve()) {
                String facetField = solrSettings.getFieldName(facetName);
                if (facetField != null)
                    solrQuery.addFacetField(solrSettings.getFieldName(facetName));
            }
        }
    }

    // Override the base facet limit if overrides are given.
    if (searchState.getFacetLimits() != null) {
        for (Entry<String, Integer> facetLimit : searchState.getFacetLimits().entrySet()) {
            solrQuery.add("f." + solrSettings.getFieldName(facetLimit.getKey()) + ".facet.limit",
                    facetLimit.getValue().toString());
        }
    }

    // Add facet limits
    Map<String, Object> facets = searchState.getFacets();
    if (facets != null) {
        Iterator<Entry<String, Object>> facetIt = facets.entrySet().iterator();
        while (facetIt.hasNext()) {
            Entry<String, Object> facetEntry = facetIt.next();

            if (facetEntry.getValue() instanceof String) {
                LOG.debug("Adding facet " + facetEntry.getKey() + " as a String");
                // Add Normal facets
                solrQuery.addFilterQuery(solrSettings.getFieldName(facetEntry.getKey()) + ":\""
                        + SolrSettings.sanitize((String) facetEntry.getValue()) + "\"");
            } else {
                LOG.debug("Adding facet " + facetEntry.getKey() + " as a "
                        + facetEntry.getValue().getClass().getName());
                facetFieldUtil.addToSolrQuery(facetEntry.getValue(), solrQuery);
            }
        }
    }

    // Scope hierarchical facet results to the highest tier selected within the facet tree
    if (searchRequest.isRetrieveFacets() && searchRequest.isApplyCutoffs()
            && searchState.getFacetsToRetrieve() != null) {
        Set<String> facetsQueried = searchState.getFacets().keySet();
        // Apply closing cutoff to all cutoff facets that are being retrieved but not being queried for
        for (String fieldKey : searchState.getFacetsToRetrieve()) {
            if (!facetsQueried.contains(fieldKey)) {
                facetFieldUtil.addDefaultFacetPivot(fieldKey, solrQuery);
            }
        }

        // Add individual facet field sorts if they are present.
        if (searchState.getFacetSorts() != null) {
            for (Entry<String, String> facetSort : searchState.getFacetSorts().entrySet()) {
                solrQuery.add("f." + solrSettings.getFieldName(facetSort.getKey()) + ".facet.sort",
                        facetSort.getValue());
            }
        }
    }

    // Set Navigation options
    if (searchState.getStartRow() != null)
        solrQuery.setStart(searchState.getStartRow());
    if (searchState.getRowsPerPage() != null)
        solrQuery.setRows(searchState.getRowsPerPage());

    return solrQuery;
}

---

From source file:edu.unc.lib.dl.search.solr.service.SolrSearchService.java

License:Apache License

/**
 * Returns a combined set of distinct field values for one or more fields, limited by the set of access groups
 * provided/*from   www . j a v a2 s  .  co  m*/
 * 
 * @param fields
 *           Solr field names to retrieve distinct values for
 * @param maxValuesPerField
 *           Max number of distinct values to retrieve for each field
 * @param accessGroups
 * @return
 * @throws AccessRestrictionException
 * @throws SolrServerException
 */
public java.util.Collection<String> getDistinctFieldValues(String[] fields, int maxValuesPerField,
        AccessGroupSet accessGroups) throws AccessRestrictionException, SolrServerException {
    SolrQuery solrQuery = new SolrQuery();
    StringBuilder query = new StringBuilder("*:*");
    addAccessRestrictions(query, accessGroups);
    solrQuery.setQuery(query.toString());
    solrQuery.setFacet(true);
    for (String facetField : fields)
        solrQuery.addFacetField(facetField);
    solrQuery.setFacetLimit(maxValuesPerField);
    solrQuery.setFacetSort("index");

    QueryResponse queryResponse = server.query(solrQuery);
    // Determine initial capacity for the result list
    int numberValues = 0;
    for (FacetField facet : queryResponse.getFacetFields())
        numberValues += facet.getValueCount();

    java.util.Collection<String> fieldValues = new java.util.HashSet<String>(numberValues);
    for (FacetField facet : queryResponse.getFacetFields())
        for (Count count : facet.getValues())
            fieldValues.add(count.getName());

    return fieldValues;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• »