Example usage for org.apache.lucene.index DirectoryReader open

List of usage examples for org.apache.lucene.index DirectoryReader open

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.index.*
  5. DirectoryReader
  6. open

Introduction

In this page you can find the example usage for org.apache.lucene.index DirectoryReader open.

Prototype

public static DirectoryReader open(final IndexCommit commit) throws IOException

Source Link

Document

Expert: returns an IndexReader reading the index in the given IndexCommit .

Usage

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

/**
 * Test {@link Filter} usage in combination with field restriction.
 *
 * @throws Exception//w w w.j a v a 2s.  c om
 */
@SuppressWarnings({ "AnonymousInnerClassMayBeStatic", "ImplicitNumericConversion" })
@Test
public void testBuilder_filter_and_field() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.ALL_FIELDS)) {
        final Query q = new TermQuery(new Term("f1", "document2field1"));
        final Filter f = new QueryWrapperFilter(q);
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).queryFilter(f)
                .fields(Collections.singleton("f2")).build();

        new LeafReaderInstanceTest() {

            @Override
            void testHasDeletions() throws Exception {
                Assert.assertFalse("Reader has deletions.", fReader.hasDeletions());
            }

            @Override
            void testFieldCount() throws Exception {
                Assert.assertEquals("Field count mismatch.", 1L, fReader.getFields().size());
            }

            @Override
            void testFieldNames() throws Exception {
                Assert.assertTrue("Visible field not found.", fReader.getFields().contains("f2"));
            }

            @Override
            void testTotalTermFreq() throws Exception {
                Assert.assertEquals("TotalTermFreq mismatch for visible term.", 1L,
                        fReader.totalTermFreq(new Term("f2", "field2")));
                Assert.assertEquals("TotalTermFreq mismatch for hidden term.", 0L,
                        fReader.totalTermFreq(new Term("f1", "field1")));
            }

            @Override
            void testSumTotalTermFreq() throws Exception {
                Assert.assertEquals("SumTotalTermFreq mismatch for visible terms.", 6L,
                        fReader.getSumTotalTermFreq("f2"));
            }

            @Override
            void testDocCount() throws Exception {
                Assert.assertEquals("Doc count mismatch.", 1L, fReader.getDocCount("f2"));
            }

            @SuppressWarnings("ObjectAllocationInLoop")
            @Override
            void testDocFreq() throws Exception {
                Assert.assertEquals("Missing term from visible document.", 1L,
                        fReader.docFreq(new Term("f2", "value")));
            }

            @Override
            void testSumDocFreq() throws Exception {
                Assert.assertEquals("SumDocFreq mismatch for visible term.", 6L, fReader.getSumDocFreq("f2"));
            }

            @Override
            void testTermVectors() throws Exception {
                boolean match = false;
                for (int i = 0; i < fReader.maxDoc(); i++) {
                    final Fields fld = fReader.getTermVectors(i);
                    if (fld != null) {
                        match = true;
                        Assert.assertEquals("Too much fields retrieved from TermVector.", 1L, fld.size());
                    }
                }
                Assert.assertTrue("Fields not found.", match);
            }

            @Override
            void testNumDocs() throws Exception {
                Assert.assertEquals("NumDocs mismatch.", 1L, fReader.numDocs());
            }

            @Override
            void testMaxDoc() throws Exception {
                Assert.assertEquals("MaxDoc mismatch.", 2L, fReader.maxDoc());
            }
        };
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

/**
 * Test {@link Filter} usage in combination with field restriction using both
 * the same field. The excluded field is the same the query-filter will run
 * on./*from  w w  w .  j  a  v a 2 s  . co m*/
 *
 * @throws Exception
 */
@SuppressWarnings({ "AnonymousInnerClassMayBeStatic", "ImplicitNumericConversion" })
@Test
public void testBuilder_filter_and_field_sameField() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.ALL_FIELDS)) {
        final Query q = new TermQuery(new Term("f2", "document2field2"));
        final Filter f = new QueryWrapperFilter(q);
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).queryFilter(f)
                .fields(Collections.singleton("f2"), true).build();

        new LeafReaderInstanceTest() {
            @Override
            void testHasDeletions() throws Exception {
                Assert.assertFalse("Reader has deletions.", fReader.hasDeletions());
            }

            @Override
            void testFieldCount() throws Exception {
                Assert.assertEquals("Field count mismatch.", idx.flds.size() - 1, fReader.getFields().size());
            }

            @Override
            void testFieldNames() throws Exception {
                Assert.assertFalse("Excluded field found.", fReader.getFields().contains("f2"));
            }

            @Override
            void testTotalTermFreq() throws Exception {
                // visible fields
                Assert.assertEquals("TotalTermFreq mismatch for visible field & term.", 1L,
                        fReader.totalTermFreq(new Term("f1", "field1")));
                Assert.assertEquals("TotalTermFreq mismatch for visible field & term.", 1L,
                        fReader.totalTermFreq(new Term("f3", "field3")));
                Assert.assertEquals("TotalTermFreq mismatch for visible field & missing term.", 0L,
                        fReader.totalTermFreq(new Term("f3", "foo")));
                // hidden fields
                Assert.assertEquals("TotalTermFreq mismatch for hidden field & term.", 0L,
                        fReader.totalTermFreq(new Term("f2", "field2")));
            }

            @Override
            void testSumTotalTermFreq() throws Exception {
                Assert.assertEquals("SumTotalTermFreq mismatch for visible field.", 6L,
                        fReader.getSumTotalTermFreq("f1"));
                Assert.assertEquals("SumTotalTermFreq mismatch for visible field.", 6L,
                        fReader.getSumTotalTermFreq("f3"));
                Assert.assertEquals("SumTotalTermFreq mismatch for hidden field.", 0L,
                        fReader.getSumTotalTermFreq("f2"));
            }

            @Override
            void testDocCount() throws Exception {
                Assert.assertEquals("Doc count mismatch for visible field.", 1L, fReader.getDocCount("f1"));
                Assert.assertEquals("Doc count mismatch for visible field.", 1L, fReader.getDocCount("f3"));
                // check visibility of all docs without visible fields
                Assert.assertEquals("Document visible with hidden field.", 0L, fReader.getDocCount("f2"));
            }

            @Override
            void testDocFreq() throws Exception {
                Assert.assertEquals("Missing term from all documents.", 1L,
                        fReader.docFreq(new Term("f1", "field1")));
                Assert.assertEquals("Found term from hidden documents.", 0L,
                        fReader.docFreq(new Term("f2", "field2")));
                Assert.assertEquals("Missing term from all documents.", 1L,
                        fReader.docFreq(new Term("f3", "field3")));
            }

            @Override
            void testSumDocFreq() throws Exception {
                Assert.assertEquals("SumDocFreq mismatch for visible field.", 6L, fReader.getSumDocFreq("f1"));
                Assert.assertEquals("SumDocFreq mismatch for visible field.", 6L, fReader.getSumDocFreq("f3"));
                Assert.assertEquals("SumDocFreq has result for hidden field.", 0L, fReader.getSumDocFreq("f2"));
            }

            @Override
            void testTermVectors() throws Exception {
                for (int i = 0; i < idx.docs - 1; i++) {
                    final Fields flds = fReader.getTermVectors(i);
                    Assert.assertEquals("Too much fields retrieved from TermVector.", 2L, flds.size());
                    flds.forEach(fld -> Assert.assertFalse("Hidden field found.", "f2".equals(fld)));
                }
            }

            @Override
            void testNumDocs() throws Exception {
                Assert.assertEquals("NumDocs mismatch.", 1L, fReader.numDocs());
            }

            @Override
            void testMaxDoc() throws Exception {
                Assert.assertEquals("MaxDoc mismatch.", 2L, fReader.maxDoc());
            }
        };
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

@Test
public void testTermsEnum_totalTermFreq() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.ALL_FIELDS)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).fields(Collections.singleton("f2")).build();

        fReader.getSubReaders().forEach(r -> {
            final Fields f = r.fields();
            f.forEach(fld -> {/*from   w  w  w .ja va 2 s. c o  m*/
                try {
                    final Terms t = f.terms(fld);
                    final TermsEnum te = t.iterator(null);
                    while (te.next() != null) {
                        te.totalTermFreq();
                    }
                } catch (final IOException e) {
                    throw new UncheckedIOException(e);
                }
            });
        });
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

/**
 * Test {@link Filter} usage in combination with {@link TermFilter}
 * restriction.//  w  w w. j a v a 2 s . c  om
 *
 * @throws Exception
 */
@SuppressWarnings({ "AnonymousInnerClassMayBeStatic", "ImplicitNumericConversion" })
@Test
public void testBuilder_filter_and_termFilter() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.ALL_FIELDS)) {
        final String skipTerm = "document2field3";
        final Query q = new TermQuery(new Term("f1", "document2field1"));
        final Filter f = new QueryWrapperFilter(q);
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).queryFilter(f).termFilter(new TermFilter() {
            @Override
            public boolean isAccepted(@Nullable final TermsEnum termsEnum, @NotNull final BytesRef term) {
                return !skipTerm.equals(term.utf8ToString());
            }
        }).build();

        new LeafReaderInstanceTest() {

            @Override
            void testHasDeletions() throws Exception {
                Assert.assertFalse("Reader has deletions.", fReader.hasDeletions());
            }

            @Override
            void testFieldCount() throws Exception {
                Assert.assertEquals("Field count mismatch.", 3L, fReader.getFields().size());
            }

            @Override
            void testFieldNames() throws Exception {
                for (final String fld : idx.flds) {
                    Assert.assertTrue("Visible field not found.", fReader.getFields().contains(fld));
                }
            }

            @Override
            void testTotalTermFreq() throws Exception {
                Assert.assertEquals("TotalTermFreq mismatch for visible term.", 1L,
                        fReader.totalTermFreq(new Term("f1", "field1")));
                Assert.assertEquals("TotalTermFreq mismatch for visible term.", 1L,
                        fReader.totalTermFreq(new Term("f2", "field2")));
                Assert.assertEquals("TotalTermFreq mismatch for visible term.", 1L,
                        fReader.totalTermFreq(new Term("f3", "field3")));
                Assert.assertEquals("TotalTermFreq mismatch for hidden term.", 0L,
                        fReader.totalTermFreq(new Term("f3", "document2field3")));
            }

            @Override
            void testSumTotalTermFreq() throws Exception {
                Assert.assertEquals("SumTotalTermFreq mismatch for visible terms.", 6L,
                        fReader.getSumTotalTermFreq("f2"));
            }

            @Override
            void testDocCount() throws Exception {
                for (final String fld : idx.flds) {
                    Assert.assertEquals("Doc count mismatch.", 1L, fReader.getDocCount(fld));
                }
            }

            @SuppressWarnings("ObjectAllocationInLoop")
            @Override
            void testDocFreq() throws Exception {
                Assert.assertEquals("Missing term from visible document.", 1L,
                        fReader.docFreq(new Term("f2", "value")));
                Assert.assertEquals("Hidden term found.", 0L,
                        fReader.docFreq(new Term("f1", "document1field1")));
                Assert.assertEquals("Hidden term found.", 0L,
                        fReader.docFreq(new Term("f3", "document2field3")));
            }

            @Override
            void testSumDocFreq() throws Exception {
                Assert.assertEquals("SumDocFreq mismatch for visible term.", 6L, fReader.getSumDocFreq("f2"));
                Assert.assertEquals("SumDocFreq mismatch for visible term.", 5L, fReader.getSumDocFreq("f3"));
            }

            @Override
            void testTermVectors() throws Exception {
                boolean match = false;
                final BytesRef term = new BytesRef(skipTerm);
                for (int i = 0; i < fReader.maxDoc(); i++) {
                    final Fields fld = fReader.getTermVectors(i);
                    if (fld != null) {
                        match = true;
                        Assert.assertEquals("Number of fields retrieved from TermVector do not match.", 3L,
                                fld.size());
                        final Terms t = fld.terms("f3");
                        if (t != null) {
                            final TermsEnum te = t.iterator(null);
                            Assert.assertFalse("Hidden term found.", te.seekExact(term));
                        }
                    }
                }
                Assert.assertTrue("Fields not found.", match);
            }

            @Override
            void testNumDocs() throws Exception {
                Assert.assertEquals("NumDocs mismatch.", 1L, fReader.numDocs());
            }

            @Override
            void testMaxDoc() throws Exception {
                Assert.assertEquals("MaxDoc mismatch.", 2L, fReader.maxDoc());
            }
        };
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

@Test
public void testUnwrap() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.PLAIN)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).build();

        Assert.assertFalse("Unwrap failed.", FilteredDirectoryReader.class.isInstance(fReader.unwrap()));
    }//from  w  w w.j av a2  s .  c o m
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

@Test
public void testDoWrapDirectoryReader() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.PLAIN)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).build();

        final FilteredDirectoryReader result = fReader.doWrapDirectoryReader(reader);

        Assert.assertTrue("Wrap failed.", FilteredDirectoryReader.class.isInstance(result));
    }/*  w w w  .  j av a  2  s  . c om*/
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

@Test
public void testHasDeletions() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.PLAIN)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).build();

        Assert.assertFalse("Reader has deletions.", fReader.hasDeletions());
    }/*w ww  .  j a va2s .c o  m*/
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

@SuppressWarnings("ImplicitNumericConversion")
@Test//w  w  w  . j  a  v a  2s .co  m
public void testGetFields() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.PLAIN)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).build();

        Assert.assertEquals("Field count mismatch.", idx.flds.size(), fReader.getFields().size());
        Assert.assertTrue("Field list mismatch.", fReader.getFields().containsAll(idx.flds));
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

@Test
public void testGetSubReaders() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.PLAIN)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).build();

        Assert.assertFalse("No subReaders.", fReader.getSubReaders().isEmpty());
    }/*from   w  ww  . j a va 2  s .c o  m*/
}

From source file:de.uni_koeln.spinfo.maalr.lucene.core.DictionaryLoader.java

License:Apache License

private synchronized void loadIndex() throws NoIndexAvailableException {
    if (searcher == null) {
        try {/*  w  w  w .  j  av  a 2  s  .  c o m*/
            logger.info("Loading index from directory " + environment.getLuceneIndexDir().getAbsolutePath());
            NIOFSDirectory directory = new NIOFSDirectory(environment.getLuceneIndexDir());
            ram = new RAMDirectory(directory, new IOContext());
            reader = DirectoryReader.open(ram);
            searcher = new IndexSearcher(reader);
            searcher.setSimilarity(new SimilarityBase() {

                @Override
                public String toString() {
                    return "Constant Similarity";
                }

                @Override
                protected float score(BasicStats stats, float freq, float docLen) {
                    return stats.getTotalBoost();
                }

            });
            directory.close();
            logger.info("Index loaded.");
        } catch (IOException e) {
            throw new NoIndexAvailableException("Failed to load index", e);
        }
    }
}