List of usage examples for org.apache.solr.common.params FacetParams FACET_OFFSET
String FACET_OFFSET
To view the source code for org.apache.solr.common.params FacetParams FACET_OFFSET.
Click Source Link
From source file:at.pagu.soldockr.core.QueryParser.java
License:Apache License
private void appendFacetingOnFields(SolrQuery solrQuery, FacetQuery query) { FacetOptions facetOptions = query.getFacetOptions(); if (facetOptions == null || !facetOptions.hasFields()) { return;/* ww w. j ava 2s .c o m*/ } solrQuery.setFacet(true); solrQuery.addFacetField(convertFieldListToStringArray(facetOptions.getFacetOnFields())); solrQuery.setFacetMinCount(facetOptions.getFacetMinCount()); solrQuery.setFacetLimit(facetOptions.getPageable().getPageSize()); if (facetOptions.getPageable().getPageNumber() > 0) { solrQuery.set(FacetParams.FACET_OFFSET, facetOptions.getPageable().getOffset()); } if (FacetOptions.FacetSort.INDEX.equals(facetOptions.getFacetSort())) { solrQuery.setFacetSort(FacetParams.FACET_SORT_INDEX); } }
From source file:com.frank.search.solr.core.DefaultQueryParser.java
License:Apache License
private boolean enableFaceting(SolrQuery solrQuery, FacetQuery query) { FacetOptions facetOptions = query.getFacetOptions(); if (facetOptions == null || !facetOptions.hasFacets()) { return false; }/*w ww .jav a2 s .c om*/ solrQuery.setFacet(true); solrQuery.setFacetMinCount(facetOptions.getFacetMinCount()); solrQuery.setFacetLimit(facetOptions.getPageable().getPageSize()); if (facetOptions.getPageable().getPageNumber() > 0) { int offset = Math.max(0, facetOptions.getPageable().getOffset()); solrQuery.set(FacetParams.FACET_OFFSET, offset); } if (FacetOptions.FacetSort.INDEX.equals(facetOptions.getFacetSort())) { solrQuery.setFacetSort(FacetParams.FACET_SORT_INDEX); } return true; }
From source file:de.uni_tuebingen.ub.ixTheo.handler.component.FacetPrefixSortComponent.java
License:Apache License
/** * Actually run the query//from w ww. j ava2s .c o m */ @Override public void process(ResponseBuilder rb) throws IOException { if (rb.doFacets) { final ModifiableSolrParams params = new ModifiableSolrParams(); final SolrParams origParams = rb.req.getParams(); final Iterator<String> iter = origParams.getParameterNamesIterator(); setCollator(origParams.get("lang")); while (iter.hasNext()) { final String paramName = iter.next(); // Deduplicate the list with LinkedHashSet, but _only_ for facet // params. if (!paramName.startsWith(FacetParams.FACET)) { params.add(paramName, origParams.getParams(paramName)); continue; } final HashSet<String> deDupe = new LinkedHashSet<>(Arrays.asList(origParams.getParams(paramName))); params.add(paramName, deDupe.toArray(new String[deDupe.size()])); } final SimplePrefixSortFacets facets = new SimplePrefixSortFacets(rb.req, rb.getResults().docSet, params, rb); final NamedList<Object> counts = org.apache.solr.handler.component.FacetComponent .getFacetCounts(facets); final String[] pivots = params.getParams(FacetParams.FACET_PIVOT); if (pivots != null && pivots.length > 0) { PivotFacetProcessor pivotProcessor = new PivotFacetProcessor(rb.req, rb.getResults().docSet, params, rb); SimpleOrderedMap<List<NamedList<Object>>> v = pivotProcessor.process(pivots); if (v != null) { counts.add(PIVOT_KEY, v); } } // Check whether we have to reorder out results // according to prefix final String sort = params.get(FacetParams.FACET_SORT); if (FacetPrefixSortParams.FACET_SORT_PREFIX.equals(sort)) { // Determine a score relative to the original query // Determine the query and make it compatible with our metric // class // by splitting the single terms String[] queryTerms = params.getParams(CommonParams.Q); final Collection<String> queryTermsCollection = new ArrayList<>(); for (String s : queryTerms) { // Split at whitespace except we have a quoted term Matcher matcher = WHITE_SPACES_WITH_QUOTES_SPLITTING_PATTERN.matcher(s); while (matcher.find()) { queryTermsCollection.add(matcher.group().replaceAll("^\"|\"$", "")); } } // In some contexts, i.e. in KWC that are derived from ordinary // keywords or if // wildcards occur, also add all the query terms as a single // phrase term // with stripped wildcards StringBuilder sb = new StringBuilder(); for (String s : queryTermsCollection) { s = s.replace("*", ""); sb.append(s); sb.append(" "); } queryTermsCollection.add(sb.toString().trim()); final ArrayList<String> queryList = new ArrayList<>(queryTermsCollection); final String facetfield = params.get(FacetParams.FACET_FIELD); // Get the current facet entry and make it compatible with our // metric class // "facet_fields" itself contains a NamedList with the // facet.field as key final NamedList<Object> facetFieldsNamedList = (NamedList<Object>) counts.get("facet_fields"); final NamedList<Object> facetFields = (NamedList<Object>) facetFieldsNamedList.get(facetfield); final List<Entry<Entry<String, Object>, Double>> facetPrefixListScored = new ArrayList<>(); for (final Entry<String, Object> entry : facetFields) { final String facetTerms = entry.getKey(); // Split up each KWC and calculate the scoring ArrayList<String> facetList = new ArrayList<>( Arrays.asList(facetTerms.split("(?<!" + Pattern.quote("\\") + ")/"))); // For usability reasons sort the result facets according to // the order of the search facetList = KeywordSort.sortToReferenceChain(queryList, facetList); final double score = KeywordChainMetric.calculateSimilarityScore(queryList, facetList); // Collect the result in a sorted list and throw away // garbage if (score > 0) { String facetTermsSorted = StringUtils.join(facetList, "/"); Map.Entry<String, Object> sortedEntry = new AbstractMap.SimpleEntry<>(facetTermsSorted, entry.getValue()); facetPrefixListScored.add(new AbstractMap.SimpleEntry<>(sortedEntry, score)); } } Collections.sort(facetPrefixListScored, ENTRY_COMPARATOR); // Extract all the values wrap it back to NamedList again and // replace in the original structure facetFieldsNamedList.clear(); NamedList<Object> facetNamedListSorted = new NamedList<>(); // We had to disable all limits and offsets sort according // Handle this accordingly now int offset = (params.getInt(FacetParams.FACET_OFFSET) != null) ? params.getInt(FacetParams.FACET_OFFSET) : 0; int limit = (params.getInt(FacetParams.FACET_LIMIT) != null) ? params.getInt(FacetParams.FACET_LIMIT) : 100; // Strip uneeded elements int s = facetPrefixListScored.size(); int off = (offset < s) ? offset : 0; limit = (limit < 0) ? s : limit; // Handle a negative limit // param, i.e. unlimited results int lim = (offset + limit <= s) ? (offset + limit) : s; final List<Entry<Entry<String, Object>, Double>> facetPrefixListScoredTruncated = facetPrefixListScored .subList(off, lim); for (Entry<Entry<String, Object>, Double> e : facetPrefixListScoredTruncated) { facetNamedListSorted.add(e.getKey().getKey(), e.getKey().getValue()); } facetFieldsNamedList.add(facetfield, facetNamedListSorted); NamedList<Object> countList = new NamedList<>(); countList.add("count", facetPrefixListScored.size()); facetFieldsNamedList.add(facetfield + "-count", countList); counts.remove("facet_fields"); counts.add("facet_fields", facetFieldsNamedList); } rb.rsp.add("facet_counts", counts); } }
From source file:org.dspace.app.xmlui.aspect.discovery.SearchFacetFilter.java
License:BSD License
/** * Get the recently submitted items for the given community or collection. * * @param scope The collection.//from ww w .java2s . co m */ protected QueryResponse getQueryResponse(DSpaceObject scope) { Request request = ObjectModelHelper.getRequest(objectModel); if (queryResults != null) { return queryResults; } queryArgs = new SolrQuery(); //Make sure we add our default filters queryArgs.addFilterQuery(SearchUtils.getDefaultFilters("search")); queryArgs.setQuery("search.resourcetype: " + Constants.ITEM + ((request.getParameter("query") != null && !"".equals(request.getParameter("query"))) ? " AND (" + request.getParameter("query") + ")" : "")); // queryArgs.setQuery("search.resourcetype:" + Constants.ITEM); queryArgs.setRows(0); queryArgs.addFilterQuery(getParameterFilterQueries()); //Set the default limit to 11 //query.setFacetLimit(11); queryArgs.setFacetMinCount(1); //sort //TODO: why this kind of sorting ? Should the sort not be on how many times the value appears like we do in the filter by sidebar ? queryArgs.setFacetSort(config.getPropertyAsType("solr.browse.sort", "lex")); queryArgs.setFacet(true); String facetField = request.getParameter(SearchFilterParam.FACET_FIELD); int offset = RequestUtils.getIntParameter(request, SearchFilterParam.OFFSET); if (offset == -1) { offset = 0; } if (facetField.endsWith(".year")) { // TODO: dates are now handled in another way, throw this away? queryArgs.setParam(FacetParams.FACET_OFFSET, "0"); queryArgs.setParam(FacetParams.FACET_LIMIT, "1000000"); } else { queryArgs.setParam(FacetParams.FACET_OFFSET, String.valueOf(offset)); //We add +1 so we can use the extra one to make sure that we need to show the next page queryArgs.setParam(FacetParams.FACET_LIMIT, String.valueOf(DEFAULT_PAGE_SIZE + 1)); } if (scope != null) /* top level search / community */ { if (scope instanceof Community) { queryArgs.setFilterQueries("location:m" + scope.getID()); } else if (scope instanceof Collection) { queryArgs.setFilterQueries("location:l" + scope.getID()); } } boolean isDate = false; if (facetField.endsWith("_dt")) { facetField = facetField.split("_")[0]; isDate = true; } if (isDate) { queryArgs.setParam(FacetParams.FACET_DATE, facetField); queryArgs.setParam(FacetParams.FACET_DATE_GAP, "+1YEAR"); Date lowestDate = getLowestDateValue(queryArgs.getQuery(), facetField, queryArgs.getFilterQueries()); int thisYear = Calendar.getInstance().get(Calendar.YEAR); DateFormat formatter = new SimpleDateFormat("yyyy"); int maxEndYear = Integer.parseInt(formatter.format(lowestDate)); //Since we have a date, we need to find the last year String startDate = "NOW/YEAR-" + SearchUtils.getConfig().getString("solr.date.gap", "10") + "YEARS"; String endDate = "NOW"; int startYear = thisYear - (offset + DEFAULT_PAGE_SIZE); // We shouldn't go lower then our max bottom year // Make sure to substract one so the bottom year is also counted ! if (startYear < maxEndYear) { startYear = maxEndYear - 1; } if (0 < offset) { //Say that we have an offset of 10 years //we need to go back 10 years (2010 - (2010 - 10)) //(add one to compensate for the NOW in the start) int endYear = thisYear - offset + 1; endDate = "NOW/YEAR-" + (thisYear - endYear) + "YEARS"; //Add one to the startyear to get one more result //When we select NOW, the current year is also used (so auto+1) } startDate = "NOW/YEAR-" + (thisYear - startYear) + "YEARS"; queryArgs.setParam(FacetParams.FACET_DATE_START, startDate); queryArgs.setParam(FacetParams.FACET_DATE_END, endDate); System.out.println(startDate); System.out.println(endDate); } else { if (request.getParameter(SearchFilterParam.STARTS_WITH) != null) { queryArgs.setFacetPrefix(facetField, request.getParameter(SearchFilterParam.STARTS_WITH).toLowerCase()); } queryArgs.addFacetField(facetField); } try { queryResults = searchService.search(queryArgs); } catch (SearchServiceException e) { log.error(e.getMessage(), e); } return queryResults; }
From source file:org.dspace.app.xmlui.aspect.discovery.SearchFacetFilter.java
License:BSD License
@Override public void addBody(Body body) throws SAXException, WingException, UIException, SQLException, IOException, AuthorizeException { Request request = ObjectModelHelper.getRequest(objectModel); DSpaceObject dso = HandleUtil.obtainHandle(objectModel); SearchFilterParam browseParams = new SearchFilterParam(request); // Build the DRI Body Division div = body.addDivision("browse-by-" + request.getParameter(SearchFilterParam.FACET_FIELD), "primary"); addBrowseJumpNavigation(div, browseParams, request); // Set up the major variables //Collection collection = (Collection) dso; // Build the collection viewer division. //Make sure we get our results queryResults = getQueryResponse(dso); if (this.queryResults != null) { java.util.List<FacetField> facetFields = this.queryResults.getFacetFields(); if (facetFields == null) { facetFields = new ArrayList<FacetField>(); }/*from ww w . ja v a2s . c o m*/ facetFields.addAll(this.queryResults.getFacetDates()); if (facetFields.size() > 0) { FacetField field = facetFields.get(0); java.util.List<FacetField.Count> values = field.getValues(); if (field.getGap() != null) { //We are dealing with dates so flip em, top date comes first Collections.reverse(values); } Division results = body.addDivision("browse-by-" + field + "-results", "primary"); results.setHead(message("xmlui.Discovery.AbstractSearch.type_" + browseParams.getFacetField())); if (values != null && 0 < values.size()) { // Find our faceting offset int offSet = 0; try { offSet = Integer.parseInt(queryArgs.get(FacetParams.FACET_OFFSET)); } catch (NumberFormatException e) { //Ignore } //Only show the nextpageurl if we have at least one result following our current results String nextPageUrl = null; if (field.getName().endsWith(".year")) { offSet = Util.getIntParameter(request, SearchFilterParam.OFFSET); offSet = offSet == -1 ? 0 : offSet; if ((offSet + DEFAULT_PAGE_SIZE) < values.size()) { nextPageUrl = getNextPageURL(browseParams, request); } } else { if (values.size() == (DEFAULT_PAGE_SIZE + 1)) { nextPageUrl = getNextPageURL(browseParams, request); } } int shownItemsMax; if (field.getName().endsWith(".year")) { if ((values.size() - offSet) < DEFAULT_PAGE_SIZE) { shownItemsMax = values.size(); } else { shownItemsMax = DEFAULT_PAGE_SIZE; } } else { shownItemsMax = offSet + (DEFAULT_PAGE_SIZE < values.size() ? values.size() - 1 : values.size()); } // We put our total results to -1 so this doesn't get shown in the results (will be hidden by the xsl) // The reason why we do this is because solr 1.4 can't retrieve the total number of facets found results.setSimplePagination(-1, offSet + 1, shownItemsMax, getPreviousPageURL(browseParams, request), nextPageUrl); Table singleTable = results.addTable("browse-by-" + field + "-results", (int) (queryResults.getResults().getNumFound() + 1), 1); List<String> filterQueries = new ArrayList<String>(); if (request.getParameterValues("fq") != null) { filterQueries = Arrays.asList(request.getParameterValues("fq")); } if (field.getName().endsWith(".year")) { int start = (values.size() - 1) - offSet; int end = start - DEFAULT_PAGE_SIZE; if (end < 0) { end = 0; } else { end++; } for (int i = start; end <= i; i--) { FacetField.Count value = values.get(i); renderFacetField(browseParams, dso, field, singleTable, filterQueries, value); } } else { int end = values.size(); if (DEFAULT_PAGE_SIZE < end) { end = DEFAULT_PAGE_SIZE; } for (int i = 0; i < end; i++) { FacetField.Count value = values.get(i); renderFacetField(browseParams, dso, field, singleTable, filterQueries, value); } } } else { results.addPara(message("xmlui.discovery.SearchFacetFilter.no-results")); } } } }
From source file:org.dspace.app.xmlui.aspect.discovery.SearchFacetFilter.java
License:BSD License
private String getPreviousPageURL(SearchFilterParam browseParams, Request request) { //If our offset should be 0 then we shouldn't be able to view a previous page url if ("0".equals(queryArgs.get(FacetParams.FACET_OFFSET)) && Util.getIntParameter(request, "offset") == -1) { return null; }//from w ww. j av a 2 s .c om int offset = Util.getIntParameter(request, SearchFilterParam.OFFSET); if (offset == -1 || offset == 0) { return null; } Map<String, String> parameters = new HashMap<String, String>(); parameters.putAll(browseParams.getCommonBrowseParams()); parameters.putAll(browseParams.getControlParameters()); parameters.put(SearchFilterParam.OFFSET, String.valueOf(offset - DEFAULT_PAGE_SIZE)); //TODO: correct comm/collection url // Add the filter queries String url = generateURL("search-filter", parameters); url = addFilterQueriesToUrl(url); return url; }
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(); }//from ww w . 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.jahia.services.search.facets.SimpleJahiaJcrFacets.java
License:Open Source License
public NamedList<Object> getTermCounts(String field, ExtendedPropertyDefinition epd, String fieldNameInIndex, String locale) throws IOException, RepositoryException { int offset = params.getFieldInt(field, FacetParams.FACET_OFFSET, 0); int limit = params.getFieldInt(field, FacetParams.FACET_LIMIT, 100); if (limit == 0) return new NamedList<Object>(); Integer mincount = params.getFieldInt(field, FacetParams.FACET_MINCOUNT); if (mincount == null) { Boolean zeros = params.getFieldBool(field, FacetParams.FACET_ZEROS); // mincount = (zeros!=null && zeros) ? 0 : 1; mincount = (zeros != null && !zeros) ? 1 : 0; // current default is to include zeros. }//from www . java 2 s.co m boolean missing = params.getFieldBool(field, FacetParams.FACET_MISSING, false); // default to sorting if there is a limit. String sort = params.getFieldParam(field, FacetParams.FACET_SORT, limit > 0 ? FacetParams.FACET_SORT_COUNT : FacetParams.FACET_SORT_INDEX); String prefix = params.getFieldParam(field, FacetParams.FACET_PREFIX); NamedList<Object> counts; SchemaField sf = new SchemaField(fieldNameInIndex, getType(epd)); FieldType ft = sf.getType(); // determine what type of faceting method to use String method = params.getFieldParam(field, FacetParams.FACET_METHOD); boolean enumMethod = FacetParams.FACET_METHOD_enum.equals(method); if (method == null && ft instanceof BoolField) { // Always use filters for booleans... we know the number of values is very small. enumMethod = true; } boolean multiToken = epd.isMultiple(); // --> added by jahia as we don't use the UnInvertedField class yet due to not using SolrIndexSearcher enumMethod = enumMethod || multiToken; // if (TrieField.getMainValuePrefix(ft) != null) { // // A TrieField with multiple parts indexed per value... currently only // // UnInvertedField can handle this case, so force it's use. // enumMethod = false; // multiToken = true; // } // unless the enum method is explicitly specified, use a counting method. if (enumMethod) { // Always use filters for booleans... we know the number of values is very small. counts = getFacetTermEnumCounts(searcher, docs, field, fieldNameInIndex, offset, limit, mincount, missing, sort, prefix, epd.isInternationalized() ? (locale == null ? "" : locale) : null, epd); } else { // if (multiToken) { // UnInvertedField uif = UnInvertedField.getUnInvertedField(field, searcher); // counts = uif.getCounts(searcher, base, offset, limit, mincount,missing,sort,prefix); // } else { // TODO: future logic could use filters instead of the fieldcache if // the number of terms in the field is small enough. counts = getFieldCacheCounts(searcher, docs, fieldNameInIndex, offset, limit, mincount, missing, sort, prefix, epd.isInternationalized() ? (locale == null ? "" : locale) : null, epd); // } } return counts; }
From source file:org.springframework.data.solr.core.DefaultQueryParser.java
License:Apache License
private boolean enableFaceting(SolrQuery solrQuery, FacetQuery query) { FacetOptions facetOptions = query.getFacetOptions(); if (facetOptions == null || (!facetOptions.hasFields() && !facetOptions.hasFacetQueries() && !facetOptions.hasPivotFields())) { return false; }/* www . j av a2s. com*/ solrQuery.setFacet(true); solrQuery.setFacetMinCount(facetOptions.getFacetMinCount()); solrQuery.setFacetLimit(facetOptions.getPageable().getPageSize()); if (facetOptions.getPageable().getPageNumber() > 0) { int offset = Math.max(0, facetOptions.getPageable().getOffset()); solrQuery.set(FacetParams.FACET_OFFSET, offset); } if (FacetOptions.FacetSort.INDEX.equals(facetOptions.getFacetSort())) { solrQuery.setFacetSort(FacetParams.FACET_SORT_INDEX); } return true; }
From source file:org.springframework.data.solr.core.DefaultQueryParserTests.java
License:Apache License
/** * @see DATASOLR-236/* w ww . jav a2 s . c o m*/ */ @Test public void testNegativeFacetLimitUsingFacetOptions_setFacetLimit() { FacetQuery query = new SimpleFacetQuery(new Criteria("field_1").is("value_1")); FacetOptions facetOptions = new FacetOptions(new SimpleField("facet_1")); facetOptions.setFacetLimit(-1); query.setFacetOptions(facetOptions); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals(-1, solrQuery.getFacetLimit()); Assert.assertEquals(null, solrQuery.get(FacetParams.FACET_OFFSET)); }