Java SolrParams.getFieldParam方法代码示例

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
protected Predicate<BytesRef> newBytesRefFilter(String field, SolrParams params) {
  final String contains = params.getFieldParam(field, FacetParams.FACET_CONTAINS);

  final Predicate<BytesRef> containsFilter;
  if (contains != null) {
    final boolean containsIgnoreCase = params.getFieldBool(field, FacetParams.FACET_CONTAINS_IGNORE_CASE, false);
    containsFilter = new SubstringBytesRefFilter(contains, containsIgnoreCase);
  } else {
    containsFilter = null;
  }

  final Predicate<BytesRef> excludeFilter = newExcludeBytesRefFilter(field, params);

  if (containsFilter == null && excludeFilter == null) {
    return null;
  }

  if (containsFilter != null && excludeFilter == null) {
    return containsFilter;
  } else if (containsFilter == null && excludeFilter != null) {
    return excludeFilter;
  }

  return containsFilter.and(excludeFilter);
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
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);
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
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;
  }
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
@Override
public Fragmenter getFragmenter(String fieldName, SolrParams params )
{ 
  numRequests++;
  params = SolrParams.wrapDefaults(params, defaults);

  int fragsize  = params.getFieldInt(   fieldName, HighlightParams.FRAGSIZE,  LuceneRegexFragmenter.DEFAULT_FRAGMENT_SIZE );
  int increment = params.getFieldInt(   fieldName, HighlightParams.INCREMENT, LuceneRegexFragmenter.DEFAULT_INCREMENT_GAP );
  float slop    = params.getFieldFloat( fieldName, HighlightParams.SLOP,      LuceneRegexFragmenter.DEFAULT_SLOP );
  int maxchars  = params.getFieldInt(   fieldName, HighlightParams.MAX_RE_CHARS, LuceneRegexFragmenter.DEFAULT_MAX_ANALYZED_CHARS );
  String rawpat = params.getFieldParam( fieldName, HighlightParams.PATTERN,   LuceneRegexFragmenter.DEFAULT_PATTERN_RAW );

  Pattern p = rawpat == defaultPatternRaw ? defaultPattern : Pattern.compile(rawpat);

  if( fragsize <= 0 ) {
    return new NullFragmenter();
  }
  
  return new LuceneRegexFragmenter( fragsize, increment, slop, maxchars, p );
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
protected Predicate<BytesRef> newExcludeBytesRefFilter(String field, SolrParams params) {
  final String exclude = params.getFieldParam(field, FacetParams.FACET_EXCLUDETERMS);
  if (exclude == null) {
    return null;
  }

  final Set<String> excludeTerms = new HashSet<>(StrUtils.splitSmart(exclude, ",", true));

  return new Predicate<BytesRef>() {
    @Override
    public boolean test(BytesRef bytesRef) {
      return !excludeTerms.contains(bytesRef.utf8ToString());
    }
  };
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
@Override
protected BoundaryScanner get(String fieldName, SolrParams params) {
  // construct Locale
  String language = params.getFieldParam(fieldName, HighlightParams.BS_LANGUAGE);
  String country = params.getFieldParam(fieldName, HighlightParams.BS_COUNTRY);
  if(country != null && language == null){
    throw new SolrException(ErrorCode.BAD_REQUEST,
        HighlightParams.BS_LANGUAGE + " parameter cannot be null when you specify " + HighlightParams.BS_COUNTRY);
  }
  Locale locale = null;
  if(language != null){
    locale = country == null ? new Locale(language) : new Locale(language, country);
  } else {
    locale = Locale.ROOT;
  }

  // construct BreakIterator
  String type = params.getFieldParam(fieldName, HighlightParams.BS_TYPE, "WORD").toLowerCase(Locale.ROOT);
  BreakIterator bi = null;
  if(type.equals("character")){
    bi = BreakIterator.getCharacterInstance(locale);
  }
  else if(type.equals("word")){
    bi = BreakIterator.getWordInstance(locale);
  }
  else if(type.equals("line")){
    bi = BreakIterator.getLineInstance(locale);
  }
  else if(type.equals("sentence")){
    bi = BreakIterator.getSentenceInstance(locale);
  }
  else
    throw new SolrException(ErrorCode.BAD_REQUEST, type + " is invalid for parameter " + HighlightParams.BS_TYPE);

  return new org.apache.lucene.search.vectorhighlight.BreakIteratorBoundaryScanner(bi);
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
private String[] getTags( SolrParams params, String paramName, String fieldName, String def ){
  params = SolrParams.wrapDefaults(params, defaults);

  String value = null;
  if( fieldName == null )
    value = params.get( paramName, def );
  else
    value = params.getFieldParam( fieldName, paramName, def );
  String[] tags = value.split( "," );
  for( int i = 0; i < tags.length; i++ ){
    tags[i] = tags[i].trim();
  }
  return tags;
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
/**
 * Return a {@link org.apache.lucene.search.highlight.Formatter} appropriate for this field. If a formatter
 * has not been configured for this field, fall back to the configured
 * default or the solr default ({@link org.apache.lucene.search.highlight.SimpleHTMLFormatter}).
 * 
 * @param fieldName The name of the field
 * @param params The params controlling Highlighting
 * @return An appropriate {@link org.apache.lucene.search.highlight.Formatter}.
 */
protected Formatter getFormatter(String fieldName, SolrParams params ) 
{
  String str = params.getFieldParam( fieldName, HighlightParams.FORMATTER );
  SolrFormatter formatter = formatters.get( str );
  if( formatter == null ) {
    throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, "Unknown formatter: "+str );
  }
  return formatter.getFormatter( fieldName, params );
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
/**
 * Return a {@link org.apache.lucene.search.highlight.Fragmenter} appropriate for this field. If a fragmenter
 * has not been configured for this field, fall back to the configured
 * default or the solr default ({@link GapFragmenter}).
 * 
 * @param fieldName The name of the field
 * @param params The params controlling Highlighting
 * @return An appropriate {@link org.apache.lucene.search.highlight.Fragmenter}.
 */
protected Fragmenter getFragmenter(String fieldName, SolrParams params) 
{
  String fmt = params.getFieldParam( fieldName, HighlightParams.FRAGMENTER );
  SolrFragmenter frag = fragmenters.get( fmt );
  if( frag == null ) {
    throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, "Unknown fragmenter: "+fmt );
  }
  return frag.getFragmenter( fieldName, params );
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
protected FragListBuilder getFragListBuilder( String fieldName, SolrParams params ){
  String flb = params.getFieldParam( fieldName, HighlightParams.FRAG_LIST_BUILDER );
  SolrFragListBuilder solrFlb = fragListBuilders.get( flb );
  if( solrFlb == null ){
    throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, "Unknown fragListBuilder: " + flb );
  }
  return solrFlb.getFragListBuilder( params );
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
private SolrFragmentsBuilder getSolrFragmentsBuilder( String fieldName, SolrParams params ){
  String fb = params.getFieldParam( fieldName, HighlightParams.FRAGMENTS_BUILDER );
  SolrFragmentsBuilder solrFb = fragmentsBuilders.get( fb );
  if( solrFb == null ){
    throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, "Unknown fragmentsBuilder: " + fb );
  }
  return solrFb;
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
private BoundaryScanner getBoundaryScanner(String fieldName, SolrParams params){
  String bs = params.getFieldParam(fieldName, HighlightParams.BOUNDARY_SCANNER);
  SolrBoundaryScanner solrBs = boundaryScanners.get(bs);
  if(solrBs == null){
    throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "Unknown boundaryScanner: " + bs);
  }
  return solrBs.getBoundaryScanner(fieldName, params);
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
@Override
protected BoundaryScanner get(String fieldName, SolrParams params) {
  int maxScan = params.getFieldInt(fieldName, HighlightParams.BS_MAX_SCAN, 10);
  String str = params.getFieldParam(fieldName, HighlightParams.BS_CHARS, ".,!? \t\n");
  Character[] chars = new Character[str.length()];
  for(int i = 0; i < str.length(); i++){
    chars[i] = str.charAt(i);
  }
  return new org.apache.lucene.search.vectorhighlight.SimpleBoundaryScanner(maxScan, chars);
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
@Override
public Formatter getFormatter(String fieldName, SolrParams params ) 
{
  numRequests++;
  params = SolrParams.wrapDefaults(params, defaults);

  return new SimpleHTMLFormatter(
      params.getFieldParam(fieldName, HighlightParams.SIMPLE_PRE,  "<em>" ), 
      params.getFieldParam(fieldName, HighlightParams.SIMPLE_POST, "</em>"));
}
 

import org.apache.solr.common.params.SolrParams; //导入方法依赖的package包/类
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);
}