Example usage for org.apache.solr.common.params GroupParams GROUP_TOTAL

Introduction

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

Prototype

String GROUP_TOTAL_COUNT

To view the source code for org.apache.solr.common.params GroupParams GROUP_TOTAL_COUNT.

Click Source Link

Document

Whether the group count should be included in the response.

Usage

From source file:com.frank.search.solr.core.DefaultQueryParser.java

License:Apache License

private void processGroupOptions(SolrQuery solrQuery, Query query) {

    GroupOptions groupOptions = query.getGroupOptions();

    if (groupOptions == null || (CollectionUtils.isEmpty(groupOptions.getGroupByFields())
            && CollectionUtils.isEmpty(groupOptions.getGroupByFunctions())
            && CollectionUtils.isEmpty(groupOptions.getGroupByQueries()))) {
        return;//from  w ww . j av  a  2  s  . c  o m
    }

    solrQuery.set(GroupParams.GROUP, true);
    solrQuery.set(GroupParams.GROUP_MAIN, groupOptions.isGroupMain());
    solrQuery.set(GroupParams.GROUP_FORMAT, "grouped");

    if (!CollectionUtils.isEmpty(groupOptions.getGroupByFields())) {
        for (Field field : groupOptions.getGroupByFields()) {
            solrQuery.add(GroupParams.GROUP_FIELD, field.getName());
        }
    }

    if (!CollectionUtils.isEmpty(groupOptions.getGroupByFunctions())) {
        for (Function function : groupOptions.getGroupByFunctions()) {
            String functionFragment = createFunctionFragment(function, 0);
            setObjectNameOnGroupQuery(query, function, functionFragment);
            solrQuery.add(GroupParams.GROUP_FUNC, functionFragment);
        }
    }

    if (!CollectionUtils.isEmpty(groupOptions.getGroupByQueries())) {
        for (Query groupQuery : groupOptions.getGroupByQueries()) {
            String queryFragment = getQueryString(groupQuery);
            setObjectNameOnGroupQuery(query, groupQuery, queryFragment);
            solrQuery.add(GroupParams.GROUP_QUERY, queryFragment);
        }
    }

    if (groupOptions.getSort() != null) {

        for (Order order : groupOptions.getSort()) {
            solrQuery.add(GroupParams.GROUP_SORT,
                    order.getProperty().trim() + " " + (order.isAscending() ? ORDER.asc : ORDER.desc));
        }
    }

    if (groupOptions.getCachePercent() > 0) {
        solrQuery.add(GroupParams.GROUP_CACHE_PERCENTAGE, String.valueOf(groupOptions.getCachePercent()));
    }

    if (groupOptions.getLimit() != null && groupOptions.getLimit() >= 0) {
        solrQuery.set(GroupParams.GROUP_LIMIT, groupOptions.getLimit());
    }

    if (groupOptions.getOffset() != null && groupOptions.getOffset() >= 0) {
        solrQuery.set(GroupParams.GROUP_OFFSET, groupOptions.getOffset());
    }

    solrQuery.set(GroupParams.GROUP_TOTAL_COUNT, groupOptions.isTotalCount());
    solrQuery.set(GroupParams.GROUP_FACET, groupOptions.isGroupFacets());
    solrQuery.set(GroupParams.GROUP_TRUNCATE, groupOptions.isTruncateFacets());
}

From source file:com.yaotrue.learn.solr.SolrjTest.java

License:Apache License

@Test
public void testGroup() throws SolrServerException, IOException {
    SolrQuery solrQuery = new SolrQuery("*:*");

    solrQuery.set(GroupParams.GROUP, true);
    solrQuery.set(GroupParams.GROUP_TOTAL_COUNT, true);
    solrQuery.set(GroupParams.GROUP_LIMIT, 12);
    solrQuery.set(GroupParams.GROUP_FORMAT, "grouped");
    solrQuery.set(GroupParams.GROUP_FACET, true);
    solrQuery.set(GroupParams.GROUP_FIELD, "style");

    QueryResponse queryResponse = solrClient.query(solrQuery);
    GroupResponse groupResponse = queryResponse.getGroupResponse();
    if (null != groupResponse) {
        List<GroupCommand> groupCommandList = groupResponse.getValues();
        for (GroupCommand groupCommand : groupCommandList) {
            int matches = groupCommand.getMatches();
            String name = groupCommand.getName();
            Integer ngroups = groupCommand.getNGroups();

            List<Group> groupList = groupCommand.getValues();
            for (Group group : groupList) {
                SolrDocumentList solrDocumentList = group.getResult();
                ListIterator<SolrDocument> listIterator = solrDocumentList.listIterator();
                while (listIterator.hasNext()) {
                    SolrDocument solrDocument = listIterator.next();
                    System.out.println(solrDocument.get("code"));
                }/*ww  w .  j  av  a  2 s. co m*/
            }
        }

    }
}

From source file:edu.unc.lib.dl.search.solr.service.SolrSearchService.java

License:Apache License

/**
 * Constructs a SolrQuery object from the search state specified within a SearchRequest object. The request may
 * optionally request to retrieve facet results in addition to search results.
 * /* w  w w  . jav a 2  s.  com*/
 * @param searchRequest
 * @param isRetrieveFacetsRequest
 * @return
 */
protected SolrQuery generateSearch(SearchRequest searchRequest) {
    SearchState searchState = (SearchState) searchRequest.getSearchState();
    SolrQuery solrQuery = new SolrQuery();
    StringBuilder termQuery = new StringBuilder();

    // Generate search term query string
    addSearchFields(searchState, termQuery);

    // Add range Fields to the query
    addRangeFields(searchState, termQuery);

    // No query terms given, make it an everything query
    StringBuilder query = new StringBuilder();
    if (termQuery.length() == 0) {
        query.append("*:* ");
    } else {
        query.append('(').append(termQuery).append(')');
    }

    // Add access restrictions to query
    try {
        addAccessRestrictions(query, searchRequest.getAccessGroups());
    } catch (AccessRestrictionException e) {
        // If the user doesn't have any access groups, they don't have access to anything, return null.
        LOG.debug("User had no access groups", e);
        return null;
    }

    // Add query
    solrQuery.setQuery(query.toString());

    if (searchState.getResultFields() != null) {
        for (String field : searchState.getResultFields()) {
            String solrFieldName = solrSettings.getFieldName(field);
            if (solrFieldName != null)
                solrQuery.addField(solrFieldName);
        }
    }

    if (searchState.getRollup() != null && searchState.getRollup()) {
        solrQuery.set(GroupParams.GROUP, true);
        if (searchState.getRollupField() == null)
            solrQuery.set(GroupParams.GROUP_FIELD, solrSettings.getFieldName(SearchFieldKeys.ROLLUP_ID.name()));
        else
            solrQuery.set(GroupParams.GROUP_FIELD, solrSettings.getFieldName(searchState.getRollupField()));

        solrQuery.set(GroupParams.GROUP_TOTAL_COUNT, true);
        if (searchState.getFacetsToRetrieve() != null && searchState.getFacetsToRetrieve().size() > 0) {
            solrQuery.set(GroupParams.GROUP_FACET, true);
        }
    }

    // Add sort parameters
    List<SearchSettings.SortField> sortFields = searchSettings.sortTypes.get(searchState.getSortType());
    if (sortFields != null) {
        for (int i = 0; i < sortFields.size(); i++) {
            SearchSettings.SortField sortField = sortFields.get(i);
            SolrQuery.ORDER sortOrder = SolrQuery.ORDER.valueOf(sortField.getSortOrder());
            if (!searchState.getSortNormalOrder())
                sortOrder = sortOrder.reverse();
            solrQuery.addSort(solrSettings.getFieldName(sortField.getFieldName()), sortOrder);
        }
    }

    // Set requested resource types
    String resourceTypeFilter = this.getResourceTypeFilter(searchState.getResourceTypes());
    if (resourceTypeFilter != null) {
        solrQuery.addFilterQuery(resourceTypeFilter);
    }

    // Turn on faceting
    if (searchRequest.isRetrieveFacets()) {
        solrQuery.setFacet(true);
        solrQuery.setFacetMinCount(1);
        if (searchState.getBaseFacetLimit() != null)
            solrQuery.setFacetLimit(searchState.getBaseFacetLimit());

        if (searchState.getFacetsToRetrieve() != null) {
            // Add facet fields
            for (String facetName : searchState.getFacetsToRetrieve()) {
                String facetField = solrSettings.getFieldName(facetName);
                if (facetField != null)
                    solrQuery.addFacetField(solrSettings.getFieldName(facetName));
            }
        }
    }

    // Override the base facet limit if overrides are given.
    if (searchState.getFacetLimits() != null) {
        for (Entry<String, Integer> facetLimit : searchState.getFacetLimits().entrySet()) {
            solrQuery.add("f." + solrSettings.getFieldName(facetLimit.getKey()) + ".facet.limit",
                    facetLimit.getValue().toString());
        }
    }

    // Add facet limits
    Map<String, Object> facets = searchState.getFacets();
    if (facets != null) {
        Iterator<Entry<String, Object>> facetIt = facets.entrySet().iterator();
        while (facetIt.hasNext()) {
            Entry<String, Object> facetEntry = facetIt.next();

            if (facetEntry.getValue() instanceof String) {
                LOG.debug("Adding facet " + facetEntry.getKey() + " as a String");
                // Add Normal facets
                solrQuery.addFilterQuery(solrSettings.getFieldName(facetEntry.getKey()) + ":\""
                        + SolrSettings.sanitize((String) facetEntry.getValue()) + "\"");
            } else {
                LOG.debug("Adding facet " + facetEntry.getKey() + " as a "
                        + facetEntry.getValue().getClass().getName());
                facetFieldUtil.addToSolrQuery(facetEntry.getValue(), solrQuery);
            }
        }
    }

    // Scope hierarchical facet results to the highest tier selected within the facet tree
    if (searchRequest.isRetrieveFacets() && searchRequest.isApplyCutoffs()
            && searchState.getFacetsToRetrieve() != null) {
        Set<String> facetsQueried = searchState.getFacets().keySet();
        // Apply closing cutoff to all cutoff facets that are being retrieved but not being queried for
        for (String fieldKey : searchState.getFacetsToRetrieve()) {
            if (!facetsQueried.contains(fieldKey)) {
                facetFieldUtil.addDefaultFacetPivot(fieldKey, solrQuery);
            }
        }

        // Add individual facet field sorts if they are present.
        if (searchState.getFacetSorts() != null) {
            for (Entry<String, String> facetSort : searchState.getFacetSorts().entrySet()) {
                solrQuery.add("f." + solrSettings.getFieldName(facetSort.getKey()) + ".facet.sort",
                        facetSort.getValue());
            }
        }
    }

    // Set Navigation options
    if (searchState.getStartRow() != null)
        solrQuery.setStart(searchState.getStartRow());
    if (searchState.getRowsPerPage() != null)
        solrQuery.setRows(searchState.getRowsPerPage());

    return solrQuery;
}

From source file:org.sakaiproject.nakamura.files.search.AbstractContentSearchQueryHandler.java

License:Apache License

/**
 * {@inheritDoc}//from   w w  w  . j a  v a  2  s.c o m
 * @see org.sakaiproject.nakamura.api.search.solr.DomainObjectSearchQueryHandler#refineQuery(java.util.Map, org.sakaiproject.nakamura.api.search.solr.Query)
 */
@Override
public void refineQuery(Map<String, String> parametersMap, Query query) {
    query.getOptions().put(CommonParams.FL, "path");

    /*
     * If there is a query string 'q' specified, then we will also need to search on
     * widget data contents. Because of this, to avoid duplicate content (e.g, multiple
     * widgets of a pooled content item match on the content), we need to group by the
     * widget content "returnpath". See also the #getResourceTypeClause(Map) method to
     * see how the widget data resourceType is dynamically included in the query.
     */
    if (hasGeneralQuery(parametersMap)) {
        query.getOptions().put(GroupParams.GROUP, Boolean.TRUE);
        query.getOptions().put(GroupParams.GROUP_FIELD, "returnpath");

        // record the number "groups" matched to give accurate total of elements
        // returned. Here, one GROUP is one actual result, instead of all the
        // identical elements aggregated in those groups.
        query.getOptions().put(GroupParams.GROUP_TOTAL_COUNT, Boolean.TRUE);
    }
}

From source file:org.springframework.data.solr.core.DefaultQueryParserTests.java

License:Apache License

private void assertGroupFormatPresent(SolrQuery solrQuery, boolean groupTotalCount) {
    Assert.assertEquals("true", solrQuery.get(GroupParams.GROUP));
    Assert.assertEquals("false", solrQuery.get(GroupParams.GROUP_MAIN));
    Assert.assertEquals("grouped", solrQuery.get(GroupParams.GROUP_FORMAT));
    Assert.assertEquals(String.valueOf(groupTotalCount), solrQuery.get(GroupParams.GROUP_TOTAL_COUNT));
}

Example usage for org.apache.solr.common.params GroupParams GROUP_TOTAL_COUNT

Introduction

Prototype

Document

Usage