public void SortOrder_With_MultiSearcher_Across_Indexes_Test() { var dir2 = new RAMDirectory(); var indexWriter2 = new IndexWriter(dir2, _analyzer, IndexWriter.MaxFieldLength.UNLIMITED); indexWriter2.AddDocument(CreateDocument(100, "Anders", 0)); indexWriter2.Commit(); var searcher = new IndexSearcher(_dir, true); var searcher2 = new IndexSearcher(dir2, true); var parallelMultiSearcher = new ParallelMultiSearcher(new Searchable[] { searcher, searcher2 }); var sortOrder = new[] { 20, 10, 100, 30, 40 }; var result = Search(parallelMultiSearcher, _query, sortOrder); CollectionAssert.AreEqual(sortOrder, result); parallelMultiSearcher.Dispose(); indexWriter2.Dispose(); dir2.Dispose(); }
public void Dispose() { searcher.Dispose(); writer.Dispose(); directory.Dispose(); analyzer = null; }
public virtual void TestOpenIfChangedAndRefCount() { Directory dir = new RAMDirectory(); // no need for random directories here var taxoWriter = new DirectoryTaxonomyWriter(dir); taxoWriter.AddCategory(new FacetLabel("a")); taxoWriter.Commit(); var taxoReader = new DirectoryTaxonomyReader(dir); Assert.AreEqual(1, taxoReader.RefCount, "wrong refCount"); taxoReader.IncRef(); Assert.AreEqual(2, taxoReader.RefCount, "wrong refCount"); taxoWriter.AddCategory(new FacetLabel("a", "b")); taxoWriter.Commit(); var newtr = TaxonomyReader.OpenIfChanged(taxoReader); Assert.IsNotNull(newtr); taxoReader.Dispose(); taxoReader = newtr; Assert.AreEqual(1, taxoReader.RefCount, "wrong refCount"); taxoWriter.Dispose(); taxoReader.Dispose(); dir.Dispose(); }
public void SortOrder_With_MultiIndexReader_Test() { var dir2 = new RAMDirectory(); var indexWriter2 = new IndexWriter(dir2, _analyzer, IndexWriter.MaxFieldLength.UNLIMITED); indexWriter2.AddDocument(CreateDocument(100, "Anders", 0)); indexWriter2.Commit(); var mr = new MultiReader(new[] { IndexReader.Open(_dir, true), IndexReader.Open(dir2, true) }); var searcher = new IndexSearcher(mr); var sortOrder = new[] { 20, 10, 100, 30, 40 }; var result = Search(searcher, _query, sortOrder); CollectionAssert.AreEqual(sortOrder, result); searcher.Dispose(); indexWriter2.Dispose(); dir2.Dispose(); }
/// <summary> /// Clears all results from the current index. During the next search the index will be rebuilt. /// </summary> public void Clear() { lck.AcquireWriterLock(WriterTimeOut); try { if (rd != null) { rd.Dispose(); rd = null; } } finally { lck.ReleaseWriterLock(); } }
/** * Build a randomish document for both RAMDirectory and MemoryIndex, * and run all the queries against it. */ public void AssertAgainstRAMDirectory(MemoryIndex memory) { memory.Reset(); StringBuilder fooField = new StringBuilder(); StringBuilder termField = new StringBuilder(); // add up to 250 terms to field "foo" int numFooTerms = Random.nextInt(250 * RandomMultiplier); for (int i = 0; i < numFooTerms; i++) { fooField.append(" "); fooField.append(RandomTerm()); } // add up to 250 terms to field "term" int numTermTerms = Random.nextInt(250 * RandomMultiplier); for (int i = 0; i < numTermTerms; i++) { termField.append(" "); termField.append(RandomTerm()); } Store.Directory ramdir = new RAMDirectory(); Analyzer analyzer = RandomAnalyzer(); IndexWriter writer = new IndexWriter(ramdir, new IndexWriterConfig(TEST_VERSION_CURRENT, analyzer).SetCodec(TestUtil.AlwaysPostingsFormat(new Lucene41PostingsFormat()))); Document doc = new Document(); Field field1 = NewTextField("foo", fooField.toString(), Field.Store.NO); Field field2 = NewTextField("term", termField.toString(), Field.Store.NO); doc.Add(field1); doc.Add(field2); writer.AddDocument(doc); writer.Dispose(); memory.AddField("foo", fooField.toString(), analyzer); memory.AddField("term", termField.toString(), analyzer); if (Verbose) { Console.WriteLine("Random MemoryIndex:\n" + memory.toString()); Console.WriteLine("Same index as RAMDirectory: " + RamUsageEstimator.HumanReadableUnits(RamUsageEstimator.SizeOf(ramdir))); Console.WriteLine(); } else { assertTrue(memory.GetMemorySize() > 0L); } AtomicReader reader = (AtomicReader)memory.CreateSearcher().IndexReader; DirectoryReader competitor = DirectoryReader.Open(ramdir); DuellReaders(competitor, reader); IOUtils.Dispose(reader, competitor); AssertAllQueries(memory, ramdir, analyzer); ramdir.Dispose(); }
public void TearDown() { _searcher1.Dispose(); _searcher2.Dispose(); _directory1.Dispose(); _directory2.Dispose(); }
public void Dispose() { facetHandlers = null; if (directory != null /*&& directory.IsOpen*/) { directory.Dispose(); } directory = null; analyzer = null; }
public void Setup(string filePath) { var sourceDir = new RAMDirectory(); LoadLuceneIndex(sourceDir, filePath); _autoSuggest = CreateSuggest(new RAMDirectory(), sourceDir); sourceDir.Dispose(); }
public void Dispose() { facetHandlers = null; if (directory.isOpen_ForNUnit) { directory.Dispose(); } directory = null; analyzer = null; }
public void AnIndexCanBeCreated() { TestDataGenerator tdg = new TestDataGenerator(); Directory directory = new RAMDirectory(); Analyzer analyzer = new StandardAnalyzer(Lucene.Net.Util.LuceneVersion.LUCENE_48); _indexer = new LuceneIndexer(directory, analyzer); _indexer.CreateIndex(tdg.AllData); Assert.Equal(2000, _indexer.Count()); analyzer.Dispose(); directory.ClearLock("write.lock"); directory.Dispose(); }
public void TestStoreAndRetrieveFieldType() { Directory dir = new RAMDirectory(); Analyzer analyzer = new StandardAnalyzer(LuceneVersion.LUCENE_48); IndexWriterConfig iwc = new IndexWriterConfig(LuceneVersion.LUCENE_48, analyzer); double value = double.MaxValue; string fieldName = "DoubleField"; FieldType type = new FieldType(); type.IsIndexed = true; type.IsStored = true; type.IsTokenized = false; type.NumericType = NumericType.DOUBLE; using (IndexWriter writer = new IndexWriter(dir, iwc)) { Document doc = new Document(); Field field = new DoubleField(fieldName, value, type); FieldType fieldType = field.FieldType; assertEquals(true, fieldType.IsIndexed); assertEquals(true, fieldType.IsStored); assertEquals(false, fieldType.IsTokenized); assertEquals(NumericType.DOUBLE, fieldType.NumericType); doc.Add(field); writer.AddDocument(doc); writer.Commit(); } using (IndexReader reader = DirectoryReader.Open(dir)) { IndexSearcher searcher = new IndexSearcher(reader); var hits = searcher.Search(new MatchAllDocsQuery(), 10).ScoreDocs; Document doc = searcher.Doc(hits[0].Doc); Field field = doc.GetField <Field>(fieldName); FieldType fieldType = field.FieldType; assertEquals(false, fieldType.IsIndexed); assertEquals(true, fieldType.IsStored); assertEquals(true, fieldType.IsTokenized); assertEquals(NumericType.NONE, fieldType.NumericType); } dir.Dispose(); }
public virtual void TestCaching() { Directory dir = new RAMDirectory(); RandomIndexWriter writer = new RandomIndexWriter( #if FEATURE_INSTANCE_TESTDATA_INITIALIZATION this, #endif Random, dir); Document doc = new Document(); TokenStream stream = new TokenStreamAnonymousInnerClassHelper(this); stream = new CachingTokenFilter(stream); doc.Add(new TextField("preanalyzed", stream)); // 1) we consume all tokens twice before we add the doc to the index CheckTokens(stream); stream.Reset(); CheckTokens(stream); // 2) now add the document to the index and verify if all tokens are indexed // don't reset the stream here, the DocumentWriter should do that implicitly writer.AddDocument(doc); IndexReader reader = writer.GetReader(); DocsAndPositionsEnum termPositions = MultiFields.GetTermPositionsEnum(reader, MultiFields.GetLiveDocs(reader), "preanalyzed", new BytesRef("term1")); Assert.IsTrue(termPositions.NextDoc() != DocIdSetIterator.NO_MORE_DOCS); Assert.AreEqual(1, termPositions.Freq); Assert.AreEqual(0, termPositions.NextPosition()); termPositions = MultiFields.GetTermPositionsEnum(reader, MultiFields.GetLiveDocs(reader), "preanalyzed", new BytesRef("term2")); Assert.IsTrue(termPositions.NextDoc() != DocIdSetIterator.NO_MORE_DOCS); Assert.AreEqual(2, termPositions.Freq); Assert.AreEqual(1, termPositions.NextPosition()); Assert.AreEqual(3, termPositions.NextPosition()); termPositions = MultiFields.GetTermPositionsEnum(reader, MultiFields.GetLiveDocs(reader), "preanalyzed", new BytesRef("term3")); Assert.IsTrue(termPositions.NextDoc() != DocIdSetIterator.NO_MORE_DOCS); Assert.AreEqual(1, termPositions.Freq); Assert.AreEqual(2, termPositions.NextPosition()); reader.Dispose(); writer.Dispose(); // 3) reset stream and consume tokens again stream.Reset(); CheckTokens(stream); dir.Dispose(); }
static void Main(string[] args) { Directory dir = new RAMDirectory(); CreateDocuments(dir); IndexReader reader = IndexReader.Open(dir, true); var searcher = new IndexSearcher(reader); int numDocs = reader.MaxDoc; var mlt = new Lucene.Net.Search.Similar.MoreLikeThis(reader); mlt.SetFieldNames(new String[] { "name" }); mlt.MinTermFreq = 1; mlt.MinDocFreq = 1; for (int docId = 0; docId < numDocs; docId++) { Document doc = reader.Document(docId); Console.WriteLine(doc.Get("name")); Query query = mlt.Like(docId); Console.WriteLine(" query = {0}", query); TopDocs similarDocs = searcher.Search(query, 10); if (similarDocs.TotalHits == 0) { Console.WriteLine(" None like this"); } for (int i = 0; i < similarDocs.ScoreDocs.Length; i++) { if (similarDocs.ScoreDocs[i].Doc != docId) { doc = reader.Document(similarDocs.ScoreDocs[i].Doc); Console.WriteLine(" -> {0}", doc.Get("name")); } } Console.WriteLine(); } searcher.Dispose(); reader.Dispose(); dir.Dispose(); }
public void TestCustomMergeScheduler() { // we don't really need to execute anything, just to make sure the custom MS // compiles. But ensure that it can be used as well, e.g., no other hidden // dependencies or something. Therefore, don't use any random API ! Directory dir = new RAMDirectory(); IndexWriterConfig conf = new IndexWriterConfig(TEST_VERSION_CURRENT, null); conf.SetMergeScheduler(new ReportingMergeScheduler()); IndexWriter writer = new IndexWriter(dir, conf); writer.AddDocument(new Document()); writer.Commit(); // trigger flush writer.AddDocument(new Document()); writer.Commit(); // trigger flush writer.ForceMerge(1); writer.Dispose(); dir.Dispose(); }
public virtual void TestRawIndexInputRead() { Random random = Random; RAMDirectory dir = new RAMDirectory(); IndexOutput os = dir.CreateOutput("foo", NewIOContext(random)); os.WriteBytes(READ_TEST_BYTES, READ_TEST_BYTES.Length); os.Dispose(); IndexInput @is = dir.OpenInput("foo", NewIOContext(random)); CheckReads(@is, typeof(IOException)); @is.Dispose(); os = dir.CreateOutput("bar", NewIOContext(random)); os.WriteBytes(RANDOM_TEST_BYTES, RANDOM_TEST_BYTES.Length); os.Dispose(); @is = dir.OpenInput("bar", NewIOContext(random)); CheckRandomReads(@is); @is.Dispose(); dir.Dispose(); }
public void TestMultithreadedWaitForGeneration() { Thread CreateWorker(int threadNum, ControlledRealTimeReopenThread <IndexSearcher> controlledReopen, long generation, SearcherManager searcherManager, List <ThreadOutput> outputList) { ThreadStart threadStart = delegate { Stopwatch stopwatch = Stopwatch.StartNew(); controlledReopen.WaitForGeneration(generation); stopwatch.Stop(); double milliSecsWaited = stopwatch.Elapsed.TotalMilliseconds; int numRecs = 0; IndexSearcher indexSearcher = searcherManager.Acquire(); try { TopDocs topDocs = indexSearcher.Search(new MatchAllDocsQuery(), 1); numRecs = topDocs.TotalHits; } finally { searcherManager.Release(indexSearcher); } lock (outputList) { outputList.Add(new ThreadOutput { ThreadNum = threadNum, NumRecs = numRecs, MilliSecsWaited = milliSecsWaited }); } }; return(new Thread(threadStart)); } int threadCount = 3; List <ThreadOutput> outputList = new List <ThreadOutput>(); RAMDirectory indexDir = new RAMDirectory(); Analyzer standardAnalyzer = new StandardAnalyzer(TEST_VERSION_CURRENT); IndexWriterConfig indexConfig = new IndexWriterConfig(TEST_VERSION_CURRENT, standardAnalyzer); IndexWriter indexWriter = new IndexWriter(indexDir, indexConfig); TrackingIndexWriter trackingWriter = new TrackingIndexWriter(indexWriter); //Add two documents Document doc = new Document(); doc.Add(new Int32Field("id", 1, Field.Store.YES)); doc.Add(new StringField("name", "Doc1", Field.Store.YES)); long generation = trackingWriter.AddDocument(doc); doc.Add(new Int32Field("id", 2, Field.Store.YES)); doc.Add(new StringField("name", "Doc3", Field.Store.YES)); generation = trackingWriter.AddDocument(doc); SearcherManager searcherManager = new SearcherManager(indexWriter, applyAllDeletes: true, null); //Reopen SearcherManager every 2 secs via background thread if no thread waiting for newer generation. //Reopen SearcherManager after .2 secs if another thread IS waiting on a newer generation. double maxRefreshSecs = 2.0; double minRefreshSecs = .2; var controlledRealTimeReopenThread = new ControlledRealTimeReopenThread <IndexSearcher>(trackingWriter, searcherManager, maxRefreshSecs, minRefreshSecs); //Start() will start a seperate thread that will invoke the object's Run(). However, //calling Run() directly would execute that code on the current thread rather then a new thread //which would defeat the purpose of using controlledRealTimeReopenThread. This aspect of the API //is not as intuitive as it could be. ie. Call Start() not Run(). controlledRealTimeReopenThread.IsBackground = true; //Set as a background thread controlledRealTimeReopenThread.Name = "Controlled Real Time Reopen Thread"; controlledRealTimeReopenThread.Priority = (ThreadPriority)Math.Min((int)Thread.CurrentThread.Priority + 2, (int)ThreadPriority.Highest); controlledRealTimeReopenThread.Start(); //Create the threads for doing searchers List <Thread> threadList = new List <Thread>(); for (int i = 1; i <= threadCount; i++) { threadList.Add(CreateWorker(i, controlledRealTimeReopenThread, generation, searcherManager, outputList)); } //Start all the threads foreach (Thread thread in threadList) { thread.Start(); } //wait for the threads to finish. foreach (Thread thread in threadList) { thread.Join(); //will wait here until the thread terminates. } //Now make sure that no thread waited longer then our min refresh time //plus a small fudge factor. Also verify that all threads resported back and //each saw 2 records. //Verify all threads reported back a result. assertEquals(threadCount, outputList.Count); int millisecsPerSec = 1000; foreach (ThreadOutput output in outputList) { //Verify the thread saw exactly 2 docs assertEquals(2, output.NumRecs); //Verify the thread wait time was around what was expected. Assert.True(output.MilliSecsWaited <= (minRefreshSecs * millisecsPerSec) + 30); //30ms is fudged factor to account for call overhead } controlledRealTimeReopenThread.Dispose(); //will kill and join to the thread Assert.False(controlledRealTimeReopenThread.IsAlive); //to prove that Dispose really does kill the thread. searcherManager.Dispose(); indexWriter.Dispose(); indexDir.Dispose(); }
public virtual void TestZeroPosIncr() { Directory dir = new RAMDirectory(); Token[] tokens = new Token[3]; tokens[0] = new Token(); tokens[0].Append("a"); tokens[0].PositionIncrement = 1; tokens[1] = new Token(); tokens[1].Append("b"); tokens[1].PositionIncrement = 0; tokens[2] = new Token(); tokens[2].Append("c"); tokens[2].PositionIncrement = 0; RandomIndexWriter writer = new RandomIndexWriter(Random(), dir); Document doc = new Document(); doc.Add(new TextField("field", new CannedTokenStream(tokens))); writer.AddDocument(doc); doc = new Document(); doc.Add(new TextField("field", new CannedTokenStream(tokens))); writer.AddDocument(doc); IndexReader r = writer.Reader; writer.Dispose(); IndexSearcher s = NewSearcher(r); MultiPhraseQuery mpq = new MultiPhraseQuery(); //mpq.setSlop(1); // NOTE: not great that if we do the else clause here we // get different scores! MultiPhraseQuery counts that // phrase as occurring twice per doc (it should be 1, I // think?). this is because MultipleTermPositions is able to // return the same position more than once (0, in this // case): if (true) { mpq.Add(new Term[] { new Term("field", "b"), new Term("field", "c") }, 0); mpq.Add(new Term[] { new Term("field", "a") }, 0); } else { mpq.Add(new Term[] { new Term("field", "a") }, 0); mpq.Add(new Term[] { new Term("field", "b"), new Term("field", "c") }, 0); } TopDocs hits = s.Search(mpq, 2); Assert.AreEqual(2, hits.TotalHits); Assert.AreEqual(hits.ScoreDocs[0].Score, hits.ScoreDocs[1].Score, 1e-5); /* * for(int hit=0;hit<hits.TotalHits;hit++) { * ScoreDoc sd = hits.ScoreDocs[hit]; * System.out.println(" hit doc=" + sd.Doc + " score=" + sd.Score); * } */ r.Dispose(); dir.Dispose(); }
public LuceneTest() { #region Init Directory directory = new RAMDirectory(); var analyzer = new StandardAnalyzer(Lucene.Net.Util.LuceneVersion.LUCENE_48); var config = new IndexWriterConfig(Lucene.Net.Util.LuceneVersion.LUCENE_48, analyzer); IndexWriter indexWriter = new IndexWriter(directory, config); //indexWriter.Commit(); #endregion #region Add Docs to Index Console.WriteLine("Document Contents:"); Document doc1 = new Document(); string text = "Lucene is an Information Retrieval library written in Java. Here's some extra document text."; Console.WriteLine(text); doc1.Add(new Int32Field("id", 1, Field.Store.YES)); doc1.Add(new TextField("Content", text, Field.Store.YES)); indexWriter.AddDocument(doc1); Document doc2 = new Document(); var text2 = "This text belongs in document number 2."; Console.WriteLine(text2); doc1.Add(new Int32Field("id", 2, Field.Store.YES)); doc2.Add(new TextField("Content", text2, Field.Store.YES)); indexWriter.AddDocument(doc2); #endregion #region Close All the Things (This doesn't work in 4.8.0 on Nuget) indexWriter.Dispose(); #endregion Console.WriteLine("Enter Search Term:"); string search_term = Console.ReadLine(); var indexReader = DirectoryReader.Open(directory, 100); var indexSearcher = new IndexSearcher(indexReader); QueryParser parser = new QueryParser(Lucene.Net.Util.LuceneVersion.LUCENE_48, "Content", analyzer); Query query = parser.Parse(search_term); int hitsPerPage = 10; TopDocs docs = indexSearcher.Search(query, hitsPerPage); ScoreDoc[] hits = docs.ScoreDocs; int end = Math.Min(docs.TotalHits, hitsPerPage); Console.WriteLine("Total Hits: " + docs.TotalHits); Console.WriteLine("Results: "); for (int i = 0; i < end; i++) { Document d = indexSearcher.Doc(hits[i].Doc); Console.WriteLine("Content: " + d.Get("Content")); } directory.Dispose(); }
public static void Main(string[] args) { #region Init Directory directory = new RAMDirectory(); Analyzer analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30); //Analyzer analyzer = new WhitespaceAnalyzer(); //Analyzer analyzer = new Lucene.Net.Analysis.Snowball.SnowballAnalyzer(Lucene.Net.Util.Version.LUCENE_30, "snowball analyzer"); IndexWriter indexWriter = new IndexWriter(directory, analyzer, true, IndexWriter.MaxFieldLength.UNLIMITED); #endregion #region Add Docs to Index Console.WriteLine("Document Contents:"); Document doc1 = new Document(); var text = "Lucene is an Information Retrieval library written in Java. Here's some extra document text."; Console.WriteLine(text); //doc1.Add(new NumericField("id").SetIntValue(1)); doc1.Add(new Field("Content", text, Field.Store.YES, Field.Index.ANALYZED)); indexWriter.AddDocument(doc1); Document doc2 = new Document(); var text2 = "This text belongs in document number 2."; Console.WriteLine(text2); //doc2.Add(new NumericField("id").SetIntValue(2)); doc2.Add(new Field("Content", text2, Field.Store.YES, Field.Index.ANALYZED)); indexWriter.AddDocument(doc2); #endregion #region Close All the Things //indexWriter.Optimize(); //indexWriter.Flush(true, true, true); //indexWriter.Dispose(true); #endregion #region Search for a Search Term Console.WriteLine("Enter Search Term:"); string search_term = Console.ReadLine(); var indexReader = IndexReader.Open(directory, true); IndexSearcher indexSearcher = new IndexSearcher(indexReader); QueryParser parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, "Content", analyzer); Query query = parser.Parse(search_term); int hitsPerPage = 10; TopDocs docs = indexSearcher.Search(query, hitsPerPage); ScoreDoc[] hits = docs.ScoreDocs; int end = Math.Min(docs.TotalHits, hitsPerPage); Console.WriteLine("Total Hits: " + docs.TotalHits); Console.WriteLine("Results: "); for (int i = 0; i < end; i++) { Document d = indexSearcher.Doc(hits[i].Doc); Console.WriteLine("Content: " + d.Get("Content")); } directory.Dispose(); #endregion }
public virtual void TestZeroPosIncr() { Directory dir = new RAMDirectory(); Token[] tokens = new Token[3]; tokens[0] = new Token(); tokens[0].Append("a"); tokens[0].PositionIncrement = 1; tokens[1] = new Token(); tokens[1].Append("b"); tokens[1].PositionIncrement = 0; tokens[2] = new Token(); tokens[2].Append("c"); tokens[2].PositionIncrement = 0; RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, Similarity, TimeZone); Document doc = new Document(); doc.Add(new TextField("field", new CannedTokenStream(tokens))); writer.AddDocument(doc); doc = new Document(); doc.Add(new TextField("field", new CannedTokenStream(tokens))); writer.AddDocument(doc); IndexReader r = writer.Reader; writer.Dispose(); IndexSearcher s = NewSearcher(r); MultiPhraseQuery mpq = new MultiPhraseQuery(); //mpq.setSlop(1); // NOTE: not great that if we do the else clause here we // get different scores! MultiPhraseQuery counts that // phrase as occurring twice per doc (it should be 1, I // think?). this is because MultipleTermPositions is able to // return the same position more than once (0, in this // case): if (true) { mpq.Add(new Term[] { new Term("field", "b"), new Term("field", "c") }, 0); mpq.Add(new Term[] { new Term("field", "a") }, 0); } else { mpq.Add(new Term[] { new Term("field", "a") }, 0); mpq.Add(new Term[] { new Term("field", "b"), new Term("field", "c") }, 0); } TopDocs hits = s.Search(mpq, 2); Assert.AreEqual(2, hits.TotalHits); Assert.AreEqual(hits.ScoreDocs[0].Score, hits.ScoreDocs[1].Score, 1e-5); /* for(int hit=0;hit<hits.TotalHits;hit++) { ScoreDoc sd = hits.ScoreDocs[hit]; System.out.println(" hit doc=" + sd.Doc + " score=" + sd.Score); } */ r.Dispose(); dir.Dispose(); }
public virtual void TestWriterLock() { // native fslock impl gets angry if we use it, so use RAMDirectory explicitly. var indexDir = new RAMDirectory(); var tw = new DirectoryTaxonomyWriter(indexDir); tw.AddCategory(new FacetLabel("hi", "there")); tw.Commit(); // we deliberately not close the write now, and keep it open and // locked. // Verify that the writer worked: var tr = new DirectoryTaxonomyReader(indexDir); Assert.AreEqual(2, tr.GetOrdinal(new FacetLabel("hi", "there"))); // Try to open a second writer, with the first one locking the directory. // We expect to get a LockObtainFailedException. try { Assert.Null(new DirectoryTaxonomyWriter(indexDir)); Fail("should have failed to write in locked directory"); } catch (LockObtainFailedException) { // this is what we expect to happen. } // Remove the lock, and now the open should succeed, and we can // write to the new writer. DirectoryTaxonomyWriter.Unlock(indexDir); var tw2 = new DirectoryTaxonomyWriter(indexDir); tw2.AddCategory(new FacetLabel("hey")); tw2.Dispose(); // See that the writer indeed wrote: var newtr = TaxonomyReader.OpenIfChanged(tr); Assert.NotNull(newtr); tr.Dispose(); tr = newtr; Assert.AreEqual(3, tr.GetOrdinal(new FacetLabel("hey"))); tr.Dispose(); tw.Dispose(); indexDir.Dispose(); }
public void TestStraightForwardDemonstration() { RAMDirectory indexDir = new RAMDirectory(); Analyzer standardAnalyzer = new StandardAnalyzer(TEST_VERSION_CURRENT); IndexWriterConfig indexConfig = new IndexWriterConfig(TEST_VERSION_CURRENT, standardAnalyzer); IndexWriter indexWriter = new IndexWriter(indexDir, indexConfig); TrackingIndexWriter trackingWriter = new TrackingIndexWriter(indexWriter); Document doc = new Document(); doc.Add(new Int32Field("id", 1, Field.Store.YES)); doc.Add(new StringField("name", "Doc1", Field.Store.YES)); trackingWriter.AddDocument(doc); SearcherManager searcherManager = new SearcherManager(indexWriter, applyAllDeletes: true, null); //Reopen SearcherManager every 1 secs via background thread if no thread waiting for newer generation. //Reopen SearcherManager after .2 secs if another thread IS waiting on a newer generation. var controlledRealTimeReopenThread = new ControlledRealTimeReopenThread <IndexSearcher>(trackingWriter, searcherManager, 1, 0.2); //Start() will start a seperate thread that will invoke the object's Run(). However, //calling Run() directly would execute that code on the current thread rather then a new thread //which would defeat the purpose of using controlledRealTimeReopenThread. This aspect of the API //is not as intuitive as it could be. ie. Call Start() not Run(). controlledRealTimeReopenThread.IsBackground = true; //Set as a background thread controlledRealTimeReopenThread.Name = "Controlled Real Time Reopen Thread"; controlledRealTimeReopenThread.Priority = (ThreadPriority)Math.Min((int)Thread.CurrentThread.Priority + 2, (int)ThreadPriority.Highest); controlledRealTimeReopenThread.Start(); //An indexSearcher only sees Doc1 IndexSearcher indexSearcher = searcherManager.Acquire(); try { TopDocs topDocs = indexSearcher.Search(new MatchAllDocsQuery(), 1); assertEquals(1, topDocs.TotalHits); //There is only one doc } finally { searcherManager.Release(indexSearcher); } //Add a 2nd document doc = new Document(); doc.Add(new Int32Field("id", 2, Field.Store.YES)); doc.Add(new StringField("name", "Doc2", Field.Store.YES)); trackingWriter.AddDocument(doc); //Demonstrate that we can only see the first doc because we haven't //waited 1 sec or called WaitForGeneration indexSearcher = searcherManager.Acquire(); try { TopDocs topDocs = indexSearcher.Search(new MatchAllDocsQuery(), 1); assertEquals(1, topDocs.TotalHits); //Can see both docs due to auto refresh after 1.1 secs } finally { searcherManager.Release(indexSearcher); } //Demonstrate that we can see both docs after we wait a little more //then 1 sec so that controlledRealTimeReopenThread max interval is exceeded //and it calls MaybeRefresh Thread.Sleep(1100); //wait 1.1 secs as ms indexSearcher = searcherManager.Acquire(); try { TopDocs topDocs = indexSearcher.Search(new MatchAllDocsQuery(), 1); assertEquals(2, topDocs.TotalHits); //Can see both docs due to auto refresh after 1.1 secs } finally { searcherManager.Release(indexSearcher); } //Add a 3rd document doc = new Document(); doc.Add(new Int32Field("id", 3, Field.Store.YES)); doc.Add(new StringField("name", "Doc3", Field.Store.YES)); long generation = trackingWriter.AddDocument(doc); //Demonstrate that if we call WaitForGeneration our wait will be // .2 secs or less (the min interval we set earlier) and then we will //see all 3 documents. Stopwatch stopwatch = Stopwatch.StartNew(); controlledRealTimeReopenThread.WaitForGeneration(generation); stopwatch.Stop(); assertTrue(stopwatch.Elapsed.TotalMilliseconds <= 200 + 30); //30ms is fudged factor to account for call overhead. indexSearcher = searcherManager.Acquire(); try { TopDocs topDocs = indexSearcher.Search(new MatchAllDocsQuery(), 1); assertEquals(3, topDocs.TotalHits); //Can see both docs due to auto refresh after 1.1 secs } finally { searcherManager.Release(indexSearcher); } controlledRealTimeReopenThread.Dispose(); searcherManager.Dispose(); indexWriter.Dispose(); indexDir.Dispose(); }
public Grouping() { #region Init Directory directory = new RAMDirectory(); var analyzer = new StandardAnalyzer(LuceneVersion.LUCENE_48); var config = new IndexWriterConfig(LuceneVersion.LUCENE_48, analyzer); IndexWriter indexWriter = new IndexWriter(directory, config); #endregion #region Add Docs to Index #region Setup Group End Field FieldType groupEndFieldType = new FieldType(); groupEndFieldType.IsStored = false; groupEndFieldType.IsTokenized = false; groupEndFieldType.IsIndexed = true; groupEndFieldType.IndexOptions = IndexOptions.DOCS_ONLY; groupEndFieldType.OmitNorms = true; Field groupEndField = new Field("groupEnd", "x", groupEndFieldType); #endregion List <Document> documentList = new List <Document>(); Document doc = new Document(); doc.Add(new StringField("BookId", "B1", Field.Store.YES)); doc.Add(new StringField("Category", "Cat 1", Field.Store.YES)); doc.Add(new Int32Field("Repetition", 1, Field.Store.YES)); documentList.Add(doc); doc = new Document(); doc.Add(new StringField("BookId", "B2", Field.Store.YES)); doc.Add(new StringField("Category", "Cat 1", Field.Store.YES)); doc.Add(new Int32Field("Repetition", 1, Field.Store.YES)); documentList.Add(doc); doc.Add(groupEndField); indexWriter.AddDocuments(documentList); documentList = new List <Document>(); doc = new Document(); doc.Add(new StringField("BookId", "B3", Field.Store.YES)); doc.Add(new StringField("Category", "Cat 2", Field.Store.YES)); doc.Add(new Int32Field("Repetition", 2, Field.Store.YES)); documentList.Add(doc); doc.Add(groupEndField); indexWriter.AddDocuments(documentList); indexWriter.Dispose(); #endregion //BasicFindRepByNumericRange(directory); //LookupGroupsByIntAlt(directory); TwoPassGroupingSearch(directory); directory.Dispose(); }