Java FacetParams.FACET_SORT_COUNT属性代码示例

protected void fillParams(ResponseBuilder rb, SolrParams params, String field) {
  this.field = field;
  this.ftype = rb.req.getSchema().getFieldTypeNoEx(this.field);
  this.offset = params.getFieldInt(field, FacetParams.FACET_OFFSET, 0);
  this.limit = params.getFieldInt(field, FacetParams.FACET_LIMIT, 100);
  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.
  }
  this.minCount = mincount;
  this.missing = params.getFieldBool(field, FacetParams.FACET_MISSING, false);
  // default to sorting by count if there is a limit.
  this.sort = params.getFieldParam(field, FacetParams.FACET_SORT,
                                   (limit > 0 ? 
                                    FacetParams.FACET_SORT_COUNT
                                    : FacetParams.FACET_SORT_INDEX));
  if (this.sort.equals(FacetParams.FACET_SORT_COUNT_LEGACY)) {
    this.sort = FacetParams.FACET_SORT_COUNT;
  } else if (this.sort.equals(FacetParams.FACET_SORT_INDEX_LEGACY)) {
    this.sort = FacetParams.FACET_SORT_INDEX;
  }
  this.prefix = params.getFieldParam(field, FacetParams.FACET_PREFIX);
}
 

private PivotFacetField(ResponseBuilder rb, PivotFacetValue parent, String fieldName) {
  
  field = fieldName;
  parentValue = parent;
  
  // facet params
  SolrParams parameters = rb.req.getParams();
  facetFieldMinimumCount = parameters.getFieldInt(field, FacetParams.FACET_PIVOT_MINCOUNT, 1);
  facetFieldOffset = parameters.getFieldInt(field, FacetParams.FACET_OFFSET, 0);
  facetFieldLimit = parameters.getFieldInt(field, FacetParams.FACET_LIMIT, 100);
  String defaultSort = (facetFieldLimit > 0) ? FacetParams.FACET_SORT_COUNT : FacetParams.FACET_SORT_INDEX;
  facetFieldSort = parameters.getFieldParam(field, FacetParams.FACET_SORT, defaultSort);

  valueCollection = new PivotFacetFieldValueCollection(facetFieldMinimumCount, facetFieldOffset, facetFieldLimit, facetFieldSort);
  
  if ( (facetFieldLimit < 0) || 
       // TODO: possible refinement issue if limit=0 & mincount=0 & missing=true
       // (ie: we only want the missing count for this field)
       (facetFieldLimit <= 0 && facetFieldMinimumCount == 0) ||
       (facetFieldSort.equals(FacetParams.FACET_SORT_INDEX) && facetFieldMinimumCount <= 0) 
       ) {
    // in any of these cases, there's no need to refine this level of the pivot
    needRefinementAtThisLevel = false;
  }
}
 

private NamedList<Integer> getTermCounts(String field, String fieldPath, Integer mincount, int limit, DocSet docs) throws IOException {
    if(cachedFieldCounts.containsKey(fieldPath)){
        return cachedFieldCounts.get(fieldPath);
    }

    int offset = 0;
    if (limit == 0) return new NamedList<Integer>();

    String sort = FacetParams.FACET_SORT_COUNT;
    NamedList<Integer> counts;

    FacetMethod method = getFacetMethod(field);
    switch (method) {
        case ENUM:
            // intersectsCheck should be false, else facet counts will be capped at 1 (binary)
            counts = getFacetTermEnumCounts(searcher, docs, field, offset, limit, mincount,false,sort,null, null, false, false);
            break;
        case FC:
            counts = DocValuesFacets.getCounts(searcher, docs, field, offset, limit, mincount, false, sort, null, null, false, null);
            break;
        default:
            throw new AssertionError();
    }
    cachedFieldCounts.put(fieldPath, counts);
    return counts;
}
 

private void fillParams(ResponseBuilder rb, SolrParams params, String field) {
  this.field = field;
  this.ftype = rb.req.getSchema().getFieldTypeNoEx(this.field);
  this.offset = params.getFieldInt(field, FacetParams.FACET_OFFSET, 0);
  this.limit = params.getFieldInt(field, FacetParams.FACET_LIMIT, 100);
  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.
  }
  this.minCount = mincount;
  this.missing = params.getFieldBool(field, FacetParams.FACET_MISSING, false);
  // default to sorting by count if there is a limit.
  this.sort = params.getFieldParam(field, FacetParams.FACET_SORT, limit>0 ? FacetParams.FACET_SORT_COUNT : FacetParams.FACET_SORT_INDEX);
  if (this.sort.equals(FacetParams.FACET_SORT_COUNT_LEGACY)) {
    this.sort = FacetParams.FACET_SORT_COUNT;
  } else if (this.sort.equals(FacetParams.FACET_SORT_INDEX_LEGACY)) {
    this.sort = FacetParams.FACET_SORT_INDEX;
  }
  this.prefix = params.getFieldParam(field,FacetParams.FACET_PREFIX);
}
 

private void modifyRequestForIndividualPivotFacets(ResponseBuilder rb, ShardRequest sreq, 
                                                   String fieldToOverRequest) {

  final SolrParams originalParams = rb.req.getParams();
  final String paramStart = "f." + fieldToOverRequest + ".";

  final int requestedLimit = originalParams.getFieldInt(fieldToOverRequest,
                                                        FacetParams.FACET_LIMIT, 100);
  sreq.params.remove(paramStart + FacetParams.FACET_LIMIT);

  final int offset = originalParams.getFieldInt(fieldToOverRequest,
                                                FacetParams.FACET_OFFSET, 0);
  sreq.params.remove(paramStart + FacetParams.FACET_OFFSET);
  
  final double overRequestRatio = originalParams.getFieldDouble
    (fieldToOverRequest, FacetParams.FACET_OVERREQUEST_RATIO, 1.5);
  sreq.params.remove(paramStart + FacetParams.FACET_OVERREQUEST_RATIO);
  
  final int overRequestCount = originalParams.getFieldInt
    (fieldToOverRequest, FacetParams.FACET_OVERREQUEST_COUNT, 10);
  sreq.params.remove(paramStart + FacetParams.FACET_OVERREQUEST_COUNT);
  
  final int requestedMinCount = originalParams.getFieldInt
    (fieldToOverRequest, FacetParams.FACET_PIVOT_MINCOUNT, 1);
  sreq.params.remove(paramStart + FacetParams.FACET_PIVOT_MINCOUNT);

  final String defaultSort = (requestedLimit > 0)
    ? FacetParams.FACET_SORT_COUNT : FacetParams.FACET_SORT_INDEX;
  final String sort = originalParams.getFieldParam
    (fieldToOverRequest, FacetParams.FACET_SORT, defaultSort);

  int shardLimit = requestedLimit + offset;
  int shardMinCount = requestedMinCount;

  // per-shard mincount & overrequest
  if ( FacetParams.FACET_SORT_INDEX.equals(sort) && 
       1 < requestedMinCount && 
       0 < requestedLimit) {

    // We can divide the mincount by num shards rounded up, because unless 
    // a single shard has at least that many it can't compete...
    shardMinCount = (int) Math.ceil((double) requestedMinCount / rb.slices.length);

    // ...but we still need to overrequest to reduce chances of missing something
    shardLimit = doOverRequestMath(shardLimit, overRequestRatio, overRequestCount);

    // (for mincount <= 1, no overrequest needed)

  } else if ( FacetParams.FACET_SORT_COUNT.equals(sort) ) {
    if ( 0 < requestedLimit ) {
      shardLimit = doOverRequestMath(shardLimit, overRequestRatio, overRequestCount);
      shardMinCount = 0; 
    } else {
      shardMinCount = Math.min(requestedMinCount, 1);
    }
  } 
  sreq.params.set(paramStart + FacetParams.FACET_LIMIT, shardLimit);
  sreq.params.set(paramStart + FacetParams.FACET_PIVOT_MINCOUNT, shardMinCount);
}
 

protected void fillParams(ResponseBuilder rb, SolrParams params, String field) {
  this.field = field;
  this.ftype = rb.req.getSchema().getFieldTypeNoEx(this.field);
  this.offset = params.getFieldInt(field, FacetParams.FACET_OFFSET, 0);
  this.limit = params.getFieldInt(field, FacetParams.FACET_LIMIT, 100);
  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.
  }
  this.minCount = mincount;
  this.missing = params.getFieldBool(field, FacetParams.FACET_MISSING, false);
  // default to sorting by count if there is a limit.
  this.sort = params.getFieldParam(field, FacetParams.FACET_SORT,
                                   (limit > 0 ? 
                                    FacetParams.FACET_SORT_COUNT
                                    : FacetParams.FACET_SORT_INDEX));
  if (this.sort.equals(FacetParams.FACET_SORT_COUNT_LEGACY)) {
    this.sort = FacetParams.FACET_SORT_COUNT;
  } else if (this.sort.equals(FacetParams.FACET_SORT_INDEX_LEGACY)) {
    this.sort = FacetParams.FACET_SORT_INDEX;
  }
  this.prefix = params.getFieldParam(field, FacetParams.FACET_PREFIX);
  this.targetDoc = params.getFieldParam(field, FacetParams.FACET_TARGET_DOC);
  this.fl = rb.rsp.getReturnFields().getRequestedFieldNames();
  String rawTarget = params.getFieldParam(field, FacetParams.FACET_TARGET);
  if (rawTarget != null) {
    this.target = new ShardFacetCount();
    boolean targetStrict = params.getFieldBool(field, FacetParams.FACET_TARGET_STRICT, this.targetDoc != null && !this.targetDoc.isEmpty());
    boolean appendDoc = targetStrict && this.targetDoc != null;
    if (ftype instanceof MultiSerializable) {
      try {
        this.target.indexed = ((MultiSerializable)ftype).normalizeQueryTarget(rawTarget, targetStrict, field, appendDoc);
      } catch (IOException ex) {
        throw new RuntimeException(ex);
      }
    } else {
      this.target.indexed = new BytesRef(rawTarget);
    }
    if (appendDoc) {
      BytesRefBuilder builder = new BytesRefBuilder();
      builder.append(this.target.indexed);
      builder.append(new BytesRef(this.targetDoc));
      this.target.indexed = builder.get();
    }
  }
  this.extend = params.getFieldBool(field, FacetParams.FACET_EXTEND, true);
}