/// <summary>Merges the named range of segments, replacing them in the stack with a
/// single segment.
/// </summary>
private void MergeSegments(int minSegment, int end)
{
System.String mergedName = NewSegmentName();
if (infoStream != null)
{
infoStream.Write("merging segments");
}
SegmentMerger merger = new SegmentMerger(this, mergedName);
System.Collections.ArrayList segmentsToDelete = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10));
for (int i = minSegment; i < end; i++)
{
SegmentInfo si = segmentInfos.Info(i);
if (infoStream != null)
{
infoStream.Write(" " + si.name + " (" + si.docCount + " docs)");
}
IndexReader reader = SegmentReader.Get(si);
merger.Add(reader);
if ((reader.Directory() == this.directory) || (reader.Directory() == this.ramDirectory))
{
segmentsToDelete.Add(reader); // queue segment for deletion
}
}
int mergedDocCount = merger.Merge();
if (infoStream != null)
{
infoStream.WriteLine(" into " + mergedName + " (" + mergedDocCount + " docs)");
}
for (int i = end - 1; i >= minSegment; i--)
{
// remove old infos & add new
segmentInfos.RemoveAt(i);
}
segmentInfos.Add(new SegmentInfo(mergedName, mergedDocCount, directory));
// close readers before we attempt to delete now-obsolete segments
merger.CloseReaders();
lock (directory)
{
// in- & inter-process sync
new AnonymousClassWith3(segmentsToDelete, this, directory.MakeLock(COMMIT_LOCK_NAME), COMMIT_LOCK_TIMEOUT).Run();
}
if (useCompoundFile)
{
System.Collections.ArrayList filesToDelete = merger.CreateCompoundFile(mergedName + ".tmp");
lock (directory)
{
// in- & inter-process sync
new AnonymousClassWith4(mergedName, filesToDelete, this, directory.MakeLock(COMMIT_LOCK_NAME), COMMIT_LOCK_TIMEOUT).Run();
}
}
}
public SuggestionQueryIndexExtension(
string key,
IndexReader reader,
StringDistance distance,
string field,
float accuracy)
{
this.key = key;
this.field = field;
if(reader.Directory() is RAMDirectory)
{
directory = new RAMDirectory();
}
else
{
directory = FSDirectory.Open(new DirectoryInfo(key));
}
this.spellChecker = new SpellChecker.Net.Search.Spell.SpellChecker(directory, distance);
this.spellChecker.SetAccuracy(accuracy);
}
private void CloseInternalReader(bool trace, IndexReader subReader, bool finalClose)
{
ReaderData readerData;
// TODO: can we avoid the lock?
lock (semaphoreIndexReaderLock)
{
readerData = searchIndexReaderSemaphores[subReader];
}
if (readerData == null)
{
log.Error("Trying to close a Lucene IndexReader not present: " + subReader.Directory());
// TODO: Should we try to close?
return;
}
// Acquire the locks in the same order as everywhere else
object directoryProviderLock = perDirectoryProviderManipulationLocks[readerData.Provider];
bool closeReader = false;
lock (directoryProviderLock)
{
IndexReader reader;
bool isActive = activeSearchIndexReaders.TryGetValue(readerData.Provider, out reader)
&& reader == subReader;
if (trace) log.Info("IndexReader not active: " + subReader);
lock (semaphoreIndexReaderLock)
{
readerData = searchIndexReaderSemaphores[subReader];
if (readerData == null)
{
log.Error("Trying to close a Lucene IndexReader not present: " + subReader.Directory());
// TODO: Should we try to close?
return;
}
//final close, the semaphore should be at 0 already
if (!finalClose)
{
readerData.Semaphore--;
if (trace)
log.Info("Semaphore decreased to: " + readerData.Semaphore + " for " + subReader);
}
if (readerData.Semaphore < 0)
log.Error("Semaphore negative: " + subReader.Directory());
if (!isActive && readerData.Semaphore == 0)
{
searchIndexReaderSemaphores.Remove(subReader);
closeReader = true;
}
else
closeReader = false;
}
}
if (closeReader)
{
if (trace) log.Info("Closing IndexReader: " + subReader);
try
{
subReader.Close();
}
catch (IOException e)
{
log.Warn("Unable to close Lucene IndexReader", e);
}
}
}
public override Directory Directory()
{
return(in_Renamed.Directory());
}
/// <summary> <p>Construct a FilterIndexReader based on the specified base reader.
/// Directory locking for delete, undeleteAll, and setNorm operations is
/// left to the base reader.</p>
/// <p>Note that base reader is closed if this FilterIndexReader is closed.</p>
/// </summary>
/// <param name="in">specified base reader.
/// </param>
public FilterIndexReader(IndexReader in_Renamed)
: base(in_Renamed.Directory())
{
this.in_Renamed = in_Renamed;
}
/// <summary> <p>Construct a FilterIndexReader based on the specified base reader.
/// Directory locking for delete, undeleteAll, and setNorm operations is
/// left to the base reader.</p>
/// <p>Note that base reader is closed if this FilterIndexReader is closed.</p>
/// </summary>
/// <param name="in">specified base reader.
/// </param>
public FilterIndexReader(IndexReader in_Renamed) : base(in_Renamed.Directory())
{
this.in_Renamed = in_Renamed;
}
/// <summary>
/// Gets the similar words.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="fieldName">Name of the field.</param>
/// <param name="word">The word.</param>
/// <returns></returns>
private static string[] SuggestSimilar(IndexReader reader, string fieldName, string word)
{
var spell = new SpellChecker.Net.Search.Spell.SpellChecker(reader.Directory());
spell.IndexDictionary(new LuceneDictionary(reader, fieldName));
var similarWords = spell.SuggestSimilar(word, 2);
// now make sure to close the spell checker
spell.Close();
return similarWords;
}
public override DocIdSet GetDocIdSet(IndexReader reader)
{
DocIdSet docs = null;
// TODO: override by SinSay
var cache = IdSetCache.GetCache(reader.Directory().ToString(), this.fieldName);
if (cache != null)
{
return cache.Cache;
}
if (processingMode == PM_FAST_INVALIDATION)
{
docs = FastBits(reader);
}
else
{
docs = CorrectBits(reader);
}
return docs;
}
