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

Introduction

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

Prototype

public SolrQuery setFacetSort(String sort) 

Source Link

Document

set facet sort

Usage

From source file:com.pearson.openideas.cq5.components.services.solr.SolrHelper.java

License:Open Source License

/**
 * Add a facet field to a SOLR Query./*  w  w w .  ja  v a 2s . c  o  m*/
 * 
 * @param facetField
 *            the facet field to be added
 * @param query
 *            the query
 */
public static void addFacet(final String facetField, final SolrQuery query) {
    if (facetField != null && facetField.trim().length() > 0) {
        log.debug("Adding facet for field {}.", facetField);
        query.setFacet(true);
        query.addFacetField(facetField);
        query.setFacetMinCount(1);
        query.setFacetSort(facetField);
    }
}

---

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());/*from   www. jav a 2 s  . c  o  m*/
    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   ww  w  .j  av  a2  s. co  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:de.dlr.knowledgefinder.webapp.webservice.solr.query.AbstractSolrQueryFactory.java

License:Apache License

private void setFacetFieldsForSolrQuery(SolrQuery solrQuery, String[] facetFields) {

    List<String> allowedFacetFields = Arrays.asList(getAllowedFacetFields());
    List<String> facetFieldList = splitStringArrays(facetFields);

    solrQuery.setFacetSort(FacetParams.FACET_SORT_COUNT);

    for (String fField : facetFieldList) {
        fField = fField.trim();/*from   w w  w .j  av  a2s .c  o m*/
        if (allowedFacetFields.contains(fField)) {
            solrQuery.addFacetField(fField);
        }
    }

}

---

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  av a2s. c o 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;
}

---

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

License:Apache License

public void getChildrenCounts(List<BriefObjectMetadata> resultList, AccessGroupSet accessGroups,
        String countName, String queryAddendum, SolrQuery baseQuery) {
    long startTime = System.currentTimeMillis();
    if (resultList == null || resultList.size() == 0)
        return;/* w  ww  .  j  a va 2 s .c om*/

    String ancestorPathField = solrSettings.getFieldName(SearchFieldKeys.ANCESTOR_PATH.name());
    SolrQuery solrQuery;
    if (baseQuery == null) {
        // Create a base query since we didn't receive one
        solrQuery = new SolrQuery();
        StringBuilder query = new StringBuilder("*:*");
        try {
            // Add access restrictions to query
            addAccessRestrictions(query, accessGroups);
        } catch (AccessRestrictionException e) {
            // If the user doesn't have any access groups, they don't have access to anything, return null.
            LOG.error(e.getMessage());
            return;
        }

        solrQuery.setStart(0);
        solrQuery.setRows(0);

        solrQuery.setQuery(query.toString());
    } else {
        // Starting from a base query
        solrQuery = baseQuery.getCopy();
        // Make sure we aren't returning any normal results
        solrQuery.setRows(0);
        // Remove all facet fields so we are only getting ancestor path
        if (solrQuery.getFacetFields() != null) {
            for (String facetField : solrQuery.getFacetFields()) {
                solrQuery.removeFacetField(facetField);
            }
        }
    }

    if (queryAddendum != null) {
        solrQuery.setQuery(solrQuery.getQuery() + " AND " + queryAddendum);
    }

    solrQuery.setFacet(true);
    solrQuery.setFacetMinCount(1);
    solrQuery.addFacetField(ancestorPathField);

    Integer countPageSize;
    try {
        countPageSize = new Integer(searchSettings.getProperty("search.facet.countPageSize"));
    } catch (NumberFormatException e) {
        countPageSize = 20;
    }

    solrQuery.add("f." + ancestorPathField + ".facet.limit", Integer.toString(Integer.MAX_VALUE));
    // Sort by value rather than count so that earlier tiers will come first in case the result gets cut off
    solrQuery.setFacetSort("index");

    java.util.Map<Integer, StringBuilder> tierQueryMap = new java.util.HashMap<Integer, StringBuilder>();
    java.util.Map<Integer, List<BriefObjectMetadata>> containerMap = new java.util.HashMap<Integer, List<BriefObjectMetadata>>();

    // Pare the list of ids we are searching for and assigning counts to down to just containers
    for (BriefObjectMetadata metadataObject : resultList) {
        if (metadataObject.getPath() != null && metadataObject.getContentModel() != null
                && metadataObject.getContentModel().contains(ContentModelHelper.Model.CONTAINER.toString())) {
            CutoffFacetNode highestTier = metadataObject.getPath().getHighestTierNode();
            StringBuilder tierQuery = tierQueryMap.get(highestTier.getTier());
            List<BriefObjectMetadata> containerObjects = containerMap.get(highestTier.getTier());
            if (tierQuery == null) {
                tierQuery = new StringBuilder();
                tierQueryMap.put(highestTier.getTier(), tierQuery);

                containerObjects = new ArrayList<BriefObjectMetadata>();
                containerMap.put(highestTier.getTier(), containerObjects);
            }

            if (tierQuery.length() == 0) {
                tierQuery.append(ancestorPathField).append(":(");
            } else {
                tierQuery.append(" OR ");
            }

            tierQuery.append(SolrSettings.sanitize(highestTier.getSearchValue())).append(",*");
            containerObjects.add(metadataObject);

            // If there are a lot of results, then do a partial lookup
            if (containerObjects.size() >= countPageSize) {
                tierQuery.append(")");
                this.executeChildrenCounts(tierQuery, containerObjects, solrQuery, countName,
                        highestTier.getTier());
                LOG.info("Partial query done at " + System.currentTimeMillis() + " ("
                        + (System.currentTimeMillis() - startTime) + ")");
                containerMap.remove(highestTier.getTier());
                tierQueryMap.remove(highestTier.getTier());
            }
        }
    }

    Iterator<java.util.Map.Entry<Integer, StringBuilder>> queryIt = tierQueryMap.entrySet().iterator();
    while (queryIt.hasNext()) {
        java.util.Map.Entry<Integer, StringBuilder> tierQueryEntry = queryIt.next();
        tierQueryEntry.getValue().append(')');
        this.executeChildrenCounts(tierQueryEntry.getValue(), containerMap.get(tierQueryEntry.getKey()),
                solrQuery, countName, tierQueryEntry.getKey());
    }
    LOG.info("Child count query done at " + System.currentTimeMillis() + " ("
            + (System.currentTimeMillis() - startTime) + ")");
}

---

From source file:edu.vt.vbi.patric.common.DataApiHandler.java

License:Apache License

public SolrQuery buildSolrQuery(Map<String, String> key, String sorts, String facets, int start, int end,
        boolean highlight) {

    SolrQuery query = new SolrQuery();
    SolrInterface solr = new SolrInterface();

    // Processing key map
    query.setQuery(StringHelper.stripQuoteAndParseSolrKeywordOperator(key.get("keyword")));

    if (key.containsKey("filter") && key.get("filter") != null) {
        query.addFilterQuery(key.get("filter"));
    }//from  www  .ja  v a  2  s .  c  o m
    if (key.containsKey("filter2") && key.get("filter2") != null) {
        query.addFilterQuery(key.get("filter2"));
    }

    // use SolrJoin if possible
    if (key.containsKey("join")) {
        query.addFilterQuery(key.get("join"));
    }

    if (key.containsKey("fields") && !key.get("fields").equals("")) {
        query.addField(key.get("fields"));
    }

    // sort conditions
    if (sorts != null && !sorts.equals("") && !sorts.equals("[]")) {
        try {
            JSONArray sorter = (JSONArray) new JSONParser().parse(sorts);
            for (Object aSort : sorter) {
                JSONObject jsonSort = (JSONObject) aSort;
                query.addSort(SolrQuery.SortClause.create(jsonSort.get("property").toString(),
                        jsonSort.get("direction").toString().toLowerCase()));
            }
        } catch (ParseException e) {
            LOGGER.error(e.getMessage(), e);
        }
    }

    // facet conditions
    if (facets != null && !facets.equals("") && !facets.equals("{}")) {
        query.setFacet(true).setFacetMinCount(1).setFacetLimit(-1).setFacetSort(FacetParams.FACET_SORT_COUNT)
                .set("json.nl", "map");

        try {
            JSONObject facetConditions = (JSONObject) new JSONParser().parse(facets);

            if (facetConditions.containsKey("facet.sort")) {
                String facetSort = facetConditions.get("facet.sort").toString();
                if (facetSort.equals("index")) {
                    query.setFacetSort(FacetParams.FACET_SORT_INDEX);
                }
            }

            if (facetConditions.containsKey("field_facets")) {
                String[] fieldFacets = facetConditions.get("field_facets").toString().split(",");
                query.addFacetField(fieldFacets);
            }

            if (facetConditions.containsKey("date_range_facets")
                    && !facetConditions.get("date_range_facets").equals("")) {
                String[] dateRangeFacets = facetConditions.get("date_range_facets").toString().split(",");
                for (String field : dateRangeFacets) {
                    query.addDateRangeFacet(field, solr.getRangeStartDate(), solr.getRangeEndDate(),
                            solr.getRangeDate());
                }
            }
        } catch (ParseException e) {
            LOGGER.error(e.getMessage(), e);
        }
    }

    // start & end
    query.setStart(start); // setting starting index

    if (end == -1) {
        query.setRows(MAX_ROWS);
    } else {
        query.setRows(end);
    }

    // highlight
    if (highlight) {
        query.set("hl", "on").set("hl.fl", "*");
    }

    return query;
}

---

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 a va2  s.  co 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:net.yacy.cora.federate.solr.connector.AbstractSolrConnector.java

License:Open Source License

/**
 * get facets of the index: a list of lists with values that are most common in a specific field
 * @param query a query which is performed to get the facets
 * @param fields the field names which are selected as facet
 * @param maxresults the maximum size of the resulting maps
 * @return a map with key = facet field name, value = an ordered map of field values for that field
 * @throws IOException//w ww.  jav a  2 s. com
 */
@Override
public LinkedHashMap<String, ReversibleScoreMap<String>> getFacets(String query, int maxresults,
        final String... fields) throws IOException {
    // construct query
    assert fields.length > 0;
    final SolrQuery params = new SolrQuery();
    params.setQuery(query);
    params.setRows(0);
    params.setStart(0);
    params.setFacet(true);
    params.setFacetMinCount(1); // there are many 0-count facets in the uninverted index cache
    params.setFacetLimit(maxresults);
    params.setFacetSort(FacetParams.FACET_SORT_COUNT);
    params.setParam(FacetParams.FACET_METHOD, FacetParams.FACET_METHOD_fc /*FACET_METHOD_fcs*/);
    params.setFields(fields);
    params.clearSorts();
    params.setIncludeScore(false);
    for (String field : fields)
        params.addFacetField(field);

    // query the server
    QueryResponse rsp = getResponseByParams(params);
    LinkedHashMap<String, ReversibleScoreMap<String>> facets = new LinkedHashMap<String, ReversibleScoreMap<String>>(
            fields.length);
    for (String field : fields) {
        FacetField facet = rsp.getFacetField(field);
        ReversibleScoreMap<String> result = new ClusteredScoreMap<String>(UTF8.insensitiveUTF8Comparator);
        List<Count> values = facet.getValues();
        if (values == null)
            continue;
        for (Count ff : values)
            if (ff.getCount() > 0)
                result.set(ff.getName(), (int) ff.getCount());
        facets.put(field, result);
    }
    return facets;
}

---

From source file:net.yacy.search.query.QueryParams.java

License:Open Source License

private SolrQuery getBasicParams(boolean getFacets, List<String> fqs) {
    final SolrQuery params = new SolrQuery();
    params.setParam("defType", "edismax");
    params.setParam(DisMaxParams.QF, CollectionSchema.text_t.getSolrFieldName() + "^1.0");
    params.setStart(this.offset);
    params.setRows(this.itemsPerPage);
    params.setFacet(false);/*w w  w .  j  a va2s . c om*/

    if (this.ranking.coeff_date == RankingProfile.COEFF_MAX) {
        // set a most-recent ordering
        params.setSort(new SortClause(CollectionSchema.last_modified.getSolrFieldName(), SolrQuery.ORDER.desc));
        //params.setSortField(CollectionSchema.last_modified.getSolrFieldName(), ORDER.desc); // deprecated in Solr 4.2
    }

    // add site facets
    fqs.addAll(getFacetsFilterQueries());
    if (fqs.size() > 0) {
        params.setFilterQueries(fqs.toArray(new String[fqs.size()]));
    }

    // set facet query attributes
    if (getFacets && this.facetfields.size() > 0) {
        params.setFacet(true);
        params.setFacetMinCount(1);
        params.setFacetLimit(FACETS_STANDARD_MAXCOUNT);
        params.setFacetSort(FacetParams.FACET_SORT_COUNT);
        params.setParam(FacetParams.FACET_METHOD, FacetParams.FACET_METHOD_fcs);
        for (String field : this.facetfields)
            params.addFacetField("{!ex=" + field + "}" + field); // params.addFacetField("{!ex=" + field + "}" + field);
        if (this.facetfields.contains(CollectionSchema.dates_in_content_dts.name())) {
            params.setParam("facet.range", CollectionSchema.dates_in_content_dts.name());
            @SuppressWarnings({ "static-access", "deprecation" })
            String start = TrieDateField
                    .formatExternal(new Date(System.currentTimeMillis() - 1000L * 60L * 60L * 24L * 3));
            @SuppressWarnings({ "static-access", "deprecation" })
            String end = TrieDateField
                    .formatExternal(new Date(System.currentTimeMillis() + 1000L * 60L * 60L * 24L * 3));
            params.setParam(
                    "f." + CollectionSchema.dates_in_content_dts.getSolrFieldName() + ".facet.range.start",
                    start);
            params.setParam(
                    "f." + CollectionSchema.dates_in_content_dts.getSolrFieldName() + ".facet.range.end", end);
            params.setParam(
                    "f." + CollectionSchema.dates_in_content_dts.getSolrFieldName() + ".facet.range.gap",
                    "+1DAY");
            params.setParam("f." + CollectionSchema.dates_in_content_dts.getSolrFieldName() + ".facet.sort",
                    "index");
            params.setParam("f." + CollectionSchema.dates_in_content_dts.getSolrFieldName() + ".facet.limit",
                    Integer.toString(FACETS_DATE_MAXCOUNT)); // the year constraint should cause that limitation already
        }
        //for (String k: params.getParameterNames()) {ArrayList<String> al = new ArrayList<>(); for (String s: params.getParams(k)) al.add(s); System.out.println("Parameter: " + k + "=" + al.toString());}
        //http://localhost:8090/solr/collection1/select?q=*:*&rows=0&facet=true&facet.field=dates_in_content_dts&f.dates_in_content_dts.facet.limit=730&f.dates_in_content_dts.facet.sort=index
    } else {
        params.setFacet(false);
    }
    params.setFields("*", "score"); // we need the score for post-ranking
    return params;
}

---

• «
• 1
• 2
• 3
• 4
• »