Example usage for org.apache.lucene.index IndexWriter getReader

List of usage examples for org.apache.lucene.index IndexWriter getReader

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.index.*
  5. IndexWriter
  6. getReader

Introduction

In this page you can find the example usage for org.apache.lucene.index IndexWriter getReader.

Prototype

DirectoryReader getReader() throws IOException

Source Link

Usage

From source file:aos.lucene.search.msc.NearRealTimeTest.java

License:Apache License

public void testNearRealTime() throws Exception {
    Directory dir = new RAMDirectory();
    IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(Version.LUCENE_46),
            IndexWriter.MaxFieldLength.UNLIMITED);
    for (int i = 0; i < 10; i++) {
        Document doc = new Document();
        doc.add(new Field("id", "" + i, Field.Store.NO, Field.Index.NOT_ANALYZED_NO_NORMS));
        doc.add(new Field("text", "aaa", Field.Store.NO, Field.Index.ANALYZED));
        writer.addDocument(doc);//  ww  w.ja v  a  2  s  .  c o m
    }
    IndexReader reader = writer.getReader();
    IndexSearcher searcher = new IndexSearcher(reader);

    Query query = new TermQuery(new Term("text", "aaa"));
    TopDocs docs = searcher.search(query, 1);
    assertEquals(10, docs.totalHits);

    writer.deleteDocuments(new Term("id", "7"));

    Document doc = new Document();
    doc.add(new Field("id", "11", Field.Store.NO, Field.Index.NOT_ANALYZED_NO_NORMS));
    doc.add(new Field("text", "bbb", Field.Store.NO, Field.Index.ANALYZED));
    writer.addDocument(doc);

    IndexReader newReader = reader.reopen();
    assertFalse(reader == newReader);
    reader.close();
    searcher = new IndexSearcher(newReader);

    TopDocs hits = searcher.search(query, 10);
    assertEquals(9, hits.totalHits);

    query = new TermQuery(new Term("text", "bbb"));
    hits = searcher.search(query, 1);
    assertEquals(1, hits.totalHits);

    newReader.close();
    writer.close();
}

From source file:com.leavesfly.lia.admin.SearcherManager.java

License:Apache License

public SearcherManager(IndexWriter writer) throws IOException { //2
    this.writer = writer;
    currentSearcher = new IndexSearcher(writer.getReader()); //C
    warm(currentSearcher);//ww w.  jav a2 s.  com

    writer.setMergedSegmentWarmer( // 3
            new IndexWriter.IndexReaderWarmer() { // 3
                public void warm(IndexReader reader) throws IOException { // 3
                    SearcherManager.this.warm(new IndexSearcher(reader)); // 3
                } // 3
            }); // 3
}

From source file:com.leavesfly.lia.searching.NearRealTimeTest.java

License:Apache License

public void testNearRealTime() throws Exception {
    Directory dir = new RAMDirectory();
    IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(Version.LUCENE_30),
            IndexWriter.MaxFieldLength.UNLIMITED);
    for (int i = 0; i < 10; i++) {
        Document doc = new Document();
        doc.add(new Field("id", "" + i, Field.Store.NO, Field.Index.NOT_ANALYZED_NO_NORMS));
        doc.add(new Field("text", "aaa", Field.Store.NO, Field.Index.ANALYZED));
        writer.addDocument(doc);/* ww  w .ja v  a2  s . c o  m*/
    }
    IndexReader reader = writer.getReader(); // #1
    IndexSearcher searcher = new IndexSearcher(reader); // #A

    Query query = new TermQuery(new Term("text", "aaa"));
    TopDocs docs = searcher.search(query, 1);
    assertEquals(10, docs.totalHits); // #B

    writer.deleteDocuments(new Term("id", "7")); // #2

    Document doc = new Document(); // #3
    doc.add(new Field("id", // #3
            "11", // #3
            Field.Store.NO, // #3
            Field.Index.NOT_ANALYZED_NO_NORMS)); // #3
    doc.add(new Field("text", // #3
            "bbb", // #3
            Field.Store.NO, // #3
            Field.Index.ANALYZED)); // #3
    writer.addDocument(doc); // #3

    IndexReader newReader = reader.reopen(); // #4
    assertFalse(reader == newReader); // #5
    reader.close(); // #6
    searcher = new IndexSearcher(newReader);

    TopDocs hits = searcher.search(query, 10); // #7
    assertEquals(9, hits.totalHits); // #7

    query = new TermQuery(new Term("text", "bbb")); // #8
    hits = searcher.search(query, 1); // #8
    assertEquals(1, hits.totalHits); // #8

    newReader.close();
    writer.close();
}

From source file:lia.searching.NearRealTime.java

License:Apache License

public void testNearRealTime() throws Exception {
    Directory dir = new RAMDirectory();
    IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_46, new StandardAnalyzer(Version.LUCENE_45));
    IndexWriter writer = new IndexWriter(dir, iwc);
    for (int i = 0; i < 10; i++) {
        Document doc = new Document();
        doc.add(new LongField("id", i, Field.Store.NO));
        doc.add(new TextField("text", "aaa", Field.Store.NO));
        writer.addDocument(doc);//from w w  w. ja va  2  s  .c o  m
    }
    DirectoryReader reader = DirectoryReader.open(writer, true); // #1
    IndexSearcher searcher = new IndexSearcher(reader); // #A

    Query query = new TermQuery(new Term("text", "aaa"));
    TopDocs docs = searcher.search(query, 1);
    assertEquals(10, docs.totalHits); // #B

    writer.deleteDocuments(new Term("id", "7")); // #2
    IndexReader newReader = writer.getReader();

    if (r2 != null) {
        reader.close();
        reader = r2;
    } else {
        // recreate
        reader.close();
        reader = DirectoryReader.open(dir);
    }
    searcher = new IndexSearcher(reader); // #A
    docs = searcher.search(query, 10);
    assertEquals(9, docs.totalHits);
    /*    Document doc = new Document();                           // #3
        doc.add(new LongField("id",                                  // #3
              11,                                  // #3
              Field.Store.NO));   // #3
        doc.add(new TextField("text",                                // #3
              "bbb",                                 // #3
              Field.Store.NO));                // #3
        writer.addDocument(doc);                                 // #3
    */

    /*    searcher = new IndexSearcher(DirectoryReader.openIfChanged(reader, writer, true));              
            
        TopDocs hits = searcher.search(query, 10);               // #7
        assertEquals(9, hits.totalHits);                         // #7
    */
    query = new TermQuery(new Term("text", "bbb")); // #8
    TopDocs hits = searcher.search(query, 1); // #8
    assertEquals(1, hits.totalHits); // #8

    reader.close();
    writer.close();
}

From source file:net.sf.mmm.search.indexer.impl.lucene.LuceneSearchIndexer.java

License:Apache License

/**
 * This method performs the actual remove by {@link Term}.
 *
 * @see #removeByCustumId(String)//from w w w. j a va2  s. c om
 * @see #removeByUri(String, String)
 * @see IndexWriter#deleteDocuments(Term)
 *
 * @param term is the {@link Term} identifying the {@link SearchEntry entry/entries} to remove.
 * @return the number of removed {@link SearchEntry entries}.
 */
protected int remove(Term term) {

    try {
        IndexWriter writer = getIndexWriter();
        int count = writer.getReader().docFreq(term);
        if (count > 0) {
            writer.deleteDocuments(term);
        }
        return count;
    } catch (IOException e) {
        throw new SearchRemoveFailedException(e, term.field(), term.text());
    }
}

From source file:org.elasticsearch.deps.lucene.LuceneFieldCacheTests.java

License:Apache License

/**
 * A test that verifies that when using FieldCache for a field that has been added twice (under the same name)
 * to the document, returns the last one.
 *///from w w w .  j  ava  2  s .  c  o  m
@Test
public void testTwoFieldSameNameNumericFieldCache() throws Exception {
    Directory dir = new RAMDirectory();
    IndexWriter indexWriter = new IndexWriter(dir, Lucene.STANDARD_ANALYZER, true,
            IndexWriter.MaxFieldLength.UNLIMITED);

    Document doc = new Document();
    NumericField field = new NumericField("int1").setIntValue(1);
    doc.add(field);

    field = new NumericField("int1").setIntValue(2);
    doc.add(field);

    indexWriter.addDocument(doc);

    IndexReader reader = indexWriter.getReader();
    int[] ints = FieldCache.DEFAULT.getInts(reader, "int1");
    assertThat(ints.length, equalTo(1));
    assertThat(ints[0], equalTo(2));
}

From source file:org.elasticsearch.index.field.data.doubles.DoubleFieldDataTests.java

License:Apache License

@Test
public void intFieldDataTests() throws Exception {
    Directory dir = new RAMDirectory();
    IndexWriter indexWriter = new IndexWriter(dir, Lucene.STANDARD_ANALYZER, true,
            IndexWriter.MaxFieldLength.UNLIMITED);

    indexWriter.addDocument(doc().add(new NumericField("svalue").setDoubleValue(4))
            .add(new NumericField("mvalue").setDoubleValue(104)).build());

    indexWriter.addDocument(doc().add(new NumericField("svalue").setDoubleValue(3))
            .add(new NumericField("mvalue").setDoubleValue(104))
            .add(new NumericField("mvalue").setDoubleValue(105)).build());

    indexWriter.addDocument(doc().add(new NumericField("svalue").setDoubleValue(7)).build());

    indexWriter.addDocument(doc().add(new NumericField("mvalue").setDoubleValue(102)).build());

    indexWriter.addDocument(doc().add(new NumericField("svalue").setDoubleValue(4)).build());

    IndexReader reader = indexWriter.getReader();

    DoubleFieldData sFieldData = DoubleFieldData.load(reader, "svalue");
    DoubleFieldData mFieldData = DoubleFieldData.load(reader, "mvalue");

    assertThat(sFieldData.fieldName(), equalTo("svalue"));
    assertThat(sFieldData.multiValued(), equalTo(false));

    assertThat(mFieldData.fieldName(), equalTo("mvalue"));
    assertThat(mFieldData.multiValued(), equalTo(true));

    // svalue//from www . ja v  a2  s .  c o  m
    assertThat(sFieldData.hasValue(0), equalTo(true));
    assertThat(sFieldData.value(0), equalTo(4d));
    assertThat(sFieldData.docFieldData(0).getValue(), equalTo(4d));
    assertThat(sFieldData.values(0).length, equalTo(1));
    assertThat(sFieldData.values(0)[0], equalTo(4d));
    assertThat(sFieldData.docFieldData(0).getValues()[0], equalTo(4d));

    assertThat(sFieldData.hasValue(1), equalTo(true));
    assertThat(sFieldData.value(1), equalTo(3d));
    assertThat(sFieldData.docFieldData(1).getValue(), equalTo(3d));
    assertThat(sFieldData.values(1).length, equalTo(1));
    assertThat(sFieldData.values(1)[0], equalTo(3d));
    assertThat(sFieldData.docFieldData(1).getValues()[0], equalTo(3d));

    assertThat(sFieldData.hasValue(2), equalTo(true));
    assertThat(sFieldData.value(2), equalTo(7d));
    assertThat(sFieldData.docFieldData(2).getValue(), equalTo(7d));
    assertThat(sFieldData.values(2).length, equalTo(1));
    assertThat(sFieldData.values(2)[0], equalTo(7d));
    assertThat(sFieldData.docFieldData(2).getValues()[0], equalTo(7d));

    assertThat(sFieldData.hasValue(3), equalTo(false));
    assertThat(sFieldData.docFieldData(3).isEmpty(), equalTo(true));

    assertThat(sFieldData.hasValue(4), equalTo(true));
    assertThat(sFieldData.value(4), equalTo(4d));
    assertThat(sFieldData.values(4).length, equalTo(1));
    assertThat(sFieldData.values(4)[0], equalTo(4d));

    // check order is correct
    final ArrayList<Double> values = new ArrayList<Double>();
    sFieldData.forEachValue(new DoubleFieldData.ValueProc() {
        @Override
        public void onValue(double value) {
            values.add(value);
        }
    });
    assertThat(values.size(), equalTo(3));

    assertThat(values.get(0), equalTo(3d));
    assertThat(values.get(1), equalTo(4d));
    assertThat(values.get(2), equalTo(7d));

    // mvalue
    assertThat(mFieldData.hasValue(0), equalTo(true));
    assertThat(mFieldData.docFieldData(0).isEmpty(), equalTo(false));
    assertThat(mFieldData.value(0), equalTo(104d));
    assertThat(mFieldData.docFieldData(0).getValue(), equalTo(104d));
    assertThat(mFieldData.values(0).length, equalTo(1));
    assertThat(mFieldData.values(0)[0], equalTo(104d));
    assertThat(mFieldData.docFieldData(0).getValues()[0], equalTo(104d));

    assertThat(mFieldData.hasValue(1), equalTo(true));
    assertThat(mFieldData.value(1), equalTo(104d));
    assertThat(mFieldData.values(1).length, equalTo(2));
    assertThat(mFieldData.values(1)[0], equalTo(104d));
    assertThat(mFieldData.values(1)[1], equalTo(105d));

    assertThat(mFieldData.hasValue(2), equalTo(false));

    assertThat(mFieldData.hasValue(3), equalTo(true));
    assertThat(mFieldData.value(3), equalTo(102d));
    assertThat(mFieldData.values(3).length, equalTo(1));
    assertThat(mFieldData.values(3)[0], equalTo(102d));

    assertThat(mFieldData.hasValue(4), equalTo(false));

    indexWriter.close();

    // check order is correct
    values.clear();
    mFieldData.forEachValue(new DoubleFieldData.ValueProc() {
        @Override
        public void onValue(double value) {
            values.add(value);
        }
    });
    assertThat(values.size(), equalTo(3));

    assertThat(values.get(0), equalTo(102d));
    assertThat(values.get(1), equalTo(104d));
    assertThat(values.get(2), equalTo(105d));
}

From source file:org.elasticsearch.index.field.data.floats.FloatFieldDataTests.java

License:Apache License

@Test
public void intFieldDataTests() throws Exception {
    Directory dir = new RAMDirectory();
    IndexWriter indexWriter = new IndexWriter(dir, Lucene.STANDARD_ANALYZER, true,
            IndexWriter.MaxFieldLength.UNLIMITED);

    indexWriter.addDocument(doc().add(new NumericField("svalue").setFloatValue(4))
            .add(new NumericField("mvalue").setFloatValue(104)).build());

    indexWriter.addDocument(doc().add(new NumericField("svalue").setFloatValue(3))
            .add(new NumericField("mvalue").setFloatValue(104))
            .add(new NumericField("mvalue").setFloatValue(105)).build());

    indexWriter.addDocument(doc().add(new NumericField("svalue").setFloatValue(7)).build());

    indexWriter.addDocument(doc().add(new NumericField("mvalue").setFloatValue(102)).build());

    indexWriter.addDocument(doc().add(new NumericField("svalue").setFloatValue(4)).build());

    IndexReader reader = indexWriter.getReader();

    FloatFieldData sFieldData = FloatFieldData.load(reader, "svalue");
    FloatFieldData mFieldData = FloatFieldData.load(reader, "mvalue");

    assertThat(sFieldData.fieldName(), equalTo("svalue"));
    assertThat(sFieldData.multiValued(), equalTo(false));

    assertThat(mFieldData.fieldName(), equalTo("mvalue"));
    assertThat(mFieldData.multiValued(), equalTo(true));

    // svalue//from  w  w w.j  av  a 2 s .  c  o m
    assertThat(sFieldData.hasValue(0), equalTo(true));
    assertThat(sFieldData.docFieldData(0).isEmpty(), equalTo(false));
    assertThat(sFieldData.value(0), equalTo(4f));
    assertThat(sFieldData.docFieldData(0).getValue(), equalTo(4f));
    assertThat(sFieldData.values(0).length, equalTo(1));
    assertThat(sFieldData.docFieldData(0).getValues().length, equalTo(1));
    assertThat(sFieldData.docFieldData(0).getValues()[0], equalTo(4f));

    assertThat(sFieldData.hasValue(1), equalTo(true));
    assertThat(sFieldData.value(1), equalTo(3f));
    assertThat(sFieldData.values(1).length, equalTo(1));
    assertThat(sFieldData.values(1)[0], equalTo(3f));

    assertThat(sFieldData.hasValue(2), equalTo(true));
    assertThat(sFieldData.value(2), equalTo(7f));
    assertThat(sFieldData.values(2).length, equalTo(1));
    assertThat(sFieldData.values(2)[0], equalTo(7f));

    assertThat(sFieldData.hasValue(3), equalTo(false));

    assertThat(sFieldData.hasValue(4), equalTo(true));
    assertThat(sFieldData.value(4), equalTo(4f));
    assertThat(sFieldData.values(4).length, equalTo(1));
    assertThat(sFieldData.values(4)[0], equalTo(4f));

    // check order is correct
    final ArrayList<Float> values = new ArrayList<Float>();
    sFieldData.forEachValue(new FloatFieldData.ValueProc() {
        @Override
        public void onValue(float value) {
            values.add(value);
        }
    });
    assertThat(values.size(), equalTo(3));

    assertThat(values.get(0), equalTo(3f));
    assertThat(values.get(1), equalTo(4f));
    assertThat(values.get(2), equalTo(7f));

    // mvalue
    assertThat(mFieldData.hasValue(0), equalTo(true));
    assertThat(mFieldData.docFieldData(0).isEmpty(), equalTo(false));
    assertThat(mFieldData.value(0), equalTo(104f));
    assertThat(mFieldData.docFieldData(0).getValue(), equalTo(104f));
    assertThat(mFieldData.values(0).length, equalTo(1));
    assertThat(mFieldData.docFieldData(0).getValues().length, equalTo(1));
    assertThat(mFieldData.values(0)[0], equalTo(104f));
    assertThat(mFieldData.docFieldData(0).getValues()[0], equalTo(104f));

    assertThat(mFieldData.hasValue(1), equalTo(true));
    assertThat(mFieldData.value(1), equalTo(104f));
    assertThat(mFieldData.values(1).length, equalTo(2));
    assertThat(mFieldData.docFieldData(1).getValues().length, equalTo(2));
    assertThat(mFieldData.values(1)[0], equalTo(104f));
    assertThat(mFieldData.docFieldData(1).getValues()[0], equalTo(104f));
    assertThat(mFieldData.docFieldData(1).getValues()[1], equalTo(105f));

    assertThat(mFieldData.hasValue(2), equalTo(false));

    assertThat(mFieldData.hasValue(3), equalTo(true));
    assertThat(mFieldData.value(3), equalTo(102f));
    assertThat(mFieldData.values(3).length, equalTo(1));
    assertThat(mFieldData.values(3)[0], equalTo(102f));

    assertThat(mFieldData.hasValue(4), equalTo(false));

    indexWriter.close();

    // check order is correct
    values.clear();
    mFieldData.forEachValue(new FloatFieldData.ValueProc() {
        @Override
        public void onValue(float value) {
            values.add(value);
        }
    });
    assertThat(values.size(), equalTo(3));

    assertThat(values.get(0), equalTo(102f));
    assertThat(values.get(1), equalTo(104f));
    assertThat(values.get(2), equalTo(105f));
}

From source file:org.elasticsearch.index.field.data.ints.IntFieldDataTests.java

License:Apache License

@Test
public void intFieldDataTests() throws Exception {
    Directory dir = new RAMDirectory();
    IndexWriter indexWriter = new IndexWriter(dir,
            new IndexWriterConfig(Lucene.VERSION, Lucene.STANDARD_ANALYZER));

    indexWriter.addDocument(doc().add(new NumericField("svalue").setIntValue(4))
            .add(new NumericField("mvalue").setIntValue(104)).build());

    indexWriter.addDocument(doc().add(new NumericField("svalue").setIntValue(3))
            .add(new NumericField("mvalue").setIntValue(104)).add(new NumericField("mvalue").setIntValue(105))
            .build());/*  www.  ja  v  a2 s  .  co  m*/

    indexWriter.addDocument(doc().add(new NumericField("svalue").setIntValue(7)).build());

    indexWriter.addDocument(doc().add(new NumericField("mvalue").setIntValue(102)).build());

    indexWriter.addDocument(doc().add(new NumericField("svalue").setIntValue(4)).build());

    IndexReader reader = indexWriter.getReader();

    IntFieldData sFieldData = IntFieldData.load(reader, "svalue");
    IntFieldData mFieldData = IntFieldData.load(reader, "mvalue");

    assertThat(sFieldData.fieldName(), equalTo("svalue"));
    assertThat(sFieldData.multiValued(), equalTo(false));

    assertThat(mFieldData.fieldName(), equalTo("mvalue"));
    assertThat(mFieldData.multiValued(), equalTo(true));

    // svalue
    assertThat(sFieldData.hasValue(0), equalTo(true));
    assertThat(sFieldData.docFieldData(0).isEmpty(), equalTo(false));
    assertThat(sFieldData.value(0), equalTo(4));
    assertThat(sFieldData.docFieldData(0).getValue(), equalTo(4));
    assertThat(sFieldData.values(0).length, equalTo(1));
    assertThat(sFieldData.docFieldData(0).getValues().length, equalTo(1));
    assertThat(sFieldData.docFieldData(0).getValues()[0], equalTo(4));

    assertThat(sFieldData.hasValue(1), equalTo(true));
    assertThat(sFieldData.value(1), equalTo(3));
    assertThat(sFieldData.values(1).length, equalTo(1));
    assertThat(sFieldData.values(1)[0], equalTo(3));

    assertThat(sFieldData.hasValue(2), equalTo(true));
    assertThat(sFieldData.value(2), equalTo(7));
    assertThat(sFieldData.values(2).length, equalTo(1));
    assertThat(sFieldData.values(2)[0], equalTo(7));

    assertThat(sFieldData.hasValue(3), equalTo(false));

    assertThat(sFieldData.hasValue(4), equalTo(true));
    assertThat(sFieldData.value(4), equalTo(4));
    assertThat(sFieldData.values(4).length, equalTo(1));
    assertThat(sFieldData.values(4)[0], equalTo(4));

    // check order is correct
    final ArrayList<Integer> values = new ArrayList<Integer>();
    sFieldData.forEachValue(new IntFieldData.ValueProc() {
        @Override
        public void onValue(int value) {
            values.add(value);
        }
    });
    assertThat(values.size(), equalTo(3));

    assertThat(values.get(0), equalTo(3));
    assertThat(values.get(1), equalTo(4));
    assertThat(values.get(2), equalTo(7));

    // mvalue
    assertThat(mFieldData.hasValue(0), equalTo(true));
    assertThat(mFieldData.value(0), equalTo(104));
    assertThat(mFieldData.values(0).length, equalTo(1));
    assertThat(mFieldData.values(0)[0], equalTo(104));

    assertThat(mFieldData.hasValue(1), equalTo(true));
    assertThat(mFieldData.value(1), equalTo(104));
    assertThat(mFieldData.values(1).length, equalTo(2));
    assertThat(mFieldData.values(1)[0], equalTo(104));
    assertThat(mFieldData.values(1)[1], equalTo(105));

    assertThat(mFieldData.hasValue(2), equalTo(false));

    assertThat(mFieldData.hasValue(3), equalTo(true));
    assertThat(mFieldData.value(3), equalTo(102));
    assertThat(mFieldData.values(3).length, equalTo(1));
    assertThat(mFieldData.values(3)[0], equalTo(102));

    assertThat(mFieldData.hasValue(4), equalTo(false));

    indexWriter.close();

    // check order is correct
    values.clear();
    mFieldData.forEachValue(new IntFieldData.ValueProc() {
        @Override
        public void onValue(int value) {
            values.add(value);
        }
    });
    assertThat(values.size(), equalTo(3));
    assertThat(values.get(0), equalTo(102));
    assertThat(values.get(1), equalTo(104));
    assertThat(values.get(2), equalTo(105));
}

From source file:org.elasticsearch.index.field.data.longs.LongFieldDataTests.java

License:Apache License

@Test
public void intFieldDataTests() throws Exception {
    Directory dir = new RAMDirectory();
    IndexWriter indexWriter = new IndexWriter(dir, Lucene.STANDARD_ANALYZER, true,
            IndexWriter.MaxFieldLength.UNLIMITED);

    indexWriter.addDocument(doc().add(new NumericField("svalue").setLongValue(4))
            .add(new NumericField("mvalue").setLongValue(104)).build());

    indexWriter.addDocument(doc().add(new NumericField("svalue").setLongValue(3))
            .add(new NumericField("mvalue").setLongValue(104)).add(new NumericField("mvalue").setLongValue(105))
            .build());/*www  .j a  va2  s .c o m*/

    indexWriter.addDocument(doc().add(new NumericField("svalue").setLongValue(7)).build());

    indexWriter.addDocument(doc().add(new NumericField("mvalue").setLongValue(102)).build());

    indexWriter.addDocument(doc().add(new NumericField("svalue").setLongValue(4)).build());

    IndexReader reader = indexWriter.getReader();

    LongFieldData sFieldData = LongFieldData.load(reader, "svalue");
    LongFieldData mFieldData = LongFieldData.load(reader, "mvalue");

    assertThat(sFieldData.fieldName(), equalTo("svalue"));
    assertThat(sFieldData.multiValued(), equalTo(false));

    assertThat(mFieldData.fieldName(), equalTo("mvalue"));
    assertThat(mFieldData.multiValued(), equalTo(true));

    // svalue
    assertThat(sFieldData.hasValue(0), equalTo(true));
    assertThat(sFieldData.docFieldData(0).isEmpty(), equalTo(false));
    assertThat(sFieldData.value(0), equalTo(4l));
    assertThat(sFieldData.date(0).getMillis(), equalTo(4l));
    assertThat(sFieldData.docFieldData(0).getValue(), equalTo(4l));
    assertThat(sFieldData.values(0).length, equalTo(1));
    assertThat(sFieldData.docFieldData(0).getValues().length, equalTo(1));
    assertThat(sFieldData.values(0)[0], equalTo(4l));
    assertThat(sFieldData.dates(0)[0].getMillis(), equalTo(4l));
    assertThat(sFieldData.docFieldData(0).getValues()[0], equalTo(4l));

    assertThat(sFieldData.hasValue(1), equalTo(true));
    assertThat(sFieldData.value(1), equalTo(3l));
    assertThat(sFieldData.values(1).length, equalTo(1));
    assertThat(sFieldData.values(1)[0], equalTo(3l));

    assertThat(sFieldData.hasValue(2), equalTo(true));
    assertThat(sFieldData.value(2), equalTo(7l));
    assertThat(sFieldData.values(2).length, equalTo(1));
    assertThat(sFieldData.values(2)[0], equalTo(7l));

    assertThat(sFieldData.hasValue(3), equalTo(false));

    assertThat(sFieldData.hasValue(4), equalTo(true));
    assertThat(sFieldData.value(4), equalTo(4l));
    assertThat(sFieldData.values(4).length, equalTo(1));
    assertThat(sFieldData.values(4)[0], equalTo(4l));

    // check order is correct
    final ArrayList<Long> values = new ArrayList<Long>();
    sFieldData.forEachValue(new LongFieldData.ValueProc() {
        @Override
        public void onValue(long value) {
            values.add(value);
        }
    });
    assertThat(values.size(), equalTo(3));

    assertThat(values.get(0), equalTo(3l));
    assertThat(values.get(1), equalTo(4l));
    assertThat(values.get(2), equalTo(7l));

    // mvalue
    assertThat(mFieldData.hasValue(0), equalTo(true));
    assertThat(mFieldData.value(0), equalTo(104l));
    assertThat(mFieldData.values(0).length, equalTo(1));
    assertThat(mFieldData.values(0)[0], equalTo(104l));

    assertThat(mFieldData.hasValue(1), equalTo(true));
    assertThat(mFieldData.value(1), equalTo(104l));
    assertThat(mFieldData.date(1).getMillis(), equalTo(104l));
    assertThat(mFieldData.values(1).length, equalTo(2));
    assertThat(mFieldData.values(1)[0], equalTo(104l));
    assertThat(mFieldData.dates(1)[0].getMillis(), equalTo(104l));
    assertThat(mFieldData.values(1)[1], equalTo(105l));
    assertThat(mFieldData.dates(1)[1].getMillis(), equalTo(105l));

    assertThat(mFieldData.hasValue(2), equalTo(false));

    assertThat(mFieldData.hasValue(3), equalTo(true));
    assertThat(mFieldData.value(3), equalTo(102l));
    assertThat(mFieldData.values(3).length, equalTo(1));
    assertThat(mFieldData.values(3)[0], equalTo(102l));

    assertThat(mFieldData.hasValue(4), equalTo(false));

    indexWriter.close();

    // check order is correct
    values.clear();
    mFieldData.forEachValue(new LongFieldData.ValueProc() {
        @Override
        public void onValue(long value) {
            values.add(value);
        }
    });
    assertThat(values.size(), equalTo(3));

    assertThat(values.get(0), equalTo(102l));
    assertThat(values.get(1), equalTo(104l));
    assertThat(values.get(2), equalTo(105l));
}