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

Introduction

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

Prototype

public SolrQuery addFacetField(String... fields) 

Source Link

Document

Add field(s) for facet computation.

Usage

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 ww  .  jav  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 ww .  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:cz.incad.vdk.client.tools.Search.java

License:Open Source License

public String getAsXML() throws JSONException {

    try {/*from  w w w.  ja  v a  2s . c  o m*/

        String q = req.getParameter("q");
        SolrQuery query = new SolrQuery();
        if (q == null || q.equals("")) {
            q = "*:*";
            query.setSort("_version_", SolrQuery.ORDER.desc);
        }
        query.setQuery(q);
        query.set("q.op", "AND");
        query.setFacet(true);
        query.setStart(getStart());
        query.setRows(getRows());

        if (LoggedController.isLogged(req)) {
            query.addFacetField(opts.getStrings("user_facets"));
        }
        query.addFacetField(opts.getStrings("facets"));

        query.setFacetMinCount(1);

        JSONObject others = opts.getJSONObject("otherParams");
        Iterator keys = others.keys();
        while (keys.hasNext()) {
            String key = (String) keys.next();
            Object val = others.get(key);
            if (val instanceof Integer) {
                query.set(key, (Integer) val);
            } else if (val instanceof String) {
                query.set(key, (String) val);
            } else if (val instanceof Boolean) {
                query.set(key, (Boolean) val);
            }

        }
        addFilters(query);

        return IndexerQuery.xml(query);
    } catch (IOException ex) {
        LOGGER.log(Level.SEVERE, null, ex);
        return null;
    }
}

---

From source file:cz.zcu.kiv.eegdatabase.logic.search.FulltextSearchService.java

License:Apache License

/**
 * Given the input query, finds out the total count of full text results for each full text result type.
 * @param solrQuery The search query./*from   w w  w .j  a v a 2s. c  o m*/
 * @return Map containg category-count pairs.
 */
public Map<String, Long> getCategoryFacets(String solrQuery) {
    SolrQuery query = new SolrQuery(solrQuery);
    query.setParam("fl", IndexField.UUID.getValue());
    query.setHighlight(false);
    query.setFacet(true);
    query.addFacetField(IndexField.CLASS.getValue());

    Map<String, Long> results = new HashMap<String, Long>();
    QueryResponse response = null;
    try {
        response = solrServer.query(query);
    } catch (SolrServerException e) {
        log.error(e);
    }
    long totalCount = 0;
    List<FacetField> facets = response.getFacetFields();
    for (FacetField field : facets) {
        log.info("count: " + field.getValueCount());
        List<FacetField.Count> facetEntries = field.getValues();
        for (FacetField.Count count : facetEntries) {
            long countValue = count.getCount();
            results.put(count.getName(), countValue);
            log.info(count.getName() + ", " + countValue);
            totalCount += countValue;
        }
    }

    // add a "facet" for all results
    results.put(ResultCategory.ALL.getValue(), totalCount);

    return results;
}

---

From source file:ddf.catalog.source.solr.SolrCatalogProvider.java

License:Open Source License

@Override
public Set<ContentType> getContentTypes() {

    Set<ContentType> finalSet = new HashSet<>();

    String contentTypeField = resolver.getField(Metacard.CONTENT_TYPE, AttributeFormat.STRING, true);
    String contentTypeVersionField = resolver.getField(Metacard.CONTENT_TYPE_VERSION, AttributeFormat.STRING,
            true);//from   ww w .j  a  v a 2s . c o m

    /*
     * If we didn't find the field, it most likely means it does not exist. If it does not
     * exist, then we can safely say that no content types are in this catalog provider
     */
    if (contentTypeField == null || contentTypeVersionField == null) {
        return finalSet;
    }

    SolrQuery query = new SolrQuery(contentTypeField + ":[* TO *]");
    query.setFacet(true);
    query.addFacetField(contentTypeField);
    query.addFacetPivotField(contentTypeField + "," + contentTypeVersionField);

    try {
        QueryResponse solrResponse = server.query(query, METHOD.POST);
        List<FacetField> facetFields = solrResponse.getFacetFields();
        for (Entry<String, List<PivotField>> entry : solrResponse.getFacetPivot()) {

            // if no content types have an associated version, the list of pivot fields will be
            // empty.
            // however, the content type names can still be obtained via the facet fields.
            if (CollectionUtils.isEmpty(entry.getValue())) {
                LOGGER.debug("No content type versions found associated with any available content types.");

                if (CollectionUtils.isNotEmpty(facetFields)) {
                    // Only one facet field was added. That facet field may contain multiple
                    // values (content type names).
                    for (FacetField.Count currContentType : facetFields.get(0).getValues()) {
                        // unknown version, so setting it to null
                        ContentTypeImpl contentType = new ContentTypeImpl(currContentType.getName(), null);

                        finalSet.add(contentType);
                    }
                }
            } else {
                for (PivotField pf : entry.getValue()) {

                    String contentTypeName = pf.getValue().toString();
                    LOGGER.debug("contentTypeName:{}", contentTypeName);

                    if (CollectionUtils.isEmpty(pf.getPivot())) {
                        // if there are no sub-pivots, that means that there are no content type
                        // versions
                        // associated with this content type name
                        LOGGER.debug("Content type does not have associated contentTypeVersion: {}",
                                contentTypeName);
                        ContentTypeImpl contentType = new ContentTypeImpl(contentTypeName, null);

                        finalSet.add(contentType);

                    } else {
                        for (PivotField innerPf : pf.getPivot()) {

                            LOGGER.debug("contentTypeVersion:{}. For contentTypeName: {}", innerPf.getValue(),
                                    contentTypeName);

                            ContentTypeImpl contentType = new ContentTypeImpl(contentTypeName,
                                    innerPf.getValue().toString());

                            finalSet.add(contentType);
                        }
                    }
                }
            }
        }

    } catch (SolrServerException e) {
        LOGGER.info("SOLR server exception getting content types", e);
    }

    return finalSet;
}

---

From source file:ddf.catalog.source.solr.SolrMetacardClientImpl.java

License:Open Source License

@Override
public Set<ContentType> getContentTypes() {
    Set<ContentType> finalSet = new HashSet<>();

    String contentTypeField = resolver.getField(Metacard.CONTENT_TYPE, AttributeType.AttributeFormat.STRING,
            true);/*  w  ww  .  j av a  2s.c o m*/
    String contentTypeVersionField = resolver.getField(Metacard.CONTENT_TYPE_VERSION,
            AttributeType.AttributeFormat.STRING, true);

    /*
     * If we didn't find the field, it most likely means it does not exist. If it does not
     * exist, then we can safely say that no content types are in this catalog provider
     */
    if (contentTypeField == null || contentTypeVersionField == null) {
        return finalSet;
    }

    SolrQuery query = new SolrQuery(contentTypeField + ":[* TO *]");
    query.setFacet(true);
    query.addFacetField(contentTypeField);
    query.addFacetPivotField(contentTypeField + "," + contentTypeVersionField);

    try {
        QueryResponse solrResponse = client.query(query, SolrRequest.METHOD.POST);
        List<FacetField> facetFields = solrResponse.getFacetFields();
        for (Map.Entry<String, List<PivotField>> entry : solrResponse.getFacetPivot()) {

            // if no content types have an associated version, the list of pivot fields will be
            // empty.
            // however, the content type names can still be obtained via the facet fields.
            if (CollectionUtils.isEmpty(entry.getValue())) {
                LOGGER.debug("No content type versions found associated with any available content types.");

                if (CollectionUtils.isNotEmpty(facetFields)) {
                    // Only one facet field was added. That facet field may contain multiple
                    // values (content type names).
                    for (FacetField.Count currContentType : facetFields.get(0).getValues()) {
                        // unknown version, so setting it to null
                        ContentType contentType = new ContentTypeImpl(currContentType.getName(), null);

                        finalSet.add(contentType);
                    }
                }
            } else {
                for (PivotField pf : entry.getValue()) {

                    String contentTypeName = pf.getValue().toString();
                    LOGGER.debug("contentTypeName: {}", contentTypeName);

                    if (CollectionUtils.isEmpty(pf.getPivot())) {
                        // if there are no sub-pivots, that means that there are no content type
                        // versions
                        // associated with this content type name
                        LOGGER.debug("Content type does not have associated contentTypeVersion: {}",
                                contentTypeName);
                        ContentType contentType = new ContentTypeImpl(contentTypeName, null);

                        finalSet.add(contentType);

                    } else {
                        for (PivotField innerPf : pf.getPivot()) {

                            LOGGER.debug("contentTypeVersion: {}. For contentTypeName: {}", innerPf.getValue(),
                                    contentTypeName);

                            ContentType contentType = new ContentTypeImpl(contentTypeName,
                                    innerPf.getValue().toString());

                            finalSet.add(contentType);
                        }
                    }
                }
            }
        }

    } catch (SolrServerException | IOException e) {
        LOGGER.info("Solr exception getting content types", e);
    }

    return finalSet;
}

---

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();/*ww w .  j ava2  s .c o  m*/
        if (allowedFacetFields.contains(fField)) {
            solrQuery.addFacetField(fField);
        }
    }

}

---

From source file:de.kp.ames.web.core.search.SearcherImpl.java

License:Open Source License

public String facet() throws Exception {

    /*//w w w.j  a va2s . c o m
     * Create query
     */
    SolrQuery query = new SolrQuery();
    query.setRows(0);

    /*
     * A single facet field is supported
     */
    query.addFacetField(JsonConstants.J_FACET);
    query.setQuery("*");

    /*
     * Retrieve facets from Apache Solr
     */
    QueryResponse response = solrProxy.executeQuery(query);
    FacetField facet = response.getFacetField(JsonConstants.J_FACET);

    /*
     * Evaluate response
     */
    if (facet == null)
        return new JSONArray().toString();

    /*
     * Sort search result
     */
    StringCollector collector = new StringCollector();

    List<Count> values = facet.getValues();
    if (values == null)
        return new JSONArray().toString();

    for (int i = 0; i < values.size(); i++) {

        Count count = values.get(i);
        String name = facet.getName();

        JSONObject jCount = new JSONObject();

        jCount.put(JsonConstants.J_COUNT, count.getCount());

        jCount.put(JsonConstants.J_FIELD, facet.getName());
        jCount.put(JsonConstants.J_VALUE, count.getName());

        collector.put(name, jCount);

    }

    JSONArray jArray = new JSONArray(collector.values());
    return jArray.toString();

}

---

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./*from   w  w  w. j a  v a  2s  . 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.lib.lcloud.ItemDAO.java

License:Open Source License

/**
 * Returns a SolrDocumentList for a given set of search parameters. Search parameters are parsed 
 * and mapped into solr (solrj) query syntax, and solr query is performed.
 * @param queryParams query parameters to map to a solr query
 * @return      the SolrDocumentList for this query
 * @see         SolrDocumentList//from w w  w . j  a v a 2  s .  co  m
 */

private SolrDocumentList doQuery(MultivaluedMap<String, String> queryParams) {
    SolrDocumentList docs = null;
    HttpSolrServer server = null;
    ArrayList<String> queryList = new ArrayList<String>();
    server = SolrServer.getSolrConnection();
    SolrQuery query = new SolrQuery();
    for (String key : queryParams.keySet()) {
        String value = queryParams.getFirst(key);
        System.out.println(key + " : " + queryParams.getFirst(key) + "\n");
        if (key.equals("start")) {
            int startNo = Integer.parseInt(value);
            if (startNo < 0)
                startNo = 0;
            query.setStart(startNo);
        } else if (key.equals("limit")) {
            limit = Integer.parseInt(value);
            query.setRows(limit);
        } else if (key.equals("sort.asc") || key.equals("sort"))
            query.setSort(value, ORDER.asc);
        else if (key.equals("sort.desc"))
            query.setSort(value, ORDER.desc);
        else if (key.startsWith("facet")) {
            query.setFacet(true);
            String[] facetArray = value.split(",");
            for (String f : facetArray) {
                query.addFacetField(f);
            }
        } else {
            if (key.endsWith("_exact"))
                queryList.add(key.replace("_exact", "") + ":\"" + value + "\"");
            else {
                if (value.contains(" "))
                    value = "( " + value.replaceAll(" ", " AND ") + ")";
                if (key.equals("q"))
                    queryList.add("keyword:" + value);
                else
                    queryList.add(key + "_keyword:" + value);
            }
        }
    }

    Iterator<String> it = queryList.iterator();
    String queryStr = "";
    while (it.hasNext()) {
        String qTerm = (String) it.next();
        System.out.print("QT: " + qTerm + "\n");
        queryStr += qTerm;
        System.out.print("QS: " + queryStr + "\n");
        if (it.hasNext())
            queryStr += " AND ";
    }
    System.out.print("queryStr: " + queryStr);
    query.setQuery(queryStr);
    QueryResponse response = null;
    try {
        response = server.query(query);
    } catch (SolrServerException se) {
        log.error(se.getMessage());
        throw new BadParameterException(se.getMessage());
    } catch (RemoteSolrException rse) {
        if (rse.getMessage().contains("SyntaxError")) {
            log.error("solr syntax error");
            throw new BadParameterException("Incorrect query syntax");
        } else {
            String msg = rse.getMessage().replace("_keyword", "");
            log.error(msg);
            throw new BadParameterException("Incorrect query syntax:" + msg);
        }
    }
    List<FacetField> facets = response.getFacetFields();
    facet = null;
    if (facets != null) {
        facet = new Facet();
        List<FacetType> facetTypes = new ArrayList<FacetType>();
        for (FacetField facetField : facets) {
            List<FacetTerm> facetTerms = new ArrayList<FacetTerm>();
            FacetType facetType = new FacetType();
            facetType.setFacetName(facetField.getName());
            List<FacetField.Count> facetEntries = facetField.getValues();
            for (FacetField.Count fcount : facetEntries) {
                if (fcount.getCount() > 0) {
                    FacetTerm facetTerm = new FacetTerm();
                    facetTerm.setTermName(fcount.getName());
                    facetTerm.setTermCount(fcount.getCount());
                    //System.out.println(fcount.getName() + ": " + fcount.getCount());
                    facetTerms.add(facetTerm);
                }
            }
            facetType.setFacetTerms(facetTerms);
            facetTypes.add(facetType);
        }
        facet.setFacetTypes(facetTypes);
    }
    docs = response.getResults();
    return docs;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• »