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

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

  1. HOME
  2. Java
  3. org.apache.solr
  4. org.apache.solr.client.solrj.*
  5. SolrQuery
  6. 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:org.dspace.app.webui.cris.controller.RPSearchFormController.java

@Override
protected Map referenceData(HttpServletRequest request) throws Exception {
    Map<String, Object> model = new HashMap<String, Object>();
    Context context = UIUtil.obtainContext(request);
    EPerson currUser = context.getCurrentUser();
    boolean isAdmin = AuthorizeManager.isAdmin(context);
    if (currUser != null) {
        model.put("researcher_page_menu", new Boolean(true));
    }/*from   w  ww. j ava2  s. c  o m*/
    if (isAdmin) {
        model.put("see_search_staffno", new Boolean(true));
        model.put("see_search_rp", new Boolean(true));// not used on jsp
        // (now search for
        // RP
        // is public)
    }

    SolrQuery query = new SolrQuery();
    query.setQuery("disabled:false");

    query.setFacet(true);
    query.setFacetLimit(-1);
    query.setFacetMinCount(1);
    query.setFacetMissing(true);
    query.setFacetSort(FacetParams.FACET_SORT_INDEX);
    // check table name
    query.addFacetField("faculty_filter");
    query.setRows(0);

    QueryResponse qResponse = ((CrisSearchService) searchService).search(query);

    FacetField facetField = qResponse.getFacetField("faculty_filter");

    List<DiscoverResult.FacetResult> faculties = new ArrayList<DiscoverResult.FacetResult>();
    List<Count> values = facetField.getValues();
    if (values != null) {
        for (FacetField.Count facetValue : values) {
            DiscoverResult.FacetResult fr = searchService.getDiscoveryFacet(context, facetField, facetValue);
            faculties.add(fr);
        }
    }
    DiscoveryConfiguration discoveryConf = SearchUtils.getDiscoveryConfigurationByName("crisrp");

    List<String> searchFields = new LinkedList<String>();
    for (DiscoverySearchFilter field : discoveryConf.getSearchFilters()) {
        searchFields.add(field.getIndexFieldName());
    }
    model.put("faculties", faculties);
    model.put("fields", searchFields);
    return model;
}

From source file:org.dspace.app.webui.cris.servlet.ProfileResearcherNetworkServlet.java

public Map<String, Integer> getRelations(String from, String to) throws SearchServiceException {
    Map<String, Integer> result = new HashMap<String, Integer>();
    SolrQuery solrQuery = new SolrQuery();

    Matcher matcher = patternRP.matcher(from);
    String field1 = "";
    String field2 = "";

    if (matcher.find()) {
        field1 = "focus_auth";
    } else {/*  w  ww .  j  ava 2 s .co m*/
        field1 = "focus_val";
    }

    matcher = patternRP.matcher(to);

    if (matcher.find()) {
        field2 = "focus_auth";
    } else {
        field2 = "focus_val";
    }

    solrQuery.setQuery(

            field1 + ":\"" + from + "\" AND " + field2 + ":\"" + to + "\""

    );

    solrQuery.setFacet(true);
    solrQuery.addFacetField("type");
    solrQuery.setFacetLimit(Integer.MAX_VALUE);
    solrQuery.setFacetMinCount(1);
    solrQuery.setRows(0);

    QueryResponse rsp = service.search(solrQuery);

    FacetField facets = rsp.getFacetField("type");
    for (Count facet : facets.getValues()) {
        result.put(facet.getName(), Integer.valueOf((int) facet.getCount()));
    }
    return result;
}

From source file:org.dspace.statistics.SolrLogger.java

License:BSD License

public static QueryResponse query(String query, String filterQuery, String facetField, int rows, int max,
        String dateType, String dateStart, String dateEnd, List<String> facetQueries, String sort,
        boolean ascending) throws SolrServerException {
    if (solr == null) {
        return null;
    }// www .  j  a  va  2  s .  c  o  m

    // System.out.println("QUERY");
    SolrQuery solrQuery = new SolrQuery().setRows(rows).setQuery(query).setFacetMinCount(1);
    addAdditionalSolrYearCores(solrQuery);

    // Set the date facet if present
    if (dateType != null) {
        solrQuery.setParam("facet.date", "time").
        // EXAMPLE: NOW/MONTH+1MONTH
                setParam("facet.date.end", "NOW/" + dateType + dateEnd + dateType)
                .setParam("facet.date.gap", "+1" + dateType).
                // EXAMPLE: NOW/MONTH-" + nbMonths + "MONTHS
                setParam("facet.date.start", "NOW/" + dateType + dateStart + dateType + "S").setFacet(true);
    }
    if (facetQueries != null) {
        for (int i = 0; i < facetQueries.size(); i++) {
            String facetQuery = facetQueries.get(i);
            solrQuery.addFacetQuery(facetQuery);
        }
        if (0 < facetQueries.size()) {
            solrQuery.setFacet(true);
        }
    }

    if (facetField != null) {
        solrQuery.addFacetField(facetField);
    }

    // Set the top x of if present
    if (max != -1) {
        solrQuery.setFacetLimit(max);
    }

    // A filter is used instead of a regular query to improve
    // performance and ensure the search result ordering will
    // not be influenced

    // Choose to filter by the Legacy spider IP list (may get too long to properly filter all IP's
    if (ConfigurationManager.getBooleanProperty("solr-statistics", "query.filter.spiderIp", false)) {
        solrQuery.addFilterQuery(getIgnoreSpiderIPs());
    }

    // Choose to filter by isBot field, may be overriden in future
    // to allow views on stats based on bots.
    if (ConfigurationManager.getBooleanProperty("solr-statistics", "query.filter.isBot", true)) {
        solrQuery.addFilterQuery("-isBot:true");
    }

    if (sort != null) {
        solrQuery.setSortField(sort, (ascending ? SolrQuery.ORDER.asc : SolrQuery.ORDER.desc));
    }

    String bundles;
    if ((bundles = ConfigurationManager.getProperty("solr-statistics", "query.filter.bundles")) != null
            && 0 < bundles.length()) {

        /**
         * The code below creates a query that will allow only records which do not have a bundlename
         * (items, collections, ...) or bitstreams that have a configured bundle name
         */
        StringBuffer bundleQuery = new StringBuffer();
        //Also add the possibility that if no bundle name is there these results will also be returned !
        bundleQuery.append("-(bundleName:[* TO *]");
        String[] split = bundles.split(",");
        for (int i = 0; i < split.length; i++) {
            String bundle = split[i].trim();
            bundleQuery.append("-bundleName:").append(bundle);
            if (i != split.length - 1) {
                bundleQuery.append(" AND ");
            }
        }
        bundleQuery.append(")");

        solrQuery.addFilterQuery(bundleQuery.toString());
    }

    if (filterQuery != null) {
        solrQuery.addFilterQuery(filterQuery);
    }

    QueryResponse response;
    try {
        // solr.set
        response = solr.query(solrQuery);
    } catch (SolrServerException e) {
        System.err.println("Error using query " + query);
        throw e;
    }
    return response;
}

From source file:org.dspace.statistics.SolrLoggerServiceImpl.java

License:BSD License

@Override
public QueryResponse query(String query, String filterQuery, String facetField, int rows, int max,
        String dateType, String dateStart, String dateEnd, List<String> facetQueries, String sort,
        boolean ascending) throws SolrServerException {
    if (solr == null) {
        return null;
    }//from   w  ww  .  ja v a  2s  .c  o  m

    // System.out.println("QUERY");
    SolrQuery solrQuery = new SolrQuery().setRows(rows).setQuery(query).setFacetMinCount(1);
    addAdditionalSolrYearCores(solrQuery);

    // Set the date facet if present
    if (dateType != null) {
        solrQuery.setParam("facet.date", "time").
        // EXAMPLE: NOW/MONTH+1MONTH
                setParam("facet.date.end", "NOW/" + dateType + dateEnd + dateType)
                .setParam("facet.date.gap", "+1" + dateType).
                // EXAMPLE: NOW/MONTH-" + nbMonths + "MONTHS
                setParam("facet.date.start", "NOW/" + dateType + dateStart + dateType + "S").setFacet(true);
    }
    if (facetQueries != null) {
        for (int i = 0; i < facetQueries.size(); i++) {
            String facetQuery = facetQueries.get(i);
            solrQuery.addFacetQuery(facetQuery);
        }
        if (0 < facetQueries.size()) {
            solrQuery.setFacet(true);
        }
    }

    if (facetField != null) {
        solrQuery.addFacetField(facetField);
    }

    // Set the top x of if present
    if (max != -1) {
        solrQuery.setFacetLimit(max);
    }

    // A filter is used instead of a regular query to improve
    // performance and ensure the search result ordering will
    // not be influenced

    // Choose to filter by the Legacy spider IP list (may get too long to properly filter all IP's
    if (configurationService.getBooleanProperty("solr-statistics.query.filter.spiderIp", false)) {
        solrQuery.addFilterQuery(getIgnoreSpiderIPs());
    }

    // Choose to filter by isBot field, may be overriden in future
    // to allow views on stats based on bots.
    if (configurationService.getBooleanProperty("solr-statistics.query.filter.isBot", true)) {
        solrQuery.addFilterQuery("-isBot:true");
    }

    if (sort != null) {
        solrQuery.setSortField(sort, (ascending ? SolrQuery.ORDER.asc : SolrQuery.ORDER.desc));
    }

    String[] bundles = configurationService.getArrayProperty("solr-statistics.query.filter.bundles");
    if (bundles != null && bundles.length > 0) {

        /**
         * The code below creates a query that will allow only records which do not have a bundlename
         * (items, collections, ...) or bitstreams that have a configured bundle name
         */
        StringBuffer bundleQuery = new StringBuffer();
        //Also add the possibility that if no bundle name is there these results will also be returned !
        bundleQuery.append("-(bundleName:[* TO *]");
        for (int i = 0; i < bundles.length; i++) {
            String bundle = bundles[i].trim();
            bundleQuery.append("-bundleName:").append(bundle);
            if (i != bundles.length - 1) {
                bundleQuery.append(" AND ");
            }
        }
        bundleQuery.append(")");

        solrQuery.addFilterQuery(bundleQuery.toString());
    }

    if (filterQuery != null) {
        solrQuery.addFilterQuery(filterQuery);
    }

    QueryResponse response;
    try {
        // solr.set
        response = solr.query(solrQuery);
    } catch (SolrServerException e) {
        System.err.println("Error using query " + query);
        throw e;
    }
    return response;
}

From source file:org.hbird.business.archive.solr.SolrProducer.java

License:Apache License

private List<EntityInstance> doInitializationRequest(DataRequest body, String request) {

    SolrQuery query = new SolrQuery(request);

    query.setRows(1);//from w w w .j  av  a 2  s. co m
    query.setSortField(endpoint.getSortField(), endpoint.getSortOrder());

    /** Configure facets. */
    query.setFacet(true);
    query.setQuery(request);
    query.setFacetSort(StandardArguments.COUNT);
    query.setFacetLimit(-1);
    query.setFacetMissing(false);
    query.setFacetMinCount(1);

    query.addFacetField(StandardArguments.NAME);

    query.setQueryType("basic");

    List<EntityInstance> results = new ArrayList<EntityInstance>();

    QueryResponse response;
    try {
        response = endpoint.getServer().query(query);
        if (response.getStatus() != 0) {
            LOG.error("Failed to execute retrieval request. Failed with status '{}'.", response.getStatus());
        }

        if (response.getFacetFields() != null) {

            /** For each facet, retrieve 'rows' samples. */
            for (FacetField facetfield : response.getFacetFields()) {

                if (facetfield.getValues() != null) {

                    LOG.info("Found " + facetfield.getValueCount() + " entries for facet value "
                            + facetfield.getName());

                    for (Count count : facetfield.getValues()) {

                        String applicableTo = "";
                        if (body.hasArgumentValue(StandardArguments.APPLICABLE_TO)) {
                            applicableTo = body.getArgumentValue(StandardArguments.APPLICABLE_TO, String.class);
                        }

                        SolrQuery sampleQuery = new SolrQuery("name:\"" + count.getName() + "\""
                                + createTimestampElement(body.getFrom(), body.getTo())
                                + createIsApplicableToElement(applicableTo));
                        LOG.info("Using sample query '" + sampleQuery + "' to get facet " + count.getName());
                        sampleQuery.setRows(body.getRows());
                        sampleQuery.setSortField(StandardArguments.TIMESTAMP, ORDER.desc);
                        sampleQuery.setQueryType("basic");

                        for (EntityInstance newObj : retrieve(sampleQuery)) {
                            results.add(newObj);
                            LOG.info("Added object '" + newObj.getID() + "'");
                        }
                    }
                }
            }
        }
    } catch (Exception e) {
        LOG.error("Failed to handle initialization request; query: '{}'.", request, e);
    }

    return results;
}

From source file:org.hippoecm.hst.demo.components.SolrFaceting.java

License:Apache License

@Override
public void doBeforeRender(final HstRequest request, final HstResponse response) throws HstComponentException {

    HippoSolrClient solrClient = HstServices.getComponentManager().getComponent(HippoSolrClient.class.getName(),
            SOLR_MODULE_NAME);//  ww w  .  j a  v a 2s  . c  o m
    SolrSearchParams params = new SolrSearchParams(request);

    params.setParamsOnRequestAttr();
    try {
        // set the free text query
        HippoQuery hippoQuery = solrClient.createQuery(params.getQuery());

        SolrQuery solrQuery = hippoQuery.getSolrQuery();

        String facetPath = request.getRequestContext().getResolvedSiteMapItem().getParameter("facetpath");
        if (facetPath != null) {
            // there is a facet path : Account for the constraints
            // the facet path looks like key/value/key/value 

            String[] constraints = facetPath.split("/");
            if (constraints.length % 2 != 0) {
                log.warn("Invalid constraints because not equal number of keys and values");
            } else {
                int i = 0;
                while (i < constraints.length) {
                    String facetField = constraints[i];
                    String facetValue = constraints[i + 1];
                    solrQuery.addFilterQuery(facetField + ":" + solrClient.getQueryParser().escape(facetValue));
                    i += 2;
                }
            }
        }

        // set rows to 0 : we are not interested to get results, but to get faceted navigation
        solrQuery.setRows(0);
        solrQuery.addFacetField("brand", "categories", "title");
        solrQuery.setFacetLimit(10);

        Calendar startCal = Calendar.getInstance();
        startCal.add(Calendar.YEAR, -5);

        Date startDate = startCal.getTime();
        Date endDate = Calendar.getInstance().getTime();
        solrQuery.addDateRangeFacet("date", startDate, endDate, "+1YEAR");

        // From SOLR 3.6 and higher you can also use :
        // solrQuery.addDateRangeFacet("date", startDate , endDate, "+1YEAR, +1MONTH, +1DAY");
        // This way you can create multiple buckets for 1 date field

        final HippoQueryResult result = hippoQuery.execute();

        // we do not need to bind the beans with their providers for faceting, so no need for
        // result.bindHits()

        request.setAttribute("queryResponse", result.getQueryResponse());
        request.setAttribute("query", params.getQuery());

    } catch (SolrServerException e) {
        throw new HstComponentException(e);
    }

}

From source file:org.hoteia.qalingo.core.solr.service.CatalogCategorySolrService.java

License:Apache License

public CatalogCategoryResponseBean searchCatalogCategory(String searchBy, String searchText, String facetField)
        throws SolrServerException, IOException {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setParam("rows", ROWS_DEFAULT_VALUE);

    if (StringUtils.isEmpty(searchBy)) {
        throw new IllegalArgumentException("SearchBy field can not be Empty or Blank!");
    }//from w ww.jav  a2  s  .  c o m

    if (StringUtils.isEmpty(searchText)) {
        solrQuery.setQuery(searchBy + ":*");
    } else {
        solrQuery.setQuery(searchBy + ":" + searchText + "*");
    }

    if (StringUtils.isNotEmpty(facetField)) {
        solrQuery.setFacet(true);
        solrQuery.setFacetMinCount(1);
        solrQuery.setFacetLimit(8);
        solrQuery.addFacetField(facetField);
    }

    logger.debug("QueryRequest solrQuery: " + solrQuery);

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);

    QueryResponse response = new QueryResponse(catalogCategorySolrServer.request(request),
            catalogCategorySolrServer);

    logger.debug("QueryResponse Obj: " + response.toString());

    List<CatalogCategorySolr> solrList = response.getBeans(CatalogCategorySolr.class);
    CatalogCategoryResponseBean catalogCategoryResponseBean = new CatalogCategoryResponseBean();
    catalogCategoryResponseBean.setCatalogCategorySolrList(solrList);

    if (StringUtils.isNotEmpty(facetField)) {
        List<FacetField> solrFacetFieldList = response.getFacetFields();
        catalogCategoryResponseBean.setCatalogCategorySolrFacetFieldList(solrFacetFieldList);
    }

    return catalogCategoryResponseBean;
}

From source file:org.hoteia.qalingo.core.solr.service.CatalogCategorySolrService.java

License:Apache License

public CatalogCategoryResponseBean searchCatalogCategory() throws SolrServerException, IOException {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setParam("rows", ROWS_DEFAULT_VALUE);

    solrQuery.setQuery("*");
    solrQuery.setFacet(true);/*from  w  w w .j  a v a  2  s.  c o  m*/
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(8);
    solrQuery.addFacetField("code");

    logger.debug("QueryRequest solrQuery: " + solrQuery);

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);

    QueryResponse response = new QueryResponse(catalogCategorySolrServer.request(request),
            catalogCategorySolrServer);

    logger.debug("QueryResponse Obj: " + response.toString());

    List<CatalogCategorySolr> solrList = response.getBeans(CatalogCategorySolr.class);
    List<FacetField> solrFacetFieldList = response.getFacetFields();

    CatalogCategoryResponseBean catalogCategoryResponseBean = new CatalogCategoryResponseBean();
    catalogCategoryResponseBean.setCatalogCategorySolrList(solrList);
    catalogCategoryResponseBean.setCatalogCategorySolrFacetFieldList(solrFacetFieldList);
    return catalogCategoryResponseBean;
}

From source file:org.hoteia.qalingo.core.solr.service.CustomerSolrService.java

License:Apache License

public CustomerResponseBean searchCustomer(String searchBy, String searchText, String facetField)
        throws IllegalArgumentException, SolrServerException, IOException {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setParam("rows", ROWS_DEFAULT_VALUE);

    if (StringUtils.isEmpty(searchBy)) {
        throw new IllegalArgumentException("SearchBy field can not be Empty or Blank!");
    }/* www . j ava2  s .  c o  m*/

    if (StringUtils.isEmpty(searchText)) {
        solrQuery.setQuery(searchBy + ":*");
    } else {
        solrQuery.setQuery(searchBy + ":" + searchText + "*");
    }

    if (StringUtils.isNotEmpty(facetField)) {
        solrQuery.setFacet(true);
        solrQuery.setFacetMinCount(1);
        solrQuery.setFacetLimit(8);
        solrQuery.addFacetField(facetField);
    }

    logger.debug("QueryRequest solrQuery: " + solrQuery);

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);

    QueryResponse response = new QueryResponse(customerSolrServer.request(request), customerSolrServer);

    logger.debug("QueryResponse Obj: " + response.toString());

    List<CustomerSolr> solrList = response.getBeans(CustomerSolr.class);
    CustomerResponseBean customerResponseBean = new CustomerResponseBean();
    customerResponseBean.setCustomerSolrList(solrList);

    if (StringUtils.isNotEmpty(facetField)) {
        List<FacetField> solrFacetFieldList = response.getFacetFields();
        customerResponseBean.setCustomerSolrFacetFieldList(solrFacetFieldList);
    }
    return customerResponseBean;
}

From source file:org.hoteia.qalingo.core.solr.service.CustomerSolrService.java

License:Apache License

public CustomerResponseBean searchCustomer() throws IllegalArgumentException, SolrServerException, IOException {
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setParam("rows", ROWS_DEFAULT_VALUE);

    solrQuery.setQuery("*");
    solrQuery.setFacet(true);//w w w . ja  v  a  2  s . co m
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(8);
    solrQuery.addFacetField("lastname");

    logger.debug("QueryRequest solrQuery: " + solrQuery);

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);

    QueryResponse response = new QueryResponse(customerSolrServer.request(request), customerSolrServer);

    logger.debug("QueryResponse Obj: " + response.toString());

    List<CustomerSolr> solrList = response.getBeans(CustomerSolr.class);
    List<FacetField> solrFacetFieldList = response.getFacetFields();

    CustomerResponseBean customerResponseBean = new CustomerResponseBean();
    customerResponseBean.setCustomerSolrList(solrList);
    customerResponseBean.setCustomerSolrFacetFieldList(solrFacetFieldList);
    return customerResponseBean;
}