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:edu.unc.lib.dl.ui.service.SolrQueryLayerService.java

License:Apache License

/**
 * Get the number of departments represented in the collection
 * // w  w w  .  j  av  a2 s.c  o  m
 * @return the count, or -1 if there was an error retrieving the count
 */

public int getDepartmentsCount() {

    SolrQuery query;
    QueryResponse response;

    query = new SolrQuery();
    query.setQuery("*:*");
    query.setRows(0);
    query.addFacetField("department");
    query.setFacetLimit(-1);

    try {
        response = this.executeQuery(query);
        return response.getFacetField("department").getValueCount();
    } catch (SolrServerException e) {
        LOG.error("Error retrieving Solr object request: " + e);
    }

    return -1;

}

---

From source file:edu.unc.lib.dl.ui.service.SolrQueryLayerService.java

License:Apache License

/**
 * Get the total number of collections//w w w .  ja v  a 2 s . co m
 * 
 * @return the count, or -1 if there was an error retrieving the count
 */

public long getCollectionsCount() {

    SolrQuery query;
    QueryResponse response;

    query = new SolrQuery();
    query.setQuery("resourceType:Collection");
    query.setRows(0);
    query.setFacetLimit(-1);

    try {
        response = this.executeQuery(query);
        return response.getResults().getNumFound();
    } catch (SolrServerException e) {
        LOG.error("Error retrieving Solr object request: " + e);
    }

    return -1;

}

---

From source file:edu.unc.lib.dl.ui.service.SolrQueryLayerService.java

License:Apache License

/**
 * Get the number of objects present in the collection for various formats
 * /* w ww .  ja va2s  .c o  m*/
 * @return a map from format name to count
 */

public Map<String, Long> getFormatCounts() {

    SolrQuery query;
    QueryResponse response;

    query = new SolrQuery();
    query.setQuery("*:*");
    query.setRows(0);
    query.addFacetField("contentType");
    query.setFacetLimit(-1);

    HashMap<String, Long> counts = new HashMap<String, Long>();

    try {
        response = this.executeQuery(query);
        FacetField facetField = response.getFacetField("contentType");

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

            if (count.getName().startsWith("^text"))
                counts.put("text", count.getCount());
            else if (count.getName().startsWith("^image"))
                counts.put("image", count.getCount());
            else if (count.getName().startsWith("^dataset"))
                counts.put("dataset", count.getCount());
            else if (count.getName().startsWith("^audio"))
                counts.put("audio", count.getCount());
            else if (count.getName().startsWith("^video"))
                counts.put("video", count.getCount());

        }

    } catch (SolrServerException e) {
        LOG.error("Error retrieving Solr object request: " + e);
    }

    return counts;

}

---

From source file:eu.europeana.web.timeline.server.SolrServiceImpl.java

License:EUPL

@Override
public List<Year> retrieveYears() {
    List<Year> years = new ArrayList<Year>();
    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*:*");
    solrQuery.setFacet(true);/*  w w w.  j  av a  2  s . c  o  m*/
    solrQuery.addFacetField("YEAR");
    solrQuery.setRows(0);
    solrQuery.setFacetLimit(20);
    solrQuery.setFacetSort(FacetParams.FACET_SORT);
    solrQuery.setSortField("YEAR", SolrQuery.ORDER.desc);
    solrQuery.setFilterQueries("YEAR:[* TO *]", "-YEAR:0000");
    LOG.fine(String.format("Query : %s", solrQuery));
    QueryResponse response = null;
    try {
        response = solrServer.query(solrQuery);

        List<FacetField> facetFields = response.getFacetFields();
        for (FacetField field : facetFields) {
            for (FacetField.Count count : field.getValues()) {
                Year year = new Year();
                year.setYear(count.getName());
                year.setAvailableItemCount(count.getCount());
                if (count.getCount() > 0) {
                    years.add(year);
                }
            }
        }
    } catch (SolrServerException e) {
        LOG.severe(String.format("Error during Solr query for years : %s", e));
    }
    return response == null ? null : years;
}

---

From source file:fr.cnes.sitools.metacatalogue.resources.opensearch.AbstractOpensearchSearchResource.java

License:Open Source License

private void setFacet(SolrQuery solrQuery) {

    solrQuery.addFacetField(MetacatalogField._RESOLUTION_DOMAIN.getField());
    // Date dateStart;
    // try {/* www . j  a  va 2  s.  co m*/
    // dateStart = DateUtils.parse("1980-01-01T00:00:00.0");
    // solrQuery.addDateRangeFacet("characterisationAxis.temporalAxis.min", dateStart, new Date(), "+1YEAR");
    // }
    // catch (ParseException e) {
    // e.printStackTrace();
    // }

    List<String> plateformIntrument = new ArrayList<String>();
    plateformIntrument.add(MetacatalogField.PLATFORM.getField());
    plateformIntrument.add(MetacatalogField.INSTRUMENT.getField());

    List<String> location = new ArrayList<String>();
    location.add(MetacatalogField.COUNTRY.getField());
    location.add(MetacatalogField.REGION.getField());
    location.add(MetacatalogField.DEPARTMENT.getField());
    location.add(MetacatalogField.CITY.getField());

    solrQuery.add("facet.pivot", Joiner.on(",").join(plateformIntrument));
    solrQuery.add("facet.pivot", Joiner.on(",").join(location));
    solrQuery.addFacetField(MetacatalogField.PROCESSING_LEVEL.getField());
    solrQuery.addFacetField(MetacatalogField.PRODUCT.getField());
    solrQuery.add("facet.pivot.mincount", "0");
    solrQuery.setFacetLimit(10);
    solrQuery.setFacetMinCount(1);

}

---

From source file:fr.hoteia.qalingo.core.solr.service.impl.CategorySolrServiceImpl.java

License:Apache License

/**
  * /*w  w w  .j av a2s.co m*/
  */
public CategoryResponseBean searchCategory() throws SolrServerException, IOException {

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*");
    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(8);
    solrQuery.addFacetField("name");
    solrQuery.addFacetField("code");

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);
    request.setPath(getRequestPath());
    QueryResponse response = new QueryResponse(solrServer.request(request), solrServer);
    List<CategorySolr> productSolrList = response.getBeans(CategorySolr.class);
    List<FacetField> productSolrFacetFieldList = response.getFacetFields();

    CategoryResponseBean categoryResponseBean = new CategoryResponseBean();
    categoryResponseBean.setCategorySolrList(productSolrList);
    categoryResponseBean.setCategorySolrFacetFieldList(productSolrFacetFieldList);

    return categoryResponseBean;
}

---

From source file:fr.hoteia.qalingo.core.solr.service.impl.CustomerSolrServiceImpl.java

License:Apache License

/**
  * //  www.  j a  va 2s .  c  o m
  */
public CustomerResponseBean searchCustomer() throws SolrServerException, IOException {

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*");
    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(8);
    solrQuery.addFacetField("lastname");

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);
    request.setPath(getRequestPath());
    QueryResponse response = new QueryResponse(solrServer.request(request), solrServer);
    List<CustomerSolr> customerSolrList = response.getBeans(CustomerSolr.class);
    List<FacetField> customerSolrFacetFieldList = response.getFacetFields();

    CustomerResponseBean customerResponseBean = new CustomerResponseBean();
    customerResponseBean.setCustomerSolrList(customerSolrList);
    customerResponseBean.setCustomerSolrFacetFieldList(customerSolrFacetFieldList);

    return customerResponseBean;
}

---

From source file:fr.hoteia.qalingo.core.solr.service.impl.ProductSolrServiceImpl.java

License:Apache License

/**
  * //from   w w w. j  a va2 s. c  om
  */
public ProductResponseBean searchProduct() throws SolrServerException, IOException {

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*");
    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(8);
    solrQuery.addFacetField("name");
    solrQuery.addFacetField("code");

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);
    request.setPath(getRequestPath());
    QueryResponse response = new QueryResponse(solrServer.request(request), solrServer);
    List<ProductSkuSolr> productSkuSolrList = response.getBeans(ProductSkuSolr.class);
    List<FacetField> productSolrFacetFieldList = response.getFacetFields();

    ProductResponseBean productResponseBean = new ProductResponseBean();
    productResponseBean.setProductSolrList(productSkuSolrList);
    productResponseBean.setProductSolrFacetFieldList(productSolrFacetFieldList);

    return productResponseBean;
}

---

From source file:fr.hoteia.qalingo.core.solr.service.impl.StoreSolrServiceImpl.java

License:Apache License

/**
  * //from  w ww  . j  a va  2 s . co m
  */
public StoreResponseBean searchStore() throws SolrServerException, IOException {

    SolrQuery solrQuery = new SolrQuery();
    solrQuery.setQuery("*");
    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(1);
    solrQuery.setFacetLimit(8);
    solrQuery.addFacetField("businessname");

    SolrRequest request = new QueryRequest(solrQuery, METHOD.POST);
    request.setPath(getRequestPath());
    QueryResponse response = new QueryResponse(solrServer.request(request), solrServer);
    List<StoreSolr> storeSolrList = response.getBeans(StoreSolr.class);
    List<FacetField> storeSolrFacetFieldList = response.getFacetFields();

    StoreResponseBean storeResponseBean = new StoreResponseBean();
    storeResponseBean.setStoreSolrList(storeSolrList);
    storeResponseBean.setStoreSolrFacetFieldList(storeSolrFacetFieldList);

    return storeResponseBean;
}

---

From source file:fr.paris.lutece.plugins.search.solr.business.SolrSearchEngine.java

License:Open Source License

/**
 * Return the result with facets. Does NOT support authentification yet.
 * @param strQuery the query/*from w ww. j av  a2 s . com*/
 * @param facetQueries The selected facets
 * @param sortName The facet name to sort by
 * @param sortOrder "asc" or "desc"
 * @param nLimit Maximal number of results.
 * @return the result with facets
 */
public SolrFacetedResult getFacetedSearchResults(String strQuery, String[] facetQueries, String sortName,
        String sortOrder, int nLimit, int nCurrentPageIndex, int nItemsPerPage, Boolean bSpellCheck) {
    SolrFacetedResult facetedResult = new SolrFacetedResult();

    SolrClient solrServer = SolrServerService.getInstance().getSolrServer();
    List<SolrSearchResult> results = new ArrayList<SolrSearchResult>();
    Hashtable<Field, List<String>> myValuesList = new Hashtable<Field, List<String>>();

    if (solrServer != null) {
        SolrQuery query = new SolrQuery(strQuery);
        query.setHighlight(true);
        query.setHighlightSimplePre(SOLR_HIGHLIGHT_PRE);
        query.setHighlightSimplePost(SOLR_HIGHLIGHT_POST);
        query.setHighlightSnippets(SOLR_HIGHLIGHT_SNIPPETS);
        query.setHighlightFragsize(SOLR_HIGHLIGHT_FRAGSIZE);
        query.setFacet(true);
        query.setFacetLimit(SOLR_FACET_LIMIT);
        //            query.setFacetMinCount( 1 );

        for (Field field : SolrFieldManager.getFacetList().values()) {
            //Add facet Field
            if (field.getEnableFacet()) {
                if (field.getName().equalsIgnoreCase("date")
                        || field.getName().toLowerCase().endsWith("_date")) {
                    query.setParam("facet.date", field.getName());
                    query.setParam("facet.date.start", SOLR_FACET_DATE_START);
                    query.setParam("facet.date.gap", SOLR_FACET_DATE_GAP);
                    query.setParam("facet.date.end", SOLR_FACET_DATE_END);
                    query.setParam("facet.date.mincount", "0");
                } else {
                    query.addFacetField(field.getSolrName());
                    query.setParam("f." + field.getSolrName() + ".facet.mincount",
                            String.valueOf(field.getFacetMincount()));
                }
                myValuesList.put(field, new ArrayList<String>());
            }
        }

        //Facet intersection
        List<String> treeParam = new ArrayList<String>();

        for (FacetIntersection intersect : SolrFieldManager.getIntersectionlist()) {
            treeParam.add(intersect.getField1().getSolrName() + "," + intersect.getField2().getSolrName());
        }

        //(String []) al.toArray (new String [0]);
        query.setParam("facet.tree", (String[]) treeParam.toArray(new String[0]));
        query.setParam("spellcheck", bSpellCheck);

        //sort order
        if ((sortName != null) && !"".equals(sortName)) {
            if (sortOrder.equals("asc")) {
                query.setSort(sortName, ORDER.asc);
            } else {
                query.setSort(sortName, ORDER.desc);
            }
        } else {
            for (Field field : SolrFieldManager.getSortList()) {
                if (field.getDefaultSort()) {
                    query.setSort(field.getName(), ORDER.desc);
                }
            }
        }

        //Treat HttpRequest
        //FacetQuery
        if (facetQueries != null) {
            for (String strFacetQuery : facetQueries) {
                //                    if ( strFacetQuery.contains( DATE_COLON ) )
                //                    {
                //                        query.addFilterQuery( strFacetQuery );
                //                    }
                //                    else
                //                    {
                String myValues[] = strFacetQuery.split(":", 2);
                if (myValues != null && myValues.length == 2) {
                    myValuesList = getFieldArrange(myValues, myValuesList);
                }
                //strFacetQueryWithColon = strFacetQuery.replaceFirst( SolrConstants.CONSTANT_COLON, COLON_QUOTE );
                //strFacetQueryWithColon += SolrConstants.CONSTANT_QUOTE;
                //                        query.addFilterQuery( strFacetQuery );
                //                    }
            }

            for (Field tmpFieldValue : myValuesList.keySet()) {
                List<String> strValues = myValuesList.get(tmpFieldValue);
                String strFacetString = "";
                if (strValues.size() > 0) {
                    strFacetString = extractQuery(strValues, tmpFieldValue.getOperator());
                    if (tmpFieldValue.getName().equalsIgnoreCase("date")
                            || tmpFieldValue.getName().toLowerCase().endsWith("_date")) {
                        strFacetString = strFacetString.replaceAll("\"", "");
                    }
                    query.addFilterQuery(tmpFieldValue.getName() + ":" + strFacetString);
                }
            }
        }

        try {

            // count query
            query.setRows(0);
            QueryResponse response = solrServer.query(query);

            int nResults = (int) response.getResults().getNumFound();
            facetedResult.setCount(nResults > nLimit ? nLimit : nResults);

            query.setStart((nCurrentPageIndex - 1) * nItemsPerPage);
            query.setRows(nItemsPerPage > nLimit ? nLimit : nItemsPerPage);

            query.setParam("defType", DEF_TYPE);
            String strWeightValue = generateQueryWeightValue();
            query.setParam("qf", strWeightValue);

            response = solrServer.query(query);

            //HighLight
            Map<String, Map<String, List<String>>> highlightsMap = response.getHighlighting();
            SolrHighlights highlights = null;

            if (highlightsMap != null) {
                highlights = new SolrHighlights(highlightsMap);
            }

            //resultList
            List<SolrItem> itemList = response.getBeans(SolrItem.class);
            results = SolrUtil.transformSolrItemsToSolrSearchResults(itemList, highlights);

            //set the spellcheckresult
            facetedResult.setSolrSpellCheckResponse(response.getSpellCheckResponse());

            //Date facet
            if ((response.getFacetDates() != null) && !response.getFacetDates().isEmpty()) {
                facetedResult.setFacetDateList(response.getFacetDates());
            }

            //FacetField
            facetedResult.setFacetFields(response.getFacetFields());

            //Facet intersection (facet tree)
            NamedList<Object> resp = (NamedList<Object>) response.getResponse().get("facet_counts");

            if (resp != null) {
                NamedList<NamedList<NamedList<Integer>>> trees = (NamedList<NamedList<NamedList<Integer>>>) resp
                        .get("trees");
                Map<String, ArrayList<FacetField>> treesResult = new HashMap<String, ArrayList<FacetField>>();

                if (trees != null) {
                    for (Entry<String, NamedList<NamedList<Integer>>> selectedFacet : trees) { //Selected Facet (ex : type,categorie )
                                                                                               //System.out.println(selectedFacet.getKey());

                        ArrayList<FacetField> facetFields = new ArrayList<FacetField>(
                                selectedFacet.getValue().size());

                        for (Entry<String, NamedList<Integer>> facetField : selectedFacet.getValue()) {
                            FacetField ff = new FacetField(facetField.getKey());

                            //System.out.println("\t" + facetField.getKey());
                            for (Entry<String, Integer> value : facetField.getValue()) { // Second Level
                                ff.add(value.getKey(), value.getValue());

                                //System.out.println("\t\t" + value.getKey() + " : " + value.getValue());
                            }

                            facetFields.add(ff);
                        }

                        treesResult.put(selectedFacet.getKey(), facetFields);
                    }
                }

                facetedResult.setFacetIntersection(treesResult);
            }
        } catch (SolrServerException e) {
            AppLogService.error(e.getMessage(), e);
        } catch (IOException e) {
            AppLogService.error(e.getMessage(), e);
        }
    } else {
        facetedResult.setFacetFields(new ArrayList<FacetField>());
    }

    facetedResult.setSolrSearchResults(results);

    return facetedResult;
}

---

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