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