Java SortField.getField方法代码示例

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
@Override
public ValueSource getValueSource(String name) {
  Object o = map.get(name);
  if (o == null) {
    throw new IllegalArgumentException("Invalid reference '" + name + "'");
  } else if (o instanceof Expression) {
    return ((Expression)o).getValueSource(this);
  } else if (o instanceof ValueSource) {
    return ((ValueSource)o);
  }
  SortField field = (SortField) o;
  switch(field.getType()) {
    case INT:
      return new IntFieldSource(field.getField(), (IntParser) field.getParser());
    case LONG:
      return new LongFieldSource(field.getField(), (LongParser) field.getParser());
    case FLOAT:
      return new FloatFieldSource(field.getField(), (FloatParser) field.getParser());
    case DOUBLE:
      return new DoubleFieldSource(field.getField(), (DoubleParser) field.getParser());
    case SCORE:
      return getScoreValueSource();
    default:
      throw new UnsupportedOperationException(); 
  }
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public static void writeSortField(StreamOutput out, SortField sortField) throws IOException {
    if (sortField.getClass() == GEO_DISTANCE_SORT_TYPE_CLASS) {
        // for geo sorting, we replace the SortField with a SortField that assumes a double field.
        // this works since the SortField is only used for merging top docs
        SortField newSortField = new SortField(sortField.getField(), SortField.Type.DOUBLE);
        newSortField.setMissingValue(sortField.getMissingValue());
        sortField = newSortField;
    }
    if (sortField.getClass() != SortField.class) {
        throw new IllegalArgumentException("Cannot serialize SortField impl [" + sortField + "]");
    }
    if (sortField.getField() == null) {
        out.writeBoolean(false);
    } else {
        out.writeBoolean(true);
        out.writeString(sortField.getField());
    }
    if (sortField.getComparatorSource() != null) {
        IndexFieldData.XFieldComparatorSource comparatorSource = (IndexFieldData.XFieldComparatorSource) sortField.getComparatorSource();
        writeSortType(out, comparatorSource.reducedType());
        writeMissingValue(out, comparatorSource.missingValue(sortField.getReverse()));
    } else {
        writeSortType(out, sortField.getType());
        writeMissingValue(out, sortField.getMissingValue());
    }
    out.writeBoolean(sortField.getReverse());
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
public ShardComparator(SortField sortField) {
  this.sortField = sortField;
  this.fieldName = sortField.getField();
  int fieldNum = 0;
  for (int i=0; i<fieldNames.size(); i++) {
    if (fieldNames.get(i).equals(fieldName)) {
      fieldNum = i;
      break;
    }
  }
  this.fieldNum = fieldNum;
}
 

import org.apache.lucene.search.SortField; //导入方法依赖的package包/类
private SortDoc getSortDoc(SolrIndexSearcher searcher, SortField[] sortFields) throws IOException {
  SortValue[] sortValues = new SortValue[sortFields.length];
  IndexSchema schema = searcher.getSchema();
  for(int i=0; i<sortFields.length; ++i) {
    SortField sf = sortFields[i];
    String field = sf.getField();
    boolean reverse = sf.getReverse();
    SchemaField schemaField = schema.getField(field);
    FieldType ft = schemaField.getType();

    if(!schemaField.hasDocValues()) {
      throw new IOException(field+" must have DocValues to use this feature.");
    }

    if(ft instanceof TrieIntField) {
      if(reverse) {
        sortValues[i] = new IntValue(field, new IntDesc());
      } else {
        sortValues[i] = new IntValue(field, new IntAsc());
      }
    } else if(ft instanceof TrieFloatField) {
      if(reverse) {
        sortValues[i] = new FloatValue(field, new FloatDesc());
      } else {
        sortValues[i] = new FloatValue(field, new FloatAsc());
      }
    } else if(ft instanceof TrieDoubleField) {
      if(reverse) {
        sortValues[i] = new DoubleValue(field, new DoubleDesc());
      } else {
        sortValues[i] = new DoubleValue(field, new DoubleAsc());
      }
    } else if(ft instanceof TrieLongField) {
      if(reverse) {
        sortValues[i] = new LongValue(field, new LongDesc());
      } else {
        sortValues[i] = new LongValue(field, new LongAsc());
      }
    } else if(ft instanceof StrField) {
      AtomicReader reader = searcher.getAtomicReader();
      SortedDocValues vals =  reader.getSortedDocValues(field);
      if(reverse) {
        sortValues[i] = new StringValue(vals, field, new IntDesc());
      } else {
        sortValues[i] = new StringValue(vals, field, new IntAsc());
      }
    } else {
      throw new IOException("Sort fields must be one of the following types: int,float,long,double,string");
    }
  }

  if(sortValues.length == 1) {
    return new SingleValueSortDoc(sortValues[0]);
  } else if(sortValues.length == 2) {
    return new DoubleValueSortDoc(sortValues[0], sortValues[1]);
  } else if(sortValues.length == 3) {
    return new TripleValueSortDoc(sortValues[0], sortValues[1], sortValues[2]);
  } else if(sortValues.length == 4) {
    return new QuadValueSortDoc(sortValues[0], sortValues[1], sortValues[2], sortValues[3]);
  } else {
    throw new IOException("A max of 4 sorts can be specified");
  }
}