Close() private method

private Close ( ) : void
return void
コード例 #1
0
        public virtual void  TestEmptyIndex()
        {
            // creating two directories for indices
            Directory indexStoreA = new MockRAMDirectory();
            Directory indexStoreB = new MockRAMDirectory();

            // creating a document to store
            Document lDoc = new Document();

            lDoc.Add(new Field("fulltext", "Once upon a time.....", Field.Store.YES, Field.Index.ANALYZED));
            lDoc.Add(new Field("id", "doc1", Field.Store.YES, Field.Index.NOT_ANALYZED));
            lDoc.Add(new Field("handle", "1", Field.Store.YES, Field.Index.NOT_ANALYZED));

            // creating a document to store
            Document lDoc2 = new Document();

            lDoc2.Add(new Field("fulltext", "in a galaxy far far away.....", Field.Store.YES, Field.Index.ANALYZED));
            lDoc2.Add(new Field("id", "doc2", Field.Store.YES, Field.Index.NOT_ANALYZED));
            lDoc2.Add(new Field("handle", "1", Field.Store.YES, Field.Index.NOT_ANALYZED));

            // creating a document to store
            Document lDoc3 = new Document();

            lDoc3.Add(new Field("fulltext", "a bizarre bug manifested itself....", Field.Store.YES, Field.Index.ANALYZED));
            lDoc3.Add(new Field("id", "doc3", Field.Store.YES, Field.Index.NOT_ANALYZED));
            lDoc3.Add(new Field("handle", "1", Field.Store.YES, Field.Index.NOT_ANALYZED));

            // creating an index writer for the first index
            IndexWriter writerA = new IndexWriter(indexStoreA, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);
            // creating an index writer for the second index, but writing nothing
            IndexWriter writerB = new IndexWriter(indexStoreB, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);

            //--------------------------------------------------------------------
            // scenario 1
            //--------------------------------------------------------------------

            // writing the documents to the first index
            writerA.AddDocument(lDoc);
            writerA.AddDocument(lDoc2);
            writerA.AddDocument(lDoc3);
            writerA.Optimize();
            writerA.Close();

            // closing the second index
            writerB.Close();

            // creating the query
            QueryParser parser = new QueryParser(Util.Version.LUCENE_CURRENT, "fulltext", new StandardAnalyzer(Util.Version.LUCENE_CURRENT));
            Query       query  = parser.Parse("handle:1");

            // building the searchables
            Searcher[] searchers = new Searcher[2];
            // VITAL STEP:adding the searcher for the empty index first, before the searcher for the populated index
            searchers[0] = new IndexSearcher(indexStoreB, true);
            searchers[1] = new IndexSearcher(indexStoreA, true);
            // creating the multiSearcher
            Searcher mSearcher = GetMultiSearcherInstance(searchers);

            // performing the search
            ScoreDoc[] hits = mSearcher.Search(query, null, 1000).ScoreDocs;

            Assert.AreEqual(3, hits.Length);

            // iterating over the hit documents
            for (int i = 0; i < hits.Length; i++)
            {
                mSearcher.Doc(hits[i].Doc);
            }
            mSearcher.Close();


            //--------------------------------------------------------------------
            // scenario 2
            //--------------------------------------------------------------------

            // adding one document to the empty index
            writerB = new IndexWriter(indexStoreB, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), false, IndexWriter.MaxFieldLength.LIMITED);
            writerB.AddDocument(lDoc);
            writerB.Optimize();
            writerB.Close();

            // building the searchables
            Searcher[] searchers2 = new Searcher[2];
            // VITAL STEP:adding the searcher for the empty index first, before the searcher for the populated index
            searchers2[0] = new IndexSearcher(indexStoreB, true);
            searchers2[1] = new IndexSearcher(indexStoreA, true);
            // creating the mulitSearcher
            MultiSearcher mSearcher2 = GetMultiSearcherInstance(searchers2);

            // performing the same search
            ScoreDoc[] hits2 = mSearcher2.Search(query, null, 1000).ScoreDocs;

            Assert.AreEqual(4, hits2.Length);

            // iterating over the hit documents
            for (int i = 0; i < hits2.Length; i++)
            {
                // no exception should happen at this point
                mSearcher2.Doc(hits2[i].Doc);
            }

            // test the subSearcher() method:
            Query subSearcherQuery = parser.Parse("id:doc1");

            hits2 = mSearcher2.Search(subSearcherQuery, null, 1000).ScoreDocs;
            Assert.AreEqual(2, hits2.Length);
            Assert.AreEqual(0, mSearcher2.SubSearcher(hits2[0].Doc)); // hit from searchers2[0]
            Assert.AreEqual(1, mSearcher2.SubSearcher(hits2[1].Doc)); // hit from searchers2[1]
            subSearcherQuery = parser.Parse("id:doc2");
            hits2            = mSearcher2.Search(subSearcherQuery, null, 1000).ScoreDocs;
            Assert.AreEqual(1, hits2.Length);
            Assert.AreEqual(1, mSearcher2.SubSearcher(hits2[0].Doc)); // hit from searchers2[1]
            mSearcher2.Close();

            //--------------------------------------------------------------------
            // scenario 3
            //--------------------------------------------------------------------

            // deleting the document just added, this will cause a different exception to take place
            Term        term    = new Term("id", "doc1");
            IndexReader readerB = IndexReader.Open(indexStoreB, false);

            readerB.DeleteDocuments(term);
            readerB.Close();

            // optimizing the index with the writer
            writerB = new IndexWriter(indexStoreB, new StandardAnalyzer(Util.Version.LUCENE_CURRENT), false, IndexWriter.MaxFieldLength.LIMITED);
            writerB.Optimize();
            writerB.Close();

            // building the searchables
            Searcher[] searchers3 = new Searcher[2];

            searchers3[0] = new IndexSearcher(indexStoreB, true);
            searchers3[1] = new IndexSearcher(indexStoreA, true);
            // creating the mulitSearcher
            Searcher mSearcher3 = GetMultiSearcherInstance(searchers3);

            // performing the same search
            ScoreDoc[] hits3 = mSearcher3.Search(query, null, 1000).ScoreDocs;

            Assert.AreEqual(3, hits3.Length);

            // iterating over the hit documents
            for (int i = 0; i < hits3.Length; i++)
            {
                mSearcher3.Doc(hits3[i].Doc);
            }
            mSearcher3.Close();
            indexStoreA.Close();
            indexStoreB.Close();
        }
コード例 #2
0
        private void  TestNormalization(int nDocs, System.String message)
        {
            Query query = new TermQuery(new Term("contents", "doc0"));

            RAMDirectory  ramDirectory1;
            IndexSearcher indexSearcher1;

            ScoreDoc[] hits;

            ramDirectory1 = new MockRAMDirectory();

            // First put the documents in the same index
            InitIndex(ramDirectory1, nDocs, true, null); // documents with a single token "doc0", "doc1", etc...
            InitIndex(ramDirectory1, nDocs, false, "x"); // documents with two tokens "doc0" and "x", "doc1" and x, etc...

            indexSearcher1 = new IndexSearcher(ramDirectory1, true);
            indexSearcher1.SetDefaultFieldSortScoring(true, true);

            hits = indexSearcher1.Search(query, null, 1000).ScoreDocs;

            Assert.AreEqual(2, hits.Length, message);

            // Store the scores for use later
            float[] scores = new float[] { hits[0].Score, hits[1].Score };

            Assert.IsTrue(scores[0] > scores[1], message);

            indexSearcher1.Close();
            ramDirectory1.Close();
            hits = null;



            RAMDirectory  ramDirectory2;
            IndexSearcher indexSearcher2;

            ramDirectory1 = new MockRAMDirectory();
            ramDirectory2 = new MockRAMDirectory();

            // Now put the documents in a different index
            InitIndex(ramDirectory1, nDocs, true, null); // documents with a single token "doc0", "doc1", etc...
            InitIndex(ramDirectory2, nDocs, true, "x");  // documents with two tokens "doc0" and "x", "doc1" and x, etc...

            indexSearcher1 = new IndexSearcher(ramDirectory1, true);
            indexSearcher1.SetDefaultFieldSortScoring(true, true);
            indexSearcher2 = new IndexSearcher(ramDirectory2, true);
            indexSearcher2.SetDefaultFieldSortScoring(true, true);

            Searcher searcher = GetMultiSearcherInstance(new Searcher[] { indexSearcher1, indexSearcher2 });

            hits = searcher.Search(query, null, 1000).ScoreDocs;

            Assert.AreEqual(2, hits.Length, message);

            // The scores should be the same (within reason)
            Assert.AreEqual(scores[0], hits[0].Score, 1e-6, message); // This will a document from ramDirectory1
            Assert.AreEqual(scores[1], hits[1].Score, 1e-6, message); // This will a document from ramDirectory2



            // Adding a Sort.RELEVANCE object should not change anything
            hits = searcher.Search(query, null, 1000, Sort.RELEVANCE).ScoreDocs;

            Assert.AreEqual(2, hits.Length, message);

            Assert.AreEqual(scores[0], hits[0].Score, 1e-6, message); // This will a document from ramDirectory1
            Assert.AreEqual(scores[1], hits[1].Score, 1e-6, message); // This will a document from ramDirectory2

            searcher.Close();

            ramDirectory1.Close();
            ramDirectory2.Close();
        }
コード例 #3
0
ファイル: TestMultiSearcher.cs プロジェクト: yonder/mono
        public virtual void  TestEmptyIndex()
        {
            // creating two directories for indices
            Directory indexStoreA = new RAMDirectory();
            Directory indexStoreB = new RAMDirectory();

            // creating a document to store
            Document lDoc = new Document();

            lDoc.Add(Field.Text("fulltext", "Once upon a time....."));
            lDoc.Add(Field.Keyword("id", "doc1"));
            lDoc.Add(Field.Keyword("handle", "1"));

            // creating a document to store
            Document lDoc2 = new Document();

            lDoc2.Add(Field.Text("fulltext", "in a galaxy far far away....."));
            lDoc2.Add(Field.Keyword("id", "doc2"));
            lDoc2.Add(Field.Keyword("handle", "1"));

            // creating a document to store
            Document lDoc3 = new Document();

            lDoc3.Add(Field.Text("fulltext", "a bizarre bug manifested itself...."));
            lDoc3.Add(Field.Keyword("id", "doc3"));
            lDoc3.Add(Field.Keyword("handle", "1"));

            // creating an index writer for the first index
            IndexWriter writerA = new IndexWriter(indexStoreA, new StandardAnalyzer(), true);
            // creating an index writer for the second index, but writing nothing
            IndexWriter writerB = new IndexWriter(indexStoreB, new StandardAnalyzer(), true);

            //--------------------------------------------------------------------
            // scenario 1
            //--------------------------------------------------------------------

            // writing the documents to the first index
            writerA.AddDocument(lDoc);
            writerA.AddDocument(lDoc2);
            writerA.AddDocument(lDoc3);
            writerA.Optimize();
            writerA.Close();

            // closing the second index
            writerB.Close();

            // creating the query
            Query query = Lucene.Net.QueryParsers.QueryParser.Parse("handle:1", "fulltext", new StandardAnalyzer());

            // building the searchables
            Searcher[] searchers = new Searcher[2];
            // VITAL STEP:adding the searcher for the empty index first, before the searcher for the populated index
            searchers[0] = new IndexSearcher(indexStoreB);
            searchers[1] = new IndexSearcher(indexStoreA);
            // creating the multiSearcher
            Searcher mSearcher = GetMultiSearcherInstance(searchers);
            // performing the search
            Hits hits = mSearcher.Search(query);

            Assert.AreEqual(3, hits.Length());

            try
            {
                // iterating over the hit documents
                for (int i = 0; i < hits.Length(); i++)
                {
                    Document d = hits.Doc(i);
                }
            }
            catch (System.IndexOutOfRangeException e)
            {
                Assert.Fail("ArrayIndexOutOfBoundsException thrown: " + e.Message);
                System.Console.Error.WriteLine(e.Source);
            }
            finally
            {
                mSearcher.Close();
            }


            //--------------------------------------------------------------------
            // scenario 2
            //--------------------------------------------------------------------

            // adding one document to the empty index
            writerB = new IndexWriter(indexStoreB, new StandardAnalyzer(), false);
            writerB.AddDocument(lDoc);
            writerB.Optimize();
            writerB.Close();

            // building the searchables
            Searcher[] searchers2 = new Searcher[2];
            // VITAL STEP:adding the searcher for the empty index first, before the searcher for the populated index
            searchers2[0] = new IndexSearcher(indexStoreB);
            searchers2[1] = new IndexSearcher(indexStoreA);
            // creating the mulitSearcher
            Searcher mSearcher2 = GetMultiSearcherInstance(searchers2);
            // performing the same search
            Hits hits2 = mSearcher2.Search(query);

            Assert.AreEqual(4, hits2.Length());

            try
            {
                // iterating over the hit documents
                for (int i = 0; i < hits2.Length(); i++)
                {
                    // no exception should happen at this point
                    Document d = hits2.Doc(i);
                }
            }
            catch (System.Exception e)
            {
                Assert.Fail("Exception thrown: " + e.Message);
                System.Console.Error.WriteLine(e.Source);
            }
            finally
            {
                mSearcher2.Close();
            }

            //--------------------------------------------------------------------
            // scenario 3
            //--------------------------------------------------------------------

            // deleting the document just added, this will cause a different exception to take place
            Term        term    = new Term("id", "doc1");
            IndexReader readerB = IndexReader.Open(indexStoreB);

            readerB.Delete(term);
            readerB.Close();

            // optimizing the index with the writer
            writerB = new IndexWriter(indexStoreB, new StandardAnalyzer(), false);
            writerB.Optimize();
            writerB.Close();

            // building the searchables
            Searcher[] searchers3 = new Searcher[2];

            searchers3[0] = new IndexSearcher(indexStoreB);
            searchers3[1] = new IndexSearcher(indexStoreA);
            // creating the mulitSearcher
            Searcher mSearcher3 = GetMultiSearcherInstance(searchers3);
            // performing the same search
            Hits hits3 = mSearcher3.Search(query);

            Assert.AreEqual(3, hits3.Length());

            try
            {
                // iterating over the hit documents
                for (int i = 0; i < hits3.Length(); i++)
                {
                    Document d = hits3.Doc(i);
                }
            }
            catch (System.IO.IOException e)
            {
                Assert.Fail("IOException thrown: " + e.Message);
                System.Console.Error.WriteLine(e.Source);
            }
            finally
            {
                mSearcher3.Close();
            }
        }