Example usage for org.apache.solr.common.params FacetParams FACET_SORT

Introduction

In this page you can find the example usage for org.apache.solr.common.params FacetParams FACET_SORT_COUNT.

Prototype

String FACET_SORT_COUNT

To view the source code for org.apache.solr.common.params FacetParams FACET_SORT_COUNT.

Click Source Link

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 www .j  a v  a2 s.  co m*/

        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: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 . jav  a  2 s . co  m
        if (allowedFacetFields.contains(fField)) {
            solrQuery.addFacetField(fField);
        }
    }

}

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

License:Apache License

/**
 * wrapper function of field facet query
 *
 * @param core SolrCore//from  w  w w .ja  v a2 s  . c  o  m
 * @param queryParam query condition
 * @param filterParam filter condition
 * @param facetFields comma separated list of fields
 */
public Map getFieldFacets(SolrCore core, String queryParam, String filterParam, String facetFields)
        throws IOException {
    Map<String, Object> res = new HashMap<>();
    SolrQuery query = new SolrQuery();

    query.setQuery(queryParam);
    if (filterParam != null) {
        query.addFilterQuery(filterParam);
    }
    query.setRows(0).setFacet(true).setFacetLimit(-1).setFacetMinCount(1)
            .setFacetSort(FacetParams.FACET_SORT_COUNT).set("json.nl", "map");
    query.addFacetField(facetFields.split(","));

    List<String> fields = Arrays.asList(facetFields.split(","));

    LOGGER.trace("getFieldFacets: [{}] {}", core.getSolrCoreName(), query.toString());
    String response = this.solrQuery(core, query);
    Map resp = jsonParser.readValue(response);
    Map facet_fields = (Map) ((Map) resp.get("facet_counts")).get("facet_fields");

    Map<String, Object> facets = new HashMap<>();
    for (String field : fields) {
        Map values = (Map) facet_fields.get(field);
        Map<String, Integer> facetValues = new LinkedHashMap<>();

        for (Map.Entry<String, Integer> entry : (Iterable<Map.Entry>) values.entrySet()) {
            facetValues.put(entry.getKey(), entry.getValue());
        }

        facets.put(field, facetValues);
    }

    res.put("total", ((Map) resp.get("response")).get("numFound"));
    res.put("facets", facets);

    return res;
}

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"));
    }/*w  ww .  j  a va 2s  . 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: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/*from  w  w w  .  j  a  v a2s  .c  o  m*/
 */
@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 ww. java 2  s.c  o  m*/

    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;
}

From source file:org.ariadne_eu.metadata.resultsformat.ResultDelegateARIADNERFJS.java

private QueryResponse getSolrResponse() {
    SolrServerManagement serverMgt = SolrServerManagement.getInstance();

    SolrQuery solrQuery = new SolrQuery().setQuery(lQuery).setFacet(true).setFacetLimit(-1).setFacetMinCount(1)
            .setFacetSort(FacetParams.FACET_SORT_COUNT).setParam("rows", Integer.toString(max))
            .setParam("start", Integer.toString(start));

    for (Iterator<String> iterator = facetFields.iterator(); iterator.hasNext();) {
        String facetField = (String) iterator.next();
        solrQuery.addFacetField(facetField);
    }/*from  w  w  w  . j  a  v a 2  s . c  om*/
    QueryResponse rsp = null;

    try {
        rsp = serverMgt.getServer().query(solrQuery);

    } catch (SolrServerException e) {
        log.error("getSolrResponse: Solr server error", e);
    } catch (IOException e) {
        log.error("getSolrResponse: Solr I/O error", e);
    }
    return rsp;
}

From source file:org.dspace.app.xmlui.aspect.discovery.json.JSONSolrSearcher.java

License:BSD License

@Override
public void setup(SourceResolver resolver, Map objectModel, String src, Parameters par)
        throws ProcessingException, SAXException, IOException {
    //Retrieve all the given parameters
    Request request = ObjectModelHelper.getRequest(objectModel);
    this.response = ObjectModelHelper.getResponse(objectModel);

    query = request.getParameter(CommonParams.Q);
    if (query == null) {
        query = "*:*";
    }/* w w  w. j  av  a2 s.co  m*/

    //Retrieve all our filter queries
    filterQueries = request.getParameterValues(CommonParams.FQ);

    //Retrieve our facet fields
    facetFields = request.getParameterValues(FacetParams.FACET_FIELD);

    //Retrieve our facet limit (if any)
    if (request.getParameter(FacetParams.FACET_LIMIT) != null) {
        try {
            facetLimit = Integer.parseInt(request.getParameter(FacetParams.FACET_LIMIT));
        } catch (Exception e) {
            //Should an invalid value be supplied use -1
            facetLimit = -1;
        }
    } else {
        facetLimit = -1;
    }

    //Retrieve our sorting value
    facetSort = request.getParameter(FacetParams.FACET_SORT);
    //Make sure we have a valid sorting value
    if (!FacetParams.FACET_SORT_INDEX.equals(facetSort) && !FacetParams.FACET_SORT_COUNT.equals(facetSort)) {
        facetSort = null;
    }

    //Retrieve our facet min count
    facetMinCount = 1;
    try {
        facetMinCount = Integer.parseInt(request.getParameter(FacetParams.FACET_MINCOUNT));
    } catch (Exception e) {
        facetMinCount = 1;
    }
    jsonWrf = request.getParameter("json.wrf");

    //Retrieve our discovery solr path
    ExtendedProperties props = null;
    //Method that will retrieve all the possible configs we have

    props = ExtendedProperties.convertProperties(ConfigurationManager.getProperties());

    InputStream is = null;
    try {
        File config = new File(props.getProperty("dspace.dir") + "/config/dspace-solr-search.cfg");
        if (config.exists()) {
            props.combine(new ExtendedProperties(config.getAbsolutePath()));
        } else {
            is = SolrServiceImpl.class.getResourceAsStream("dspace-solr-search.cfg");
            ExtendedProperties defaults = new ExtendedProperties();
            defaults.load(is);
            props.combine(defaults);
        }
    } catch (Exception e) {
        log.error("Error while retrieving solr url", e);
        e.printStackTrace();
    } finally {
        if (is != null) {
            is.close();
        }
    }

    if (props.getProperty("solr.search.server") != null) {
        this.solrServerUrl = props.getProperty("solr.search.server").toString();
    }

}

From source file:org.dspace.discovery.SolrServiceImpl.java

License:BSD License

protected SolrQuery resolveToSolrQuery(Context context, DiscoverQuery discoveryQuery,
        boolean includeUnDiscoverable) {
    SolrQuery solrQuery = new SolrQuery();

    String query = "*:*";
    if (discoveryQuery.getQuery() != null) {
        query = discoveryQuery.getQuery();
    }/*  w  ww .ja v a2  s.com*/

    solrQuery.setQuery(query);
    if (discoveryQuery.isSpellCheck()) {
        solrQuery.setParam(SpellingParams.SPELLCHECK_Q, query);
        solrQuery.setParam(SpellingParams.SPELLCHECK_COLLATE, Boolean.TRUE);
        solrQuery.setParam("spellcheck", Boolean.TRUE);
    }

    if (!includeUnDiscoverable) {
        solrQuery.addFilterQuery("NOT(withdrawn:true)");
        solrQuery.addFilterQuery("NOT(discoverable:false)");
    }

    for (int i = 0; i < discoveryQuery.getFilterQueries().size(); i++) {
        String filterQuery = discoveryQuery.getFilterQueries().get(i);
        solrQuery.addFilterQuery(filterQuery);
    }
    if (discoveryQuery.getDSpaceObjectFilter() != -1) {
        solrQuery.addFilterQuery("search.resourcetype:" + discoveryQuery.getDSpaceObjectFilter());
    }

    for (int i = 0; i < discoveryQuery.getFieldPresentQueries().size(); i++) {
        String filterQuery = discoveryQuery.getFieldPresentQueries().get(i);
        solrQuery.addFilterQuery(filterQuery + ":[* TO *]");
    }

    if (discoveryQuery.getStart() != -1) {
        solrQuery.setStart(discoveryQuery.getStart());
    }

    if (discoveryQuery.getMaxResults() != -1) {
        solrQuery.setRows(discoveryQuery.getMaxResults());
    }

    if (discoveryQuery.getSortField() != null) {
        SolrQuery.ORDER order = SolrQuery.ORDER.asc;
        if (discoveryQuery.getSortOrder().equals(DiscoverQuery.SORT_ORDER.desc))
            order = SolrQuery.ORDER.desc;

        solrQuery.addSortField(discoveryQuery.getSortField(), order);
    }

    for (String property : discoveryQuery.getProperties().keySet()) {
        List<String> values = discoveryQuery.getProperties().get(property);
        solrQuery.add(property, values.toArray(new String[values.size()]));
    }

    List<DiscoverFacetField> facetFields = discoveryQuery.getFacetFields();
    if (0 < facetFields.size()) {
        //Only add facet information if there are any facets
        for (DiscoverFacetField facetFieldConfig : facetFields) {
            String field = transformFacetField(facetFieldConfig, facetFieldConfig.getField(), false);
            solrQuery.addFacetField(field);

            // Setting the facet limit in this fashion ensures that each facet can have its own max
            solrQuery.add("f." + field + "." + FacetParams.FACET_LIMIT,
                    String.valueOf(facetFieldConfig.getLimit()));
            String facetSort;
            if (DiscoveryConfigurationParameters.SORT.COUNT.equals(facetFieldConfig.getSortOrder())) {
                facetSort = FacetParams.FACET_SORT_COUNT;
            } else {
                facetSort = FacetParams.FACET_SORT_INDEX;
            }
            solrQuery.add("f." + field + "." + FacetParams.FACET_SORT, facetSort);
            if (facetFieldConfig.getOffset() != -1) {
                solrQuery.setParam("f." + field + "." + FacetParams.FACET_OFFSET,
                        String.valueOf(facetFieldConfig.getOffset()));
            }
            if (facetFieldConfig.getPrefix() != null) {
                solrQuery.setFacetPrefix(field, facetFieldConfig.getPrefix());
            }
        }

        List<String> facetQueries = discoveryQuery.getFacetQueries();
        for (String facetQuery : facetQueries) {
            solrQuery.addFacetQuery(facetQuery);
        }

        if (discoveryQuery.getFacetMinCount() != -1) {
            solrQuery.setFacetMinCount(discoveryQuery.getFacetMinCount());
        }

        solrQuery.setParam(FacetParams.FACET_OFFSET, String.valueOf(discoveryQuery.getFacetOffset()));
    }

    if (0 < discoveryQuery.getHitHighlightingFields().size()) {
        solrQuery.setHighlight(true);
        solrQuery.add(HighlightParams.USE_PHRASE_HIGHLIGHTER, Boolean.TRUE.toString());
        for (DiscoverHitHighlightingField highlightingField : discoveryQuery.getHitHighlightingFields()) {
            solrQuery.addHighlightField(highlightingField.getField() + "_hl");
            solrQuery.add("f." + highlightingField.getField() + "_hl." + HighlightParams.FRAGSIZE,
                    String.valueOf(highlightingField.getMaxChars()));
            solrQuery.add("f." + highlightingField.getField() + "_hl." + HighlightParams.SNIPPETS,
                    String.valueOf(highlightingField.getMaxSnippets()));
        }

    }

    //Add any configured search plugins !
    List<SolrServiceSearchPlugin> solrServiceSearchPlugins = new DSpace().getServiceManager()
            .getServicesByType(SolrServiceSearchPlugin.class);
    for (SolrServiceSearchPlugin searchPlugin : solrServiceSearchPlugins) {
        searchPlugin.additionalSearchParameters(context, discoveryQuery, solrQuery);
    }
    return solrQuery;
}

From source file:org.emonocot.persistence.dao.hibernate.SearchableDaoImpl.java

License:Open Source License

/**
 * @param query//from   w w w.  j  a  va  2  s  . c o m
 *            A lucene query
 * @param spatialQuery
 *            A spatial query to filter the results by
 * @param pageSize
 *            The maximum number of results to return
 * @param pageNumber
 *            The offset (in pageSize chunks, 0-based) from the beginning of
 *            the recordset
 * @param facets
 *            The names of the facets you want to calculate
 * @param selectedFacets
 *            A map of facets which you would like to restrict the search by
 * @param sort
 *            A representation for the order results should be returned in
 * @param fetch
 *            Set the fetch profile
 * @return a Page from the resultset
 * @throws SolrServerException
 */
public final Page<T> search(final String query, final String spatialQuery, final Integer pageSize,
        final Integer pageNumber, final String[] facets, Map<String, String> facetPrefixes,
        final Map<String, String> selectedFacets, final String sort, final String fetch)
        throws SolrServerException {
    SolrQuery solrQuery = prepareQuery(query, sort, pageSize, pageNumber, selectedFacets);
    solrQuery.set("spellcheck", "true");
    solrQuery.set("spellcheck.collate", "true");
    solrQuery.set("spellcheck.count", "1");
    solrQuery.set("bq", "base.class_s:org.emonocot.model.Taxon^2.0");

    // Filter the searchable objects out
    solrQuery.addFilterQuery("base.class_searchable_b:" + isSearchableObject());

    if (spatialQuery != null && spatialQuery.trim().length() != 0) {
        solrQuery.addFilterQuery(spatialQuery);
    }

    if (facets != null && facets.length != 0) {
        solrQuery.setFacet(true);
        solrQuery.setFacetMinCount(1);
        solrQuery.setFacetSort(FacetParams.FACET_SORT_INDEX);

        for (String facet : facets) {
            if (facet.equals("base.class_s")) {
                solrQuery.setParam("f.base.class_s.facet.sort", FacetParams.FACET_SORT_COUNT);
            }
            if (facet.endsWith("_dt")) {
                /**
                 * Is a date facet. Once Solr 4.2 is released, we can implement variable length buckets, but for now
                 * stick with fixed buckets https://issues.apache.org/jira/browse/SOLR-2366
                 */

                solrQuery.add("facet.range", facet);
                solrQuery.add("f." + facet + ".facet.range.start", "NOW/DAY-1YEARS");
                solrQuery.add("f." + facet + ".facet.range.end", "NOW/DAY");
                solrQuery.add("f." + facet + ".facet.range.gap", "+1MONTH");
            } else {
                solrQuery.addFacetField(facet);
            }
            includeMissing(solrQuery, facet);
        }
        if (facetPrefixes != null) {
            for (String facet : facetPrefixes.keySet()) {
                solrQuery.add("f." + facet + ".facet.prefix", facetPrefixes.get(facet));
            }
        }
    }
    QueryResponse queryResponse = solrServer.query(solrQuery);

    List<T> results = new ArrayList<T>();
    for (SolrDocument solrDocument : queryResponse.getResults()) {
        T object = loadObjectForDocument(solrDocument);
        enableProfilePostQuery(object, fetch);
        results.add(object);
    }

    Long totalResults = new Long(queryResponse.getResults().getNumFound());
    Page<T> page = new DefaultPageImpl<T>(totalResults.intValue(), pageNumber, pageSize, results,
            queryResponse);
    if (selectedFacets != null) {
        page.setSelectedFacets(selectedFacets);
    }
    page.setSort(sort);

    return page;
}

Example usage for org.apache.solr.common.params FacetParams FACET_SORT_COUNT

Introduction

Prototype

Usage