Java FieldType.setNumericPrecisionStep方法代码示例

import org.apache.lucene.document.FieldType; //导入方法依赖的package包/类
public BBoxStrategy(SpatialContext ctx, String fieldNamePrefix) {
  super(ctx, fieldNamePrefix);
  field_bbox = fieldNamePrefix;
  field_minX = fieldNamePrefix + SUFFIX_MINX;
  field_maxX = fieldNamePrefix + SUFFIX_MAXX;
  field_minY = fieldNamePrefix + SUFFIX_MINY;
  field_maxY = fieldNamePrefix + SUFFIX_MAXY;
  field_xdl = fieldNamePrefix + SUFFIX_XDL;

  FieldType fieldType = new FieldType(DoubleField.TYPE_NOT_STORED);
  fieldType.setNumericPrecisionStep(8);//Solr's default
  fieldType.setDocValueType(FieldInfo.DocValuesType.NUMERIC);
  setFieldType(fieldType);
}
 

import org.apache.lucene.document.FieldType; //导入方法依赖的package包/类
/** @see #createIndexableFields(com.spatial4j.core.shape.Shape) */
public Field[] createIndexableFields(Point point) {
  FieldType doubleFieldType = new FieldType(DoubleField.TYPE_NOT_STORED);
  doubleFieldType.setNumericPrecisionStep(precisionStep);
  Field[] f = new Field[2];
  f[0] = new DoubleField(fieldNameX, point.getX(), doubleFieldType);
  f[1] = new DoubleField(fieldNameY, point.getY(), doubleFieldType);
  return f;
}
 

import org.apache.lucene.document.FieldType; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public IndexableField createField(SchemaField field, Object value, float boost) {
  final boolean indexed = field.indexed();
  final boolean stored = field.stored();
  final boolean docValues = field.hasDocValues();

  if (!indexed && !stored && !docValues) {
    if (log.isTraceEnabled())
      log.trace("Ignoring unindexed/unstored field: " + field);
    return null;
  }
  final Integer intValue = stringValueToIntValue(value.toString());
  if (intValue == null || intValue.equals(DEFAULT_VALUE))
    throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Unknown value for enum field: " + value.toString());

  String intAsString =  intValue.toString();
  final FieldType newType = new FieldType();

  newType.setIndexed(field.indexed());
  newType.setTokenized(field.isTokenized());
  newType.setStored(field.stored());
  newType.setOmitNorms(field.omitNorms());
  newType.setIndexOptions(getIndexOptions(field, intAsString));
  newType.setStoreTermVectors(field.storeTermVector());
  newType.setStoreTermVectorOffsets(field.storeTermOffsets());
  newType.setStoreTermVectorPositions(field.storeTermPositions());
  newType.setNumericType(FieldType.NumericType.INT);
  newType.setNumericPrecisionStep(DEFAULT_PRECISION_STEP);

  final org.apache.lucene.document.Field f;
  f = new org.apache.lucene.document.IntField(field.getName(), intValue.intValue(), newType);

  f.setBoost(boost);
  return f;
}
 

import org.apache.lucene.document.FieldType; //导入方法依赖的package包/类
@BeforeClass
public static void beforeClass() throws Exception {
  noDocs = atLeast(4096);
  distance = (1 << 30) / noDocs;
  directory = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), directory,
      newIndexWriterConfig(new MockAnalyzer(random()))
      .setMaxBufferedDocs(TestUtil.nextInt(random(), 100, 1000))
      .setMergePolicy(newLogMergePolicy()));
  
  final FieldType storedInt = new FieldType(IntField.TYPE_NOT_STORED);
  storedInt.setStored(true);
  storedInt.freeze();

  final FieldType storedInt8 = new FieldType(storedInt);
  storedInt8.setNumericPrecisionStep(8);

  final FieldType storedInt4 = new FieldType(storedInt);
  storedInt4.setNumericPrecisionStep(4);

  final FieldType storedInt2 = new FieldType(storedInt);
  storedInt2.setNumericPrecisionStep(2);

  final FieldType storedIntNone = new FieldType(storedInt);
  storedIntNone.setNumericPrecisionStep(Integer.MAX_VALUE);

  final FieldType unstoredInt = IntField.TYPE_NOT_STORED;

  final FieldType unstoredInt8 = new FieldType(unstoredInt);
  unstoredInt8.setNumericPrecisionStep(8);

  final FieldType unstoredInt4 = new FieldType(unstoredInt);
  unstoredInt4.setNumericPrecisionStep(4);

  final FieldType unstoredInt2 = new FieldType(unstoredInt);
  unstoredInt2.setNumericPrecisionStep(2);

  IntField
    field8 = new IntField("field8", 0, storedInt8),
    field4 = new IntField("field4", 0, storedInt4),
    field2 = new IntField("field2", 0, storedInt2),
    fieldNoTrie = new IntField("field"+Integer.MAX_VALUE, 0, storedIntNone),
    ascfield8 = new IntField("ascfield8", 0, unstoredInt8),
    ascfield4 = new IntField("ascfield4", 0, unstoredInt4),
    ascfield2 = new IntField("ascfield2", 0, unstoredInt2);
  
  Document doc = new Document();
  // add fields, that have a distance to test general functionality
  doc.add(field8); doc.add(field4); doc.add(field2); doc.add(fieldNoTrie);
  // add ascending fields with a distance of 1, beginning at -noDocs/2 to test the correct splitting of range and inclusive/exclusive
  doc.add(ascfield8); doc.add(ascfield4); doc.add(ascfield2);
  
  // Add a series of noDocs docs with increasing int values
  for (int l=0; l<noDocs; l++) {
    int val=distance*l+startOffset;
    field8.setIntValue(val);
    field4.setIntValue(val);
    field2.setIntValue(val);
    fieldNoTrie.setIntValue(val);

    val=l-(noDocs/2);
    ascfield8.setIntValue(val);
    ascfield4.setIntValue(val);
    ascfield2.setIntValue(val);
    writer.addDocument(doc);
  }

  reader = writer.getReader();
  searcher=newSearcher(reader);
  writer.close();
}
 

import org.apache.lucene.document.FieldType; //导入方法依赖的package包/类
@BeforeClass
public static void beforeClass() throws Exception {
  noDocs = atLeast(4096);
  distance = (1L << 60) / noDocs;
  directory = newDirectory();
  RandomIndexWriter writer = new RandomIndexWriter(random(), directory,
      newIndexWriterConfig(new MockAnalyzer(random()))
      .setMaxBufferedDocs(TestUtil.nextInt(random(), 100, 1000))
      .setMergePolicy(newLogMergePolicy()));

  final FieldType storedLong = new FieldType(LongField.TYPE_NOT_STORED);
  storedLong.setStored(true);
  storedLong.freeze();

  final FieldType storedLong8 = new FieldType(storedLong);
  storedLong8.setNumericPrecisionStep(8);

  final FieldType storedLong4 = new FieldType(storedLong);
  storedLong4.setNumericPrecisionStep(4);

  final FieldType storedLong6 = new FieldType(storedLong);
  storedLong6.setNumericPrecisionStep(6);

  final FieldType storedLong2 = new FieldType(storedLong);
  storedLong2.setNumericPrecisionStep(2);

  final FieldType storedLongNone = new FieldType(storedLong);
  storedLongNone.setNumericPrecisionStep(Integer.MAX_VALUE);

  final FieldType unstoredLong = LongField.TYPE_NOT_STORED;

  final FieldType unstoredLong8 = new FieldType(unstoredLong);
  unstoredLong8.setNumericPrecisionStep(8);

  final FieldType unstoredLong6 = new FieldType(unstoredLong);
  unstoredLong6.setNumericPrecisionStep(6);

  final FieldType unstoredLong4 = new FieldType(unstoredLong);
  unstoredLong4.setNumericPrecisionStep(4);

  final FieldType unstoredLong2 = new FieldType(unstoredLong);
  unstoredLong2.setNumericPrecisionStep(2);

  LongField
    field8 = new LongField("field8", 0L, storedLong8),
    field6 = new LongField("field6", 0L, storedLong6),
    field4 = new LongField("field4", 0L, storedLong4),
    field2 = new LongField("field2", 0L, storedLong2),
    fieldNoTrie = new LongField("field"+Integer.MAX_VALUE, 0L, storedLongNone),
    ascfield8 = new LongField("ascfield8", 0L, unstoredLong8),
    ascfield6 = new LongField("ascfield6", 0L, unstoredLong6),
    ascfield4 = new LongField("ascfield4", 0L, unstoredLong4),
    ascfield2 = new LongField("ascfield2", 0L, unstoredLong2);

  Document doc = new Document();
  // add fields, that have a distance to test general functionality
  doc.add(field8); doc.add(field6); doc.add(field4); doc.add(field2); doc.add(fieldNoTrie);
  // add ascending fields with a distance of 1, beginning at -noDocs/2 to test the correct splitting of range and inclusive/exclusive
  doc.add(ascfield8); doc.add(ascfield6); doc.add(ascfield4); doc.add(ascfield2);
  
  // Add a series of noDocs docs with increasing long values, by updating the fields
  for (int l=0; l<noDocs; l++) {
    long val=distance*l+startOffset;
    field8.setLongValue(val);
    field6.setLongValue(val);
    field4.setLongValue(val);
    field2.setLongValue(val);
    fieldNoTrie.setLongValue(val);

    val=l-(noDocs/2);
    ascfield8.setLongValue(val);
    ascfield6.setLongValue(val);
    ascfield4.setLongValue(val);
    ascfield2.setLongValue(val);
    writer.addDocument(doc);
  }
  reader = writer.getReader();
  searcher=newSearcher(reader);
  writer.close();
}
 

import org.apache.lucene.document.FieldType; //导入方法依赖的package包/类
@Override
public IndexableField createField(SchemaField field, Object value, float boost) {
  boolean indexed = field.indexed();
  boolean stored = field.stored();
  boolean docValues = field.hasDocValues();

  if (!indexed && !stored && !docValues) {
    if (log.isTraceEnabled())
      log.trace("Ignoring unindexed/unstored field: " + field);
    return null;
  }
  
  FieldType ft = new FieldType();
  ft.setStored(stored);
  ft.setTokenized(true);
  ft.setIndexed(indexed);
  ft.setOmitNorms(field.omitNorms());
  ft.setIndexOptions(getIndexOptions(field, value.toString()));

  switch (type) {
    case INTEGER:
      ft.setNumericType(NumericType.INT);
      break;
    case FLOAT:
      ft.setNumericType(NumericType.FLOAT);
      break;
    case LONG:
      ft.setNumericType(NumericType.LONG);
      break;
    case DOUBLE:
      ft.setNumericType(NumericType.DOUBLE);
      break;
    case DATE:
      ft.setNumericType(NumericType.LONG);
      break;
    default:
      throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Unknown type for trie field: " + type);
  }
  ft.setNumericPrecisionStep(precisionStep);

  final org.apache.lucene.document.Field f;

  switch (type) {
    case INTEGER:
      int i = (value instanceof Number)
        ? ((Number)value).intValue()
        : Integer.parseInt(value.toString());
      f = new org.apache.lucene.document.IntField(field.getName(), i, ft);
      break;
    case FLOAT:
      float fl = (value instanceof Number)
        ? ((Number)value).floatValue()
        : Float.parseFloat(value.toString());
      f = new org.apache.lucene.document.FloatField(field.getName(), fl, ft);
      break;
    case LONG:
      long l = (value instanceof Number)
        ? ((Number)value).longValue()
        : Long.parseLong(value.toString());
      f = new org.apache.lucene.document.LongField(field.getName(), l, ft);
      break;
    case DOUBLE:
      double d = (value instanceof Number)
        ? ((Number)value).doubleValue()
        : Double.parseDouble(value.toString());
      f = new org.apache.lucene.document.DoubleField(field.getName(), d, ft);
      break;
    case DATE:
      Date date = (value instanceof Date)
        ? ((Date)value)
        : dateField.parseMath(null, value.toString());
      f = new org.apache.lucene.document.LongField(field.getName(), date.getTime(), ft);
      break;
    default:
      throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Unknown type for trie field: " + type);
  }

  f.setBoost(boost);
  return f;
}