public void SetDefaultIndex(string name)
{
Check.DoRequireArgumentNotBlank(name, nameof(name));
Check.DoCheckArgument(MultiIndex.GetIndex(name) != null, () => $"Index {name} does not exist.");
MultiIndex.DefaultIndexName = name;
}
public IList <THeader> Search(string queryText, int maxResults)
{
Log.DebugFormat("Searching '{0}', maxResults = {1}", queryText, maxResults);
var result = MultiIndex.Search(EntityAdapter.SearchFieldName, queryText, maxResults);
return(EntityAdapter.GetHeaders(result));
}
public void Delete(params THeader[] docHeaders)
{
var terms = docHeaders.Select(h => EntityAdapter.GetKeyTerm(h)).ToArray();
if (terms.Length > 0)
{
MultiIndex.Delete(terms);
}
}
/// <summary>
/// Get top <paramref name="maxResults"/> documents in the period filtered and sorted in descending order by <paramref name="searchableDocumentTime"/>.
/// </summary>
/// <param name="periodStart">
/// Inclusive, truncated to seconds.
/// </param>
/// <param name="periodEnd">
/// Exclusive, truncated to seconds.
/// </param>
/// <param name="maxResults">
/// Max number of documents to return.
/// </param>
/// <param name="searchableDocumentTime">
/// One of the supported document time properties to filter on.
/// </param>
public IList <THeader> GetTopInPeriod(DateTime?periodStart, DateTime?periodEnd, int maxResults, SearchableDocumentTime searchableDocumentTime = SearchableDocumentTime.LastUpdate)
{
var timeFieldName = searchableDocumentTime == SearchableDocumentTime.Creation
? EntityAdapter.CreationTimeFieldName
: EntityAdapter.LastUpdateTimeFieldName;
Check.DoCheckArgument(!string.IsNullOrEmpty(timeFieldName), () => $"{searchableDocumentTime} time is not searchable");
return(EntityAdapter.GetHeaders(MultiIndex.GetTopInPeriod(timeFieldName, periodStart, periodEnd, maxResults)));
}
public void RemoveIndex(string name)
{
Check.DoRequireArgumentNotBlank(name, nameof(name));
var path = GetIndexRootFolder(name);
MultiIndex.RemoveIndex(name);
Directory.Delete(path, true);
}
public void AddOrOpenIndex(string stemmerName)
{
Check.DoRequireArgumentNotNull(stemmerName, nameof(stemmerName));
Log.InfoFormat($"Adding index {0}", stemmerName);
Check.DoCheckArgument(MultiIndex.GetIndex(stemmerName) == null, () => $"Index {stemmerName} is already active");
var info = SearchEngine.AddOrOpenSnowballIndex(stemmerName);
SearchEngine.RebuildIndex(stemmerName, Storage.GetAll(), Storage.CountAll());
info.LuceneIndex.Commit();
}
private bool _disposedValue; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!_disposedValue)
{
if (disposing)
{
// dispose managed state (managed objects).
MultiIndex?.Dispose();
}
// free unmanaged resources (unmanaged objects) and override a finalizer below.
// set large fields to null.
_disposedValue = true;
}
}
public static NoteStorage CreateStandard(LiteDatabase database, string rootDirectoryPath, bool updateLastUpdateAutomatically = false)
{
Check.DoRequireArgumentNotNull(database, nameof(database));
Check.DoRequireArgumentNotNull(rootDirectoryPath, nameof(rootDirectoryPath));
var fulltextPath = Path.Combine(rootDirectoryPath, "ft");
Directory.CreateDirectory(fulltextPath);
var luceneAdapter = new LuceneNoteAdapter();
var storage = new LiteDbStorage <Note>(database, new NoteAdapter(updateLastUpdateAutomatically));
var multiIndex = new MultiIndex(luceneAdapter.DocumentKeyName);
var searchEngine = new SearchEngine <Note, INoteHeader, string>(fulltextPath, luceneAdapter, multiIndex);
var result = new NoteStorage(storage, searchEngine)
{
RootPath = rootDirectoryPath
};
return(result);
}
/// <summary>
/// Sets index as default if it's the first one.
/// </summary>
/// <param name="name">
/// Index name translated into name of the folder under FT catalog directory
/// </param>
/// <param name="analyzer">
/// </param>
/// <param name="dropExisting">
/// Whether to drop existing index if exists
/// </param>
/// <returns>
/// The new index
/// </returns>
public IndexInformation AddOrOpenIndex(string name, Analyzer analyzer, bool dropExisting = false)
{
Check.DoCheckArgument(MultiIndex.GetIndex(name) == null, () => "Index already open");
Check.DoRequireArgumentNotBlank(name, nameof(name));
Check.DoRequireArgumentNotNull(analyzer, nameof(analyzer));
var result = new IndexInformation(name);
var indexDirectoryPath = GetIndexRootFolder(name);
var dirInfo = new DirectoryInfo(indexDirectoryPath);
result.IsNew = !dirInfo.Exists;
if (!result.IsNew)
{
dirInfo.Create();
}
else if (dropExisting)
{
dirInfo.Delete(true);
}
var luceneDir = LuceneIndex.PreparePersistentDirectory(indexDirectoryPath);
var newIndex = new LuceneIndex(indexDirectoryPath, analyzer, luceneDir, EntityAdapter.DocumentKeyName);
MultiIndex.AddIndex(name, newIndex);
if (MultiIndex.IndexCount == 1)
{
SetDefaultIndex(name);
}
return(result);
}
public void CommitFulltextIndex()
{
MultiIndex.Commit();
}
public void Delete(params string[] keys)
{
MultiIndex.Delete(keys[0]);
}
public void Add(params TDoc[] docs)
{
var luceneDocs = EntityAdapter.GetIndexedDocuments(docs);
MultiIndex.Add(luceneDocs);
}
/// <summary>
/// Rebuild all specified indexes
/// </summary>
/// <param name="indexNames"></param>
/// <param name="documents">
/// All documents in the database; collection not expected to be fully loaded into RAM
/// </param>
/// <param name="docCount">
/// Optional, total number of documents for progress reporting
/// </param>
/// <param name="progressReporter">
/// Optional delegate receiving progress report.
/// </param>
public void RebuildIndexes(IEnumerable <string> indexNames, IEnumerable <TDoc> documents, int docCount = -1, Action <double> progressReporter = null)
{
MultiIndex.RebuildIndexes(indexNames, EntityAdapter.GetIndexedDocuments(documents), docCount, progressReporter);
}
