Java 类org.apache.lucene.document.NumericDocValuesField 实例源码

private Engine.Index getIndex(final String id) {
    final String type = "test";
    final ParseContext.Document document = new ParseContext.Document();
    document.add(new TextField("test", "test", Field.Store.YES));
    final Field uidField = new Field("_uid", Uid.createUid(type, id), UidFieldMapper.Defaults.FIELD_TYPE);
    final Field versionField = new NumericDocValuesField("_version", Versions.MATCH_ANY);
    final SeqNoFieldMapper.SequenceID seqID = SeqNoFieldMapper.SequenceID.emptySeqID();
    document.add(uidField);
    document.add(versionField);
    document.add(seqID.seqNo);
    document.add(seqID.seqNoDocValue);
    document.add(seqID.primaryTerm);
    final BytesReference source = new BytesArray(new byte[] { 1 });
    final ParsedDocument doc =
        new ParsedDocument(versionField, seqID, id, type, null, Arrays.asList(document), source, XContentType.JSON, null);
    return new Engine.Index(new Term("_uid", doc.uid()), doc);
}

public void testNumericDocValues() throws IOException {
    testCase(new MatchAllDocsQuery(), iw -> {
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 1)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 2)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 1)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 2)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 1)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 2)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 1)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 2)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 1)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 2)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 1)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 2)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 1)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 2)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 1)));
        iw.addDocument(singleton(new NumericDocValuesField(FIELD_NAME, 2)));
    }, count -> assertEquals(24L, count.getValue(), 0d));
}

public void testSlowLogParsedDocumentPrinterSourceToLog() throws IOException {
    BytesReference source = JsonXContent.contentBuilder().startObject().field("foo", "bar").endObject().bytes();
    ParsedDocument pd = new ParsedDocument(new NumericDocValuesField("version", 1), SeqNoFieldMapper.SequenceID.emptySeqID(), "id",
            "test", null, null, source, XContentType.JSON, null);
    Index index = new Index("foo", "123");
    // Turning off document logging doesn't log source[]
    SlowLogParsedDocumentPrinter p = new SlowLogParsedDocumentPrinter(index, pd, 10, true, 0);
    assertThat(p.toString(), not(containsString("source[")));

    // Turning on document logging logs the whole thing
    p = new SlowLogParsedDocumentPrinter(index, pd, 10, true, Integer.MAX_VALUE);
    assertThat(p.toString(), containsString("source[{\"foo\":\"bar\"}]"));

    // And you can truncate the source
    p = new SlowLogParsedDocumentPrinter(index, pd, 10, true, 3);
    assertThat(p.toString(), containsString("source[{\"f]"));

    // And you can truncate the source
    p = new SlowLogParsedDocumentPrinter(index, pd, 10, true, 3);
    assertThat(p.toString(), containsString("source[{\"f]"));
    assertThat(p.toString(), startsWith("[foo/123] took"));
}

/** 
 * test version lookup actually works
 */
public void testSimple() throws Exception {
    Directory dir = newDirectory();
    IndexWriter writer = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
    Document doc = new Document();
    doc.add(new Field(UidFieldMapper.NAME, "6", UidFieldMapper.Defaults.FIELD_TYPE));
    doc.add(new NumericDocValuesField(VersionFieldMapper.NAME, 87));
    writer.addDocument(doc);
    DirectoryReader reader = DirectoryReader.open(writer);
    LeafReaderContext segment = reader.leaves().get(0);
    PerThreadIDAndVersionLookup lookup = new PerThreadIDAndVersionLookup(segment.reader());
    // found doc
    DocIdAndVersion result = lookup.lookup(new BytesRef("6"), null, segment);
    assertNotNull(result);
    assertEquals(87, result.version);
    assertEquals(0, result.docId);
    // not found doc
    assertNull(lookup.lookup(new BytesRef("7"), null, segment));
    // deleted doc
    assertNull(lookup.lookup(new BytesRef("6"), new Bits.MatchNoBits(1), segment));
    reader.close();
    writer.close();
    dir.close();
}

/** Test that version map cache works, is evicted on close, etc */
public void testCache() throws Exception {
    int size = Versions.lookupStates.size();

    Directory dir = newDirectory();
    IndexWriter writer = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
    Document doc = new Document();
    doc.add(new Field(UidFieldMapper.NAME, "6", UidFieldMapper.Defaults.FIELD_TYPE));
    doc.add(new NumericDocValuesField(VersionFieldMapper.NAME, 87));
    writer.addDocument(doc);
    DirectoryReader reader = DirectoryReader.open(writer);
    // should increase cache size by 1
    assertEquals(87, Versions.loadVersion(reader, new Term(UidFieldMapper.NAME, "6")));
    assertEquals(size+1, Versions.lookupStates.size());
    // should be cache hit
    assertEquals(87, Versions.loadVersion(reader, new Term(UidFieldMapper.NAME, "6")));
    assertEquals(size+1, Versions.lookupStates.size());

    reader.close();
    writer.close();
    // core should be evicted from the map
    assertEquals(size, Versions.lookupStates.size());
    dir.close();
}

/** Test that version map cache behaves properly with a filtered reader */
public void testCacheFilterReader() throws Exception {
    int size = Versions.lookupStates.size();

    Directory dir = newDirectory();
    IndexWriter writer = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
    Document doc = new Document();
    doc.add(new Field(UidFieldMapper.NAME, "6", UidFieldMapper.Defaults.FIELD_TYPE));
    doc.add(new NumericDocValuesField(VersionFieldMapper.NAME, 87));
    writer.addDocument(doc);
    DirectoryReader reader = DirectoryReader.open(writer);
    assertEquals(87, Versions.loadVersion(reader, new Term(UidFieldMapper.NAME, "6")));
    assertEquals(size+1, Versions.lookupStates.size());
    // now wrap the reader
    DirectoryReader wrapped = ElasticsearchDirectoryReader.wrap(reader, new ShardId("bogus", "_na_", 5));
    assertEquals(87, Versions.loadVersion(wrapped, new Term(UidFieldMapper.NAME, "6")));
    // same size map: core cache key is shared
    assertEquals(size+1, Versions.lookupStates.size());

    reader.close();
    writer.close();
    // core should be evicted from the map
    assertEquals(size, Versions.lookupStates.size());
    dir.close();
}

@Override
public Document transform(final Example input) throws TransformException {
    final Document doc = new Document();

    doc.add(new Field(ExampleField.ID.getName(), input.getId(), StringField.TYPE_STORED));
    doc.add(new SortedDocValuesField(ExampleField.ID.getName(), new BytesRef(input.getId())));

    doc.add(new Field(ExampleField.TITLE.getName(), input.getTitle(), TextField.TYPE_STORED));
    doc.add(new Field(ExampleField.BODY.getName(), input.getBody(), TextField.TYPE_STORED));

    doc.add(new Field(ExampleField.COLOR.getName(), input.getColor(), StringField.TYPE_STORED));
    doc.add(new SortedSetDocValuesFacetField(ExampleField.COLOR.getName(), input.getColor()));

    final Date createDate = input.getCreateDate();
    doc.add(new NumericDocValuesField(ExampleField.CREATE_DATE.getName(), createDate.getTime()));
    doc.add(new StoredField(ExampleField.CREATE_DATE.getName(), createDate.getTime()));

    return doc;
}

/** Build the example index. */
private void index() throws IOException {
  IndexWriter indexWriter = new IndexWriter(indexDir, new IndexWriterConfig(FacetExamples.EXAMPLES_VER, 
      new WhitespaceAnalyzer()));

  // Writes facet ords to a separate directory from the main index
  DirectoryTaxonomyWriter taxoWriter = new DirectoryTaxonomyWriter(taxoDir);

  Document doc = new Document();
  doc.add(new TextField("c", "foo bar", Store.NO));
  doc.add(new NumericDocValuesField("popularity", 5L));
  doc.add(new FacetField("A", "B"));
  indexWriter.addDocument(config.build(taxoWriter, doc));

  doc = new Document();
  doc.add(new TextField("c", "foo foo bar", Store.NO));
  doc.add(new NumericDocValuesField("popularity", 3L));
  doc.add(new FacetField("A", "C"));
  indexWriter.addDocument(config.build(taxoWriter, doc));

  indexWriter.close();
  taxoWriter.close();
}

/** Build the example index. */
public void index() throws IOException {
  IndexWriter indexWriter = new IndexWriter(indexDir, new IndexWriterConfig(FacetExamples.EXAMPLES_VER, 
      new WhitespaceAnalyzer()));

  // Add documents with a fake timestamp, 1000 sec before
  // "now", 2000 sec before "now", ...:
  for(int i=0;i<100;i++) {
    Document doc = new Document();
    long then = nowSec - i * 1000;
    // Add as doc values field, so we can compute range facets:
    doc.add(new NumericDocValuesField("timestamp", then));
    // Add as numeric field so we can drill-down:
    doc.add(new LongField("timestamp", then, Field.Store.NO));
    indexWriter.addDocument(doc);
  }

  // Open near-real-time searcher
  searcher = new IndexSearcher(DirectoryReader.open(indexWriter, true));
  indexWriter.close();
}

@Override
public void setUp() throws Exception {
  super.setUp();
  dir = newDirectory();
  RandomIndexWriter iw = new RandomIndexWriter(random(), dir);
  int numDocs = TestUtil.nextInt(random(), 2049, 4000);
  for (int i = 0; i < numDocs; i++) {
    Document document = new Document();
    document.add(newTextField("english", English.intToEnglish(i), Field.Store.NO));
    document.add(newTextField("oddeven", (i % 2 == 0) ? "even" : "odd", Field.Store.NO));
    document.add(newStringField("byte", "" + ((byte) random().nextInt()), Field.Store.NO));
    document.add(newStringField("short", "" + ((short) random().nextInt()), Field.Store.NO));
    document.add(new IntField("int", random().nextInt(), Field.Store.NO));
    document.add(new LongField("long", random().nextLong(), Field.Store.NO));

    document.add(new FloatField("float", random().nextFloat(), Field.Store.NO));
    document.add(new DoubleField("double", random().nextDouble(), Field.Store.NO));

    document.add(new NumericDocValuesField("intdocvalues", random().nextInt()));
    document.add(new FloatDocValuesField("floatdocvalues", random().nextFloat()));
    iw.addDocument(document);
  }
  reader = iw.getReader();
  iw.close();
  searcher = newSearcher(reader);
}

private Document buildDocument(BytesRef text, Set<BytesRef> contexts, long weight, BytesRef payload) throws IOException {
  String textString = text.utf8ToString();
  Document doc = new Document();
  FieldType ft = getTextFieldType();
  doc.add(new Field(TEXT_FIELD_NAME, textString, ft));
  doc.add(new Field("textgrams", textString, ft));
  doc.add(new StringField(EXACT_TEXT_FIELD_NAME, textString, Field.Store.NO));
  doc.add(new BinaryDocValuesField(TEXT_FIELD_NAME, text));
  doc.add(new NumericDocValuesField("weight", weight));
  if (payload != null) {
    doc.add(new BinaryDocValuesField("payloads", payload));
  }
  if (contexts != null) {
    for(BytesRef context : contexts) {
      // TODO: if we had a BinaryTermField we could fix
      // this "must be valid ut8f" limitation:
      doc.add(new StringField(CONTEXTS_FIELD_NAME, context.utf8ToString(), Field.Store.NO));
      doc.add(new SortedSetDocValuesField(CONTEXTS_FIELD_NAME, context));
    }
  }
  return doc;
}

private Map<String, Document> generateIndexDocuments(int ndocs) {
  Map<String, Document> docs = new HashMap<>();
  for(int i = 0; i < ndocs ; i++) {
    Field field = new TextField(FIELD_NAME, "field_" + i, Field.Store.YES);
    Field payload = new StoredField(PAYLOAD_FIELD_NAME, new BytesRef("payload_" + i));
    Field weight1 = new NumericDocValuesField(WEIGHT_FIELD_NAME_1, 10 + i);
    Field weight2 = new NumericDocValuesField(WEIGHT_FIELD_NAME_2, 20 + i);
    Field weight3 = new NumericDocValuesField(WEIGHT_FIELD_NAME_3, 30 + i);
    Field contexts = new StoredField(CONTEXTS_FIELD_NAME, new BytesRef("ctx_"  + i + "_0"));
    Document doc = new Document();
    doc.add(field);
    doc.add(payload);
    doc.add(weight1);
    doc.add(weight2);
    doc.add(weight3);
    doc.add(contexts);
    for(int j = 1; j < atLeast(3); j++) {
      contexts.setBytesValue(new BytesRef("ctx_" + i + "_" + j));
      doc.add(contexts);
    }
    docs.put(field.stringValue(), doc);
  }
  return docs;
}

public void testNoScore() throws Exception {
  Directory indexDir = newDirectory();
  Directory taxoDir = newDirectory();

  DirectoryTaxonomyWriter taxoWriter = new DirectoryTaxonomyWriter(taxoDir);
  IndexWriter iw = new IndexWriter(indexDir, newIndexWriterConfig(new MockAnalyzer(random())));
  FacetsConfig config = new FacetsConfig();
  for (int i = 0; i < 4; i++) {
    Document doc = new Document();
    doc.add(new NumericDocValuesField("price", (i+1)));
    doc.add(new FacetField("a", Integer.toString(i % 2)));
    iw.addDocument(config.build(taxoWriter, doc));
  }

  DirectoryReader r = DirectoryReader.open(iw, true);
  DirectoryTaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoWriter);

  FacetsCollector sfc = new FacetsCollector();
  newSearcher(r).search(new MatchAllDocsQuery(), sfc);
  Facets facets = new TaxonomyFacetSumValueSource(taxoReader, config, sfc, new LongFieldSource("price"));
  assertEquals("dim=a path=[] value=10.0 childCount=2\n  1 (6.0)\n  0 (4.0)\n", facets.getTopChildren(10, "a").toString());

  IOUtils.close(taxoWriter, iw, taxoReader, taxoDir, r, indexDir);
}

public void testDateCompression() throws IOException {
  final Directory dir = new RAMDirectory();
  final IndexWriterConfig iwc = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random()));
  final IndexWriter iwriter = new IndexWriter(dir, iwc);

  final long base = 13; // prime
  final long day = 1000L * 60 * 60 * 24;

  final Document doc = new Document();
  final NumericDocValuesField dvf = new NumericDocValuesField("dv", 0);
  doc.add(dvf);
  for (int i = 0; i < 300; ++i) {
    dvf.setLongValue(base + random().nextInt(1000) * day);
    iwriter.addDocument(doc);
  }
  iwriter.forceMerge(1);
  final long size1 = dirSize(dir);
  for (int i = 0; i < 50; ++i) {
    dvf.setLongValue(base + random().nextInt(1000) * day);
    iwriter.addDocument(doc);
  }
  iwriter.forceMerge(1);
  final long size2 = dirSize(dir);
  // make sure the new longs costed less than if they had only been packed
  assertTrue(size2 < size1 + (PackedInts.bitsRequired(day) * 50) / 8);
}

public void testSingleBigValueCompression() throws IOException {
  final Directory dir = new RAMDirectory();
  final IndexWriterConfig iwc = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random()));
  final IndexWriter iwriter = new IndexWriter(dir, iwc);

  final Document doc = new Document();
  final NumericDocValuesField dvf = new NumericDocValuesField("dv", 0);
  doc.add(dvf);
  for (int i = 0; i < 20000; ++i) {
    dvf.setLongValue(i & 1023);
    iwriter.addDocument(doc);
  }
  iwriter.forceMerge(1);
  final long size1 = dirSize(dir);
  dvf.setLongValue(Long.MAX_VALUE);
  iwriter.addDocument(doc);
  iwriter.forceMerge(1);
  final long size2 = dirSize(dir);
  // make sure the new value did not grow the bpv for every other value
  assertTrue(size2 < size1 + (20000 * (63 - 10)) / 8);
}

public void testDisableImpersonation() throws Exception {
  Codec[] oldCodecs = new Codec[] { new Lucene40RWCodec(), new Lucene41RWCodec(), new Lucene42RWCodec() };
  Directory dir = newDirectory();
  IndexWriterConfig conf = newIndexWriterConfig(new MockAnalyzer(random()));
  conf.setCodec(oldCodecs[random().nextInt(oldCodecs.length)]);
  IndexWriter writer = new IndexWriter(dir, conf);

  Document doc = new Document();
  doc.add(new StringField("f", "bar", Store.YES));
  doc.add(new NumericDocValuesField("n", 18L));
  writer.addDocument(doc);

  OLD_FORMAT_IMPERSONATION_IS_ACTIVE = false;
  try {
    writer.close();
    fail("should not have succeeded to impersonate an old format!");
  } catch (UnsupportedOperationException e) {
    writer.rollback();
  } finally {
    OLD_FORMAT_IMPERSONATION_IS_ACTIVE = true;
  }

  dir.close();
}

@Test
public void testUpdateSameDocMultipleTimes() throws Exception {
  Directory dir = newDirectory();
  IndexWriterConfig conf = newIndexWriterConfig(new MockAnalyzer(random()));
  IndexWriter writer = new IndexWriter(dir, conf);

  Document doc = new Document();
  doc.add(new StringField("key", "doc", Store.NO));
  doc.add(new NumericDocValuesField("ndv", 5));
  writer.addDocument(doc); // flushed document
  writer.commit();
  writer.addDocument(doc); // in-memory document

  writer.updateNumericDocValue(new Term("key", "doc"), "ndv", 17L); // update existing field
  writer.updateNumericDocValue(new Term("key", "doc"), "ndv", 3L); // update existing field 2nd time in this commit
  writer.close();

  final DirectoryReader reader = DirectoryReader.open(dir);
  final AtomicReader r = SlowCompositeReaderWrapper.wrap(reader);
  NumericDocValues ndv = r.getNumericDocValues("ndv");
  for (int i = 0; i < r.maxDoc(); i++) {
    assertEquals(3, ndv.get(i));
  }
  reader.close();
  dir.close();
}

@Test
public void testUpdateNumericDVFieldWithSameNameAsPostingField() throws Exception {
  // this used to fail because FieldInfos.Builder neglected to update
  // globalFieldMaps.docValueTypes map
  Directory dir = newDirectory();
  IndexWriterConfig conf = newIndexWriterConfig(new MockAnalyzer(random()));
  IndexWriter writer = new IndexWriter(dir, conf);

  Document doc = new Document();
  doc.add(new StringField("f", "mock-value", Store.NO));
  doc.add(new NumericDocValuesField("f", 5));
  writer.addDocument(doc);
  writer.commit();
  writer.updateNumericDocValue(new Term("f", "mock-value"), "f", 17L);
  writer.close();

  DirectoryReader r = DirectoryReader.open(dir);
  NumericDocValues ndv = r.leaves().get(0).reader().getNumericDocValues("f");
  assertEquals(17, ndv.get(0));
  r.close();

  dir.close();
}

@Test
public void testUpdatesOrder() throws Exception {
  Directory dir = newDirectory();
  IndexWriterConfig conf = newIndexWriterConfig(new MockAnalyzer(random()));
  IndexWriter writer = new IndexWriter(dir, conf);

  Document doc = new Document();
  doc.add(new StringField("upd", "t1", Store.NO));
  doc.add(new StringField("upd", "t2", Store.NO));
  doc.add(new NumericDocValuesField("f1", 1L));
  doc.add(new NumericDocValuesField("f2", 1L));
  writer.addDocument(doc);
  writer.updateNumericDocValue(new Term("upd", "t1"), "f1", 2L); // update f1 to 2
  writer.updateNumericDocValue(new Term("upd", "t1"), "f2", 2L); // update f2 to 2
  writer.updateNumericDocValue(new Term("upd", "t2"), "f1", 3L); // update f1 to 3
  writer.updateNumericDocValue(new Term("upd", "t2"), "f2", 3L); // update f2 to 3
  writer.updateNumericDocValue(new Term("upd", "t1"), "f1", 4L); // update f1 to 4 (but not f2)
  writer.close();

  DirectoryReader reader = DirectoryReader.open(dir);
  assertEquals(4, reader.leaves().get(0).reader().getNumericDocValues("f1").get(0));
  assertEquals(3, reader.leaves().get(0).reader().getNumericDocValues("f2").get(0));
  reader.close();

  dir.close();
}

@Test
public void testUpdateAllDeletedSegment() throws Exception {
  Directory dir = newDirectory();
  IndexWriterConfig conf = newIndexWriterConfig(new MockAnalyzer(random()));
  IndexWriter writer = new IndexWriter(dir, conf);

  Document doc = new Document();
  doc.add(new StringField("id", "doc", Store.NO));
  doc.add(new NumericDocValuesField("f1", 1L));
  writer.addDocument(doc);
  writer.addDocument(doc);
  writer.commit();
  writer.deleteDocuments(new Term("id", "doc")); // delete all docs in the first segment
  writer.addDocument(doc);
  writer.updateNumericDocValue(new Term("id", "doc"), "f1", 2L);
  writer.close();

  DirectoryReader reader = DirectoryReader.open(dir);
  assertEquals(1, reader.leaves().size());
  assertEquals(2L, reader.leaves().get(0).reader().getNumericDocValues("f1").get(0));
  reader.close();

  dir.close();
}

@Test
public void testUpdateTwoNonexistingTerms() throws Exception {
  Directory dir = newDirectory();
  IndexWriterConfig conf = newIndexWriterConfig(new MockAnalyzer(random()));
  IndexWriter writer = new IndexWriter(dir, conf);

  Document doc = new Document();
  doc.add(new StringField("id", "doc", Store.NO));
  doc.add(new NumericDocValuesField("f1", 1L));
  writer.addDocument(doc);
  // update w/ multiple nonexisting terms in same field
  writer.updateNumericDocValue(new Term("c", "foo"), "f1", 2L);
  writer.updateNumericDocValue(new Term("c", "bar"), "f1", 2L);
  writer.close();

  DirectoryReader reader = DirectoryReader.open(dir);
  assertEquals(1, reader.leaves().size());
  assertEquals(1L, reader.leaves().get(0).reader().getNumericDocValues("f1").get(0));
  reader.close();

  dir.close();
}

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();
}

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();
}

public void testDifferentTypedDocValuesField2() 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 SortedDocValuesField("field", new BytesRef("hello")));
  try {
    w.addDocument(doc);
    fail("didn't hit expected exception");
  } catch (IllegalArgumentException iae) {
    // expected
  }
  DirectoryReader r = w.getReader();
  assertEquals(17, getOnlySegmentReader(r).getNumericDocValues("field").get(0));
  r.close();
  w.close();
  d.close();
}

public void testMixedTypesSameDocument() throws Exception {
  Directory dir = newDirectory();
  IndexWriter w = new IndexWriter(dir, newIndexWriterConfig(new MockAnalyzer(random())));
  w.addDocument(new Document());

  Document doc = new Document();
  doc.add(new NumericDocValuesField("foo", 0));
  doc.add(new SortedDocValuesField("foo", new BytesRef("hello")));
  try {
    w.addDocument(doc);
    fail("didn't hit expected exception");
  } catch (IllegalArgumentException iae) {
    // expected
  }
  IndexReader ir = w.getReader();
  assertEquals(1, ir.numDocs());
  ir.close();
  w.close();
  dir.close();
}

public void testMixedTypesDifferentDocuments() throws Exception {
  Directory dir = newDirectory();
  IndexWriter w = new IndexWriter(dir, newIndexWriterConfig(new MockAnalyzer(random())));
  Document doc = new Document();
  doc.add(new NumericDocValuesField("foo", 0));
  w.addDocument(doc);

  doc = new Document();
  doc.add(new SortedDocValuesField("foo", new BytesRef("hello")));
  try {
    w.addDocument(doc);
    fail("didn't hit expected exception");
  } catch (IllegalArgumentException iae) {
    // expected
  }
  IndexReader ir = w.getReader();
  assertEquals(1, ir.numDocs());
  ir.close();
  w.close();
  dir.close();
}

public void testAddNumericTwice() throws IOException {
  Analyzer analyzer = new MockAnalyzer(random());

  Directory directory = newDirectory();
  // we don't use RandomIndexWriter because it might add more docvalues than we expect !!!!1
  IndexWriterConfig iwc = newIndexWriterConfig(analyzer);
  iwc.setMergePolicy(newLogMergePolicy());
  IndexWriter iwriter = new IndexWriter(directory, iwc);
  Document doc = new Document();
  doc.add(new NumericDocValuesField("dv", 1));
  iwriter.addDocument(doc);

  doc.add(new NumericDocValuesField("dv", 2));
  try {
    iwriter.addDocument(doc);
    fail("didn't hit expected exception");
  } catch (IllegalArgumentException expected) {
    // expected
  }
  IndexReader ir = iwriter.getReader();
  assertEquals(1, ir.numDocs());
  ir.close();
  iwriter.close();
  directory.close();
}

public void testMixedTypesDifferentSegments() throws Exception {
  Directory dir = newDirectory();
  IndexWriter w = new IndexWriter(dir, newIndexWriterConfig(new MockAnalyzer(random())));
  Document doc = new Document();
  doc.add(new NumericDocValuesField("foo", 0));
  w.addDocument(doc);
  w.commit();

  doc = new Document();
  doc.add(new SortedDocValuesField("foo", new BytesRef("hello")));
  try {
    w.addDocument(doc);
    fail("did not get expected exception");
  } catch (IllegalArgumentException iae) {
    // expected
  }
  w.close();
  dir.close();
}

public void testMixedTypesAfterReopenCreate() throws Exception {
  Directory dir = newDirectory();
  IndexWriter w = new IndexWriter(dir, newIndexWriterConfig(new MockAnalyzer(random())));
  Document doc = new Document();
  doc.add(new NumericDocValuesField("foo", 0));
  w.addDocument(doc);
  w.close();

  IndexWriterConfig iwc = newIndexWriterConfig(new MockAnalyzer(random()));
  iwc.setOpenMode(IndexWriterConfig.OpenMode.CREATE);
  w = new IndexWriter(dir, iwc);
  doc = new Document();
  w.addDocument(doc);
  w.close();
  dir.close();
}

public void testMixedTypesAfterReopenAppend1() throws Exception {
  Directory dir = newDirectory();
  IndexWriter w = new IndexWriter(dir, newIndexWriterConfig(new MockAnalyzer(random())));
  Document doc = new Document();
  doc.add(new NumericDocValuesField("foo", 0));
  w.addDocument(doc);
  w.close();

  w = new IndexWriter(dir, newIndexWriterConfig(new MockAnalyzer(random())));
  doc = new Document();
  doc.add(new SortedDocValuesField("foo", new BytesRef("hello")));
  try {
    w.addDocument(doc);
    fail("did not get expected exception");
  } catch (IllegalArgumentException iae) {
    // expected
  }
  w.close();
  dir.close();
}

public void testIllegalTypeChange() 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 SortedDocValuesField("dv", new BytesRef("foo")));
  try {
    writer.addDocument(doc);
    fail("did not hit exception");
  } catch (IllegalArgumentException iae) {
    // expected
  }
  IndexReader ir = writer.getReader();
  assertEquals(1, ir.numDocs());
  ir.close();
  writer.close();
  dir.close();
}

public void testIllegalTypeChangeAcrossSegments() 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);
  writer.close();

  conf = newIndexWriterConfig(new MockAnalyzer(random()));
  writer = new IndexWriter(dir, conf);
  doc = new Document();
  doc.add(new SortedDocValuesField("dv", new BytesRef("foo")));
  try {
    writer.addDocument(doc);
    fail("did not hit exception");
  } catch (IllegalArgumentException iae) {
    // expected
  }
  writer.close();
  dir.close();
}

public void testTypeChangeAfterCloseAndDeleteAll() 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);
  writer.close();

  conf = newIndexWriterConfig(new MockAnalyzer(random()));
  writer = new IndexWriter(dir, conf);
  writer.deleteAll();
  doc = new Document();
  doc.add(new SortedDocValuesField("dv", new BytesRef("foo")));
  writer.addDocument(doc);
  writer.close();
  dir.close();
}

public void testTypeChangeAfterOpenCreate() 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);
  writer.close();
  conf = newIndexWriterConfig(new MockAnalyzer(random()));
  conf.setOpenMode(IndexWriterConfig.OpenMode.CREATE);
  writer = new IndexWriter(dir, conf);
  doc = new Document();
  doc.add(new SortedDocValuesField("dv", new BytesRef("foo")));
  writer.addDocument(doc);
  writer.close();
  dir.close();
}

public void testTypeChangeViaAddIndexes() 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);
  writer.close();

  Directory dir2 = newDirectory();
  conf = newIndexWriterConfig(new MockAnalyzer(random()));
  writer = new IndexWriter(dir2, conf);
  doc = new Document();
  doc.add(new SortedDocValuesField("dv", new BytesRef("foo")));
  writer.addDocument(doc);
  try {
    writer.addIndexes(dir);
    fail("did not hit exception");
  } catch (IllegalArgumentException iae) {
    // expected
  }
  writer.close();

  dir.close();
  dir2.close();
}

public void testTypeChangeViaAddIndexes2() 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);
  writer.close();

  Directory dir2 = newDirectory();
  conf = newIndexWriterConfig(new MockAnalyzer(random()));
  writer = new IndexWriter(dir2, conf);
  writer.addIndexes(dir);
  doc = new Document();
  doc.add(new SortedDocValuesField("dv", new BytesRef("foo")));
  try {
    writer.addDocument(doc);
    fail("did not hit exception");
  } catch (IllegalArgumentException iae) {
    // expected
  }
  writer.close();
  dir2.close();
  dir.close();
}

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();
}

public void testSameFieldNameForPostingAndDocValue() throws Exception {
  // LUCENE-5192: FieldInfos.Builder neglected to update
  // globalFieldNumbers.docValuesType map if the field existed, resulting in
  // potentially adding the same field with different DV types.
  Directory dir = newDirectory();
  IndexWriterConfig conf = newIndexWriterConfig(new MockAnalyzer(random()));
  IndexWriter writer = new IndexWriter(dir, conf);

  Document doc = new Document();
  doc.add(new StringField("f", "mock-value", Store.NO));
  doc.add(new NumericDocValuesField("f", 5));
  writer.addDocument(doc);
  writer.commit();

  doc = new Document();
  doc.add(new BinaryDocValuesField("f", new BytesRef("mock")));
  try {
    writer.addDocument(doc);
    fail("should not have succeeded to add a field with different DV type than what already exists");
  } catch (IllegalArgumentException e) {
    writer.rollback();
  }

  dir.close();
}

@Override
protected void parseCreateField(ParseContext context, List<IndexableField> fields) throws IOException {
    // see InternalEngine.updateVersion to see where the real version value is set
    final Field version = new NumericDocValuesField(NAME, -1L);
    context.version(version);
    fields.add(version);
}

@Override
public void postParse(ParseContext context) throws IOException {
    // In the case of nested docs, let's fill nested docs with version=1 so that Lucene doesn't write a Bitset for documents
    // that don't have the field. This is consistent with the default value for efficiency.
    for (int i = 1; i < context.docs().size(); i++) {
        final Document doc = context.docs().get(i);
        doc.add(new NumericDocValuesField(NAME, 1L));
    }
}