Java FieldCache类代码示例

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
@Override
public FunctionValues getValues(Map context, AtomicReaderContext readerContext) throws IOException {
  final IndexReader topReader = ReaderUtil.getTopLevelContext(readerContext).reader();
  final AtomicReader r = SlowCompositeReaderWrapper.wrap(topReader);
  final int off = readerContext.docBase;

  final SortedDocValues sindex = FieldCache.DEFAULT.getTermsIndex(r, field);
  final int end = sindex.getValueCount();

  return new IntDocValues(this) {
   @Override
    public int intVal(int doc) {
      return (end - sindex.getOrd(doc+off) - 1);
    }
  };
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
@Override
protected CustomScoreProvider getCustomScoreProvider(AtomicReaderContext context) throws IOException {
  final FieldCache.Ints values = FieldCache.DEFAULT.getInts(context.reader(), INT_FIELD, false);
  return new CustomScoreProvider(context) {
    @Override
    public float customScore(int doc, float subScore, float valSrcScore) {
      assertTrue(doc <= context.reader().maxDoc());
      return values.get(doc);
    }
  };
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
@Override
public void setNextReader(AtomicReaderContext context) throws IOException {
  index = FieldCache.DEFAULT.getTermsIndex(context.reader(), groupField);

  // Clear ordSet and fill it with previous encountered groups that can occur in the current segment.
  ordSet.clear();
  for (BytesRef countedGroup : groups) {
    if (countedGroup == null) {
      ordSet.put(-1);
    } else {
      int ord = index.lookupTerm(countedGroup);
      if (ord >= 0) {
        ordSet.put(ord);
      }
    }
  }
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
@Override
public void setNextReader(AtomicReaderContext context) throws IOException {
  groupFieldTermIndex = FieldCache.DEFAULT.getTermsIndex(context.reader(), groupField);
  countFieldTermIndex = FieldCache.DEFAULT.getTermsIndex(context.reader(), countField);
  ordSet.clear();
  for (GroupCount group : groups) {
    int groupOrd = group.groupValue == null ? -1 : groupFieldTermIndex.lookupTerm(group.groupValue);
    if (group.groupValue != null && groupOrd < 0) {
      continue;
    }

    groupCounts[ordSet.put(groupOrd)] = group;
    group.ords = new int[group.uniqueValues.size()];
    Arrays.fill(group.ords, -2);
    int i = 0;
    for (BytesRef value : group.uniqueValues) {
      int countOrd = value == null ? -1 : countFieldTermIndex.lookupTerm(value);
      if (value == null || countOrd >= 0) {
        group.ords[i++] = countOrd;
      }
    }
  }
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
@Override
public Statement apply(final Statement s, final Description d) {
  return new Statement() {
    @Override
    public void evaluate() throws Throwable {
      s.evaluate();

      Throwable problem = null;
      try {
        LuceneTestCase.assertSaneFieldCaches(d.getDisplayName());
      } catch (Throwable t) {
        problem = t;
      }

      FieldCache.DEFAULT.purgeAllCaches();

      if (problem != null) {
        Rethrow.rethrow(problem);
      }
    }
  };
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
/**
 * Asserts that FieldCacheSanityChecker does not detect any
 * problems with FieldCache.DEFAULT.
 * <p>
 * If any problems are found, they are logged to System.err
 * (allong with the msg) when the Assertion is thrown.
 * </p>
 * <p>
 * This method is called by tearDown after every test method,
 * however IndexReaders scoped inside test methods may be garbage
 * collected prior to this method being called, causing errors to
 * be overlooked. Tests are encouraged to keep their IndexReaders
 * scoped at the class level, or to explicitly call this method
 * directly in the same scope as the IndexReader.
 * </p>
 *
 * @see org.apache.lucene.util.FieldCacheSanityChecker
 */
protected static void assertSaneFieldCaches(final String msg) {
  final CacheEntry[] entries = FieldCache.DEFAULT.getCacheEntries();
  Insanity[] insanity = null;
  try {
    try {
      insanity = FieldCacheSanityChecker.checkSanity(entries);
    } catch (RuntimeException e) {
      dumpArray(msg + ": FieldCache", entries, System.err);
      throw e;
    }

    assertEquals(msg + ": Insane FieldCache usage(s) found",
                 0, insanity.length);
    insanity = null;
  } finally {

    // report this in the event of any exception/failure
    // if no failure, then insanity will be null anyway
    if (null != insanity) {
      dumpArray(msg + ": Insane FieldCache usage(s)", insanity, System.err);
    }
  }
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
public void testMultiValuedDocValuesField() throws Exception {
  Directory d = newDirectory();
  RandomIndexWriter w = new RandomIndexWriter(random(), d);
  Document doc = new Document();
  Field f = new NumericDocValuesField("field", 17);
  doc.add(f);
  
  // add the doc
  w.addDocument(doc);
  
  // Index doc values are single-valued so we should not
  // be able to add same field more than once:
  doc.add(f);
  try {
    w.addDocument(doc);
    fail("didn't hit expected exception");
  } catch (IllegalArgumentException iae) {
    // expected
  }

  DirectoryReader r = w.getReader();
  w.close();
  assertEquals(17, FieldCache.DEFAULT.getInts(getOnlySegmentReader(r), "field", false).get(0));
  r.close();
  d.close();
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
public void testDifferentTypedDocValuesField() throws Exception {
  Directory d = newDirectory();
  RandomIndexWriter w = new RandomIndexWriter(random(), d);
  Document doc = new Document();
  doc.add(new NumericDocValuesField("field", 17));
  w.addDocument(doc);
  
  // Index doc values are single-valued so we should not
  // be able to add same field more than once:
  doc.add(new BinaryDocValuesField("field", new BytesRef("blah")));
  try {
    w.addDocument(doc);
    fail("didn't hit expected exception");
  } catch (IllegalArgumentException iae) {
    // expected
  }

  DirectoryReader r = w.getReader();
  w.close();
  assertEquals(17, FieldCache.DEFAULT.getInts(getOnlySegmentReader(r), "field", false).get(0));
  r.close();
  d.close();
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
public void testDocsWithField() throws Exception {
  Directory dir = newDirectory();
  IndexWriterConfig conf = newIndexWriterConfig(new MockAnalyzer(random()));
  IndexWriter writer = new IndexWriter(dir, conf);
  Document doc = new Document();
  doc.add(new NumericDocValuesField("dv", 0L));
  writer.addDocument(doc);

  doc = new Document();
  doc.add(new TextField("dv", "some text", Field.Store.NO));
  doc.add(new NumericDocValuesField("dv", 0L));
  writer.addDocument(doc);
  
  DirectoryReader r = writer.getReader();
  writer.close();

  AtomicReader subR = r.leaves().get(0).reader();
  assertEquals(2, subR.numDocs());

  Bits bits = FieldCache.DEFAULT.getDocsWithField(subR, "dv");
  assertTrue(bits.get(0));
  assertTrue(bits.get(1));
  r.close();
  dir.close();
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
public void testSanity() throws IOException {
  FieldCache cache = FieldCache.DEFAULT;
  cache.purgeAllCaches();

  cache.getDoubles(readerA, "theDouble", false);
  cache.getDoubles(readerA, "theDouble", FieldCache.DEFAULT_DOUBLE_PARSER, false);
  cache.getDoubles(readerAclone, "theDouble", FieldCache.DEFAULT_DOUBLE_PARSER, false);
  cache.getDoubles(readerB, "theDouble", FieldCache.DEFAULT_DOUBLE_PARSER, false);

  cache.getInts(readerX, "theInt", false);
  cache.getInts(readerX, "theInt", FieldCache.DEFAULT_INT_PARSER, false);

  // // // 

  Insanity[] insanity = 
    FieldCacheSanityChecker.checkSanity(cache.getCacheEntries());
  
  if (0 < insanity.length)
    dumpArray(getTestClass().getName() + "#" + getTestName() 
        + " INSANITY", insanity, System.err);

  assertEquals("shouldn't be any cache insanity", 0, insanity.length);
  cache.purgeAllCaches();
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
public void testInsanity1() throws IOException {
  FieldCache cache = FieldCache.DEFAULT;
  cache.purgeAllCaches();

  cache.getInts(readerX, "theInt", FieldCache.DEFAULT_INT_PARSER, false);
  cache.getTerms(readerX, "theInt", false);
  cache.getBytes(readerX, "theByte", false);

  // // // 

  Insanity[] insanity = 
    FieldCacheSanityChecker.checkSanity(cache.getCacheEntries());

  assertEquals("wrong number of cache errors", 1, insanity.length);
  assertEquals("wrong type of cache error", 
               InsanityType.VALUEMISMATCH,
               insanity[0].getType());
  assertEquals("wrong number of entries in cache error", 2,
               insanity[0].getCacheEntries().length);

  // we expect bad things, don't let tearDown complain about them
  cache.purgeAllCaches();
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
public void testInsanity2() throws IOException {
  FieldCache cache = FieldCache.DEFAULT;
  cache.purgeAllCaches();

  cache.getTerms(readerA, "theInt", false);
  cache.getTerms(readerB, "theInt", false);
  cache.getTerms(readerX, "theInt", false);

  cache.getBytes(readerX, "theByte", false);


  // // // 

  Insanity[] insanity = 
    FieldCacheSanityChecker.checkSanity(cache.getCacheEntries());
  
  assertEquals("wrong number of cache errors", 1, insanity.length);
  assertEquals("wrong type of cache error", 
               InsanityType.SUBREADER,
               insanity[0].getType());
  assertEquals("wrong number of entries in cache error", 3,
               insanity[0].getCacheEntries().length);

  // we expect bad things, don't let tearDown complain about them
  cache.purgeAllCaches();
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
@Override
public ValueSource getValueSource(SchemaField field, QParser qparser) {
  field.checkFieldCacheSource(qparser);
  switch (type) {
    case INTEGER:
      return new IntFieldSource( field.getName(), FieldCache.NUMERIC_UTILS_INT_PARSER );
    case FLOAT:
      return new FloatFieldSource( field.getName(), FieldCache.NUMERIC_UTILS_FLOAT_PARSER );
    case DATE:
      return new TrieDateFieldSource( field.getName(), FieldCache.NUMERIC_UTILS_LONG_PARSER );        
    case LONG:
      return new LongFieldSource( field.getName(), FieldCache.NUMERIC_UTILS_LONG_PARSER );
    case DOUBLE:
      return new DoubleFieldSource( field.getName(), FieldCache.NUMERIC_UTILS_DOUBLE_PARSER );
    default:
      throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Unknown type for trie field: " + field.name);
  }
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
/**
 * some platforms don't allow quote characters in filenames, so 
 * in addition to testExternalFieldValueSourceParser above, test a field 
 * name with quotes in it that does NOT use ExternalFileField
 * @see #testExternalFieldValueSourceParser
 */
@Test
public void testFieldValueSourceParser() {
  clearIndex();

  String field = "CoMpleX \" fieldName _f";
  String fieldAsFunc = "field(\"CoMpleX \\\" fieldName _f\")";

  float[] ids = {100,-4,0,10,25,5,77,1};

  createIndex(field, ids);

  // test identity (straight field value)
  singleTest(fieldAsFunc, "\0", 
             100,100,  -4,-4,  0,0,  10,10,  25,25,  5,5,  77,77,  1,1);
  singleTest(fieldAsFunc, "sqrt(\0)", 
             100,10,  25,5,  0,0,   1,1);
  singleTest(fieldAsFunc, "log(\0)",  1,0);

  FieldCache.DEFAULT.purgeAllCaches();   // avoid FC insanity    
}
 

import org.apache.lucene.search.FieldCache; //导入依赖的package包/类
@Test
public void testRandomFaceting() throws Exception {
  try {
    Random rand = random();
    int iter = atLeast(100);
    init();
    addMoreDocs(0);

    for (int i=0; i<iter; i++) {
      doFacetTests();

      if (rand.nextInt(100) < 5) {
        init();
      }

      addMoreDocs(rand.nextInt(indexSize) + 1);

      if (rand.nextInt(100) < 50) {
        deleteSomeDocs();
      }
    }
  } finally {
    FieldCache.DEFAULT.purgeAllCaches();   // avoid FC insanity
  }
}