public static IndexWriter GetIndexWriter(string indexpath, Dictionary <string, Analyzer> customAnalyzerDict = null)
{
#region initialize analyzer
Analyzer analyzer;
if (customAnalyzerDict == null)
{
analyzer = standardAnalyzer;
}
else
{
var perFieldAnalyzer = new PerFieldAnalyzerWrapper(standardAnalyzer);
foreach (var kvp in customAnalyzerDict)
{
perFieldAnalyzer.AddAnalyzer(kvp.Key, kvp.Value);
}
analyzer = perFieldAnalyzer;
}
#endregion
FileOperations.EnsureFileFolderExist(indexpath);
IndexWriter indexwriter = new IndexWriter(FSDirectory.Open(new DirectoryInfo(indexpath)),
analyzer, true, IndexWriter.MaxFieldLength.UNLIMITED);
return(indexwriter);
}
protected override Analyzer GetAnalyzer(Net.Util.Version version)
{
analyzer = new PerFieldAnalyzerWrapper(base.GetAnalyzer(version));
analyzer.AddAnalyzer <SampleDocument>(t => t.Id, new KeywordAnalyzer());
analyzer.AddAnalyzer <SampleDocument>(t => t.Key, new LowercaseKeywordAnalyzer());
return(analyzer);
}
private void configureBexisIndexing(bool recreateIndex)
{
configXML = new XmlDocument();
configXML.Load(FileHelper.ConfigFilePath);
LoadBeforeIndexing();
pathIndex = FSDirectory.Open(new DirectoryInfo(luceneIndexPath));
autoCompleteIndex = FSDirectory.Open(new DirectoryInfo(autoCompleteIndexPath));
using (var bexisAnalyzer = new BexisAnalyzer())
using (var nGramAnalyzer = new NGramAnalyzer())
using (PerFieldAnalyzerWrapper analyzer = new PerFieldAnalyzerWrapper(bexisAnalyzer))
{
indexWriter = new IndexWriter(pathIndex, analyzer, recreateIndex, IndexWriter.MaxFieldLength.UNLIMITED);
autoCompleteIndexWriter = new IndexWriter(autoCompleteIndex, nGramAnalyzer, recreateIndex, IndexWriter.MaxFieldLength.UNLIMITED);
foreach (XmlNode a in categoryXmlNodeList)
{
analyzer.AddAnalyzer("ng_" + a.Attributes.GetNamedItem("lucene_name").Value, nGramAnalyzer);
}
analyzer.AddAnalyzer("ng_all", nGramAnalyzer);
isIndexConfigured = true;
}
}
public IList <long> Search(NuixLogRepo repo, string queryString)
{
// Lucene seems to be picky about lower case for some things?
Regex notFix = new Regex(@"\bnot\b", RegexOptions.Compiled);
queryString = notFix.Replace(queryString, "NOT");
// Emtpy query is all items, we return a special collection that pretends to be a full list of ID values
// but that is actually just based on the range of possible values.
if (string.IsNullOrWhiteSpace(queryString))
{
return(new AllEntriesIDList((int)repo.Database.TotalRecords));
}
else
{
luceneDirectory = FSDirectory.Open(IndexDirectory);
analyzer = getAnalyzer();
IndexSearcher searcher = new IndexSearcher(luceneDirectory);
Query query = parseQuery(queryString);
var hitsFound = searcher.Search(query, int.MaxValue);
long[] ids = new long[hitsFound.TotalHits];
for (int i = 0; i < hitsFound.TotalHits; i++)
{
Document doc = searcher.Doc(hitsFound.ScoreDocs[i].Doc);
ids[i] = long.Parse(doc.Get("id"));
}
luceneDirectory.Dispose();
searcher.Dispose();
analyzer.Dispose();
return(ids);
}
}
/// <summary>
/// Detects untokenized fields and sets as NotAnalyzed in analyzer
/// </summary>
private static string PreProcessUntokenizedTerms(PerFieldAnalyzerWrapper analyzer, string query, Analyzer keywordAnlyzer)
{
var untokenizedMatches = untokenizedQuery.Matches(query);
if (untokenizedMatches.Count < 1)
{
return(query);
}
var sb = new StringBuilder(query);
// KeywordAnalyzer will not tokenize the values
// process in reverse order to leverage match string indexes
for (int i = untokenizedMatches.Count; i > 0; i--)
{
Match match = untokenizedMatches[i - 1];
// specify that term for this field should not be tokenized
analyzer.AddAnalyzer(match.Groups[1].Value, keywordAnlyzer);
Group term = match.Groups[2];
// remove enclosing "[[" "]]" from term value (again in reverse order)
sb.Remove(term.Index + term.Length - 2, 2);
sb.Remove(term.Index, 2);
}
return(sb.ToString());
}
protected override Analyzer GetAnalyzer(Net.Util.Version version)
{
var analyzer = new PerFieldAnalyzerWrapper(base.GetAnalyzer(version));
analyzer.AddAnalyzer("Path", new LowercaseKeywordAnalyzer());
return(analyzer);
}
public int Count(NuixLogRepo repo, string queryString)
{
// Lucene seems to be picky about lower case for some things?
Regex notFix = new Regex(@"\bnot\b", RegexOptions.Compiled);
queryString = notFix.Replace(queryString, "NOT");
// Blank query means all items
if (string.IsNullOrWhiteSpace(queryString))
{
return((int)repo.Database.TotalRecords);
}
else
{
luceneDirectory = FSDirectory.Open(IndexDirectory);
analyzer = getAnalyzer();
IndexSearcher searcher = new IndexSearcher(luceneDirectory);
Query query = parseQuery(queryString);
var hitsFound = searcher.Search(query, int.MaxValue);
int hitCount = hitsFound.TotalHits;
luceneDirectory.Dispose();
searcher.Dispose();
analyzer.Dispose();
return(hitCount);
}
}
public static Query BuildQuery(string query, IndexQuery indexQuery, PerFieldAnalyzerWrapper analyzer)
{
var originalQuery = query;
try
{
var queryParser = new RangeQueryParser(Version.LUCENE_29, indexQuery.DefaultField ?? string.Empty, analyzer)
{
DefaultOperator = indexQuery.DefaultOperator == QueryOperator.Or
? QueryParser.Operator.OR
: QueryParser.Operator.AND,
AllowLeadingWildcard = true
};
query = PreProcessUntokenizedTerms(query, queryParser);
query = PreProcessSearchTerms(query);
query = PreProcessDateTerms(query, queryParser);
var generatedQuery = queryParser.Parse(query);
generatedQuery = HandleMethods(generatedQuery);
return(generatedQuery);
}
catch (ParseException pe)
{
if (originalQuery == query)
{
throw new ParseException("Could not parse: '" + query + "'", pe);
}
throw new ParseException("Could not parse modified query: '" + query + "' original was: '" + originalQuery + "'", pe);
}
}
internal static Analyzer GetAnalyzer()
{
//var masterAnalyzer = new PerFieldAnalyzerWrapper(new KeywordAnalyzer());
////TODO: Lucene_FullText2 is failed with new WhitespaceAnalyzer
////masterAnalyzer.AddAnalyzer(LucObject.FieldName.AllText, new WhitespaceAnalyzer());
//masterAnalyzer.AddAnalyzer(LucObject.FieldName.AllText, new StandardAnalyzer());
//return masterAnalyzer;
// Field Analyzer
// -----------------------------------------------------------------
// Name Lucene.Net.Analysis.KeywordAnalyzer
// Path Lucene.Net.Analysis.KeywordAnalyzer
// Keywords Lucene.Net.Analysis.StopAnalyzer
// _Text Lucene.Net.Analysis.Standard.StandardAnalyzer
// -----------------------------------------------------------------
// Default Lucene.Net.Analysis.WhitespaceAnalyzer
var masterAnalyzer = new PerFieldAnalyzerWrapper(new KeywordAnalyzer());
foreach (var item in SenseNet.ContentRepository.Storage.StorageContext.Search.SearchEngine.GetAnalyzers())
{
masterAnalyzer.AddAnalyzer(item.Key, (Analyzer)Activator.CreateInstance(item.Value));
}
masterAnalyzer.AddAnalyzer(LucObject.FieldName.AllText, new StandardAnalyzer());
//masterAnalyzer.AddAnalyzer(LucObject.FieldName.AllText, new StandardAnalyzer(SenseNet.Search.Indexing.LuceneManager.LuceneVersion));
return(masterAnalyzer);
}
private Analyzer GenerateArticleAnalyzer()
{
IDictionary <String, Analyzer> analyzerPerField = new Dictionary <string, Analyzer>();
var entity = new ArticleCacheEntity();
analyzerPerField.Add(nameof(entity.AdvisorId).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.AllAuthorIds).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.ArticleId).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.ArticleTypeId).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.AuthorId).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.ClassId).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.CrawlHistoryId).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.GrandParentSourceId).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.MainArticleTypeId).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.ParentSourceId).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.SourceId).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.SupervisorId).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.IsArticle).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.IsDeleted).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.AuthorName).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.University).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.MagazineName).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.MagazineId).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.Keyword).ToLower(), new KeywordAnalyzer());
analyzerPerField.Add(nameof(entity.ClassIsDeleted).ToLower(), new KeywordAnalyzer());
PerFieldAnalyzerWrapper aWrapper =
new PerFieldAnalyzerWrapper(new CustomAnalyzer(), analyzerPerField);
return(aWrapper);
}
private static void LoadAnalyzer()
{
string[] stopWords = new string[0];
PerFieldAnalyzerWrapper perFieldAnalyzerWrapper = new PerFieldAnalyzerWrapper(new StandardAnalyzer(IndexingServiceSettings.LuceneVersion, StopFilter.MakeStopSet(stopWords)));
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.IdFieldName, new KeywordAnalyzer());
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.CultureFieldName, new KeywordAnalyzer());
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.ReferenceIdFieldName, new KeywordAnalyzer());
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.AuthorStorageFieldName, new KeywordAnalyzer());
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.CategoriesFieldName, new WhitespaceAnalyzer());
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.AclFieldName, new WhitespaceAnalyzer());
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.VirtualPathFieldName, new WhitespaceAnalyzer());
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.TypeFieldName, new WhitespaceAnalyzer());
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.CreatedFieldName, new WhitespaceAnalyzer());
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.ModifiedFieldName, new WhitespaceAnalyzer());
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.PublicationEndFieldName, new WhitespaceAnalyzer());
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.PublicationStartFieldName, new WhitespaceAnalyzer());
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.ItemStatusFieldName, new WhitespaceAnalyzer());
Analyzer analyzer = new StandardAnalyzer(IndexingServiceSettings.LuceneVersion, StopFilter.MakeStopSet(stopWords));
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.TitleFieldName, analyzer);
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.DisplayTextFieldName, analyzer);
perFieldAnalyzerWrapper.AddAnalyzer(IndexingServiceSettings.AuthorsFieldName, analyzer);
perFieldAnalyzerWrapper.AddAnalyzer(DefaultFieldName, analyzer);
IndexingServiceSettings._analyzer = perFieldAnalyzerWrapper;
}
static void Main(string[] args)
{
RAMDirectory dir = new RAMDirectory();
var perFieldAnalyzer = new PerFieldAnalyzerWrapper(new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30));
perFieldAnalyzer.AddAnalyzer("ExactTitle", new LowercaseKeywordAnalyzer());
IndexWriter indexWriter = new IndexWriter(dir, perFieldAnalyzer, IndexWriter.MaxFieldLength.UNLIMITED);
Document reportDoc = new Document();
Field exactTitleField = new Field("ExactTitle",
"Test Abc",
Field.Store.NO,
Field.Index.ANALYZED);
reportDoc.Add(exactTitleField);
indexWriter.AddDocument(reportDoc);
indexWriter.Commit();
IndexSearcher searcher = new IndexSearcher(indexWriter.GetReader());
var term = new Term("ExactTitle", "test abc"); //note: for this to work this way you need to always lower case the search too
var exactQuery = new TermQuery(term);
var hits = searcher.Search(exactQuery, null, 25, Sort.RELEVANCE);
Console.WriteLine(hits.TotalHits); // prints "1"
Console.ReadLine();
indexWriter.Close();
}
private Query GetLuceneQuery(string query, string defaultField)
{
Query luceneQuery;
if (String.IsNullOrEmpty(query))
{
logQuerying.Debug("Issuing query on index {0} for all documents", parent.name);
luceneQuery = new MatchAllDocsQuery();
}
else
{
logQuerying.Debug("Issuing query on index {0} for: {1}", parent.name, query);
var toDispose = new List <Action>();
PerFieldAnalyzerWrapper searchAnalyzer = null;
try
{
searchAnalyzer = parent.CreateAnalyzer(new LowerCaseKeywordAnalyzer(), toDispose, true);
searchAnalyzer = parent.AnalyzerGenerators.Aggregate(searchAnalyzer, (currentAnalyzer, generator) =>
{
Analyzer newAnalyzer = generator.GenerateAnalzyerForQuerying(parent.name, indexQuery.Query, currentAnalyzer);
if (newAnalyzer != currentAnalyzer)
{
DisposeAnalyzerAndFriends(toDispose, currentAnalyzer);
}
return(parent.CreateAnalyzer(newAnalyzer, toDispose, true));
});
luceneQuery = QueryBuilder.BuildQuery(query, defaultField, searchAnalyzer);
}
finally
{
DisposeAnalyzerAndFriends(toDispose, searchAnalyzer);
}
}
return(luceneQuery);
}
/// <summary>
/// Initalize all analyzers for search service
/// </summary>
/// <param name="indexingServiceSettingsType"></param>
/// <param name="luceneVersion"></param>
public virtual void Initialize(Type indexingServiceSettingsType, Lucene.Net.Util.Version luceneVersion, ISearchAnalyzers analyzers)
{
var defaultAnalyzer = analyzers.DefaultAnalyzer;
var textAnalyzer = analyzers.TextAnalyzer;
PerFieldAnalyzerWrapper fieldAnalyzerWrapper = new PerFieldAnalyzerWrapper(defaultAnalyzer);
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_ID", new KeywordAnalyzer());
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_CULTURE", new KeywordAnalyzer());
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_REFERENCEID", new KeywordAnalyzer());
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_AUTHORSTORAGE", new KeywordAnalyzer());
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_CATEGORIES", new WhitespaceAnalyzer());
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_ACL", new WhitespaceAnalyzer());
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_VIRTUALPATH", new WhitespaceAnalyzer());
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_TYPE", new WhitespaceAnalyzer());
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_CREATED", new WhitespaceAnalyzer());
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_MODIFIED", new WhitespaceAnalyzer());
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_PUBLICATIONEND", new WhitespaceAnalyzer());
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_PUBLICATIONSTART", new WhitespaceAnalyzer());
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_ITEMSTATUS", new WhitespaceAnalyzer());
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_TITLE", textAnalyzer);
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_DISPLAYTEXT", textAnalyzer);
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_AUTHORS", textAnalyzer);
fieldAnalyzerWrapper.AddAnalyzer("EPISERVER_SEARCH_DEFAULT", textAnalyzer);
// Replace default analyzer
indexingServiceSettingsType
.GetField("_analyzer", BindingFlags.Static | BindingFlags.NonPublic)
.SetValue(null, fieldAnalyzerWrapper);
}
/**
* @param language
* @return
*/
protected Analyzer GetAnalyzerForLanguage(string language)
{
Analyzer contentAnalyzer = null;
Analyzer defaultAnalyzer = null;
PerFieldAnalyzerWrapper perFieldAnalyzer = null;
switch (language)
{
case "de":
contentAnalyzer = new GermanAnalyzer();
break;
case "eo":
contentAnalyzer = new EsperantoAnalyzer();
break;
case "ru":
contentAnalyzer = new RussianAnalyzer();
break;
}
if (contentAnalyzer == null)
{
contentAnalyzer = new EnglishAnalyzer();
}
if (defaultAnalyzer == null)
{
defaultAnalyzer = new SimpleAnalyzer();
}
perFieldAnalyzer = new PerFieldAnalyzerWrapper(defaultAnalyzer);
perFieldAnalyzer.AddAnalyzer("contents", contentAnalyzer);
return(perFieldAnalyzer);
}
private void CreateIndexer()
{
ServiceLocator.Resolve <UIPackage>();
ServiceLocator.RegisterInstance(new IndexFilterManager());
PerFieldAnalyzerWrapper analyzer = new PerFieldAnalyzerWrapper(new SnowballAnalyzer("English"));
analyzer.AddAnalyzer(SandoField.Source.ToString(), new KeywordAnalyzer());
analyzer.AddAnalyzer(SandoField.AccessLevel.ToString(), new KeywordAnalyzer());
analyzer.AddAnalyzer(SandoField.ProgramElementType.ToString(), new KeywordAnalyzer());
ServiceLocator.RegisterInstance <Analyzer>(analyzer);
var currentIndexer = new DocumentIndexer(TimeSpan.FromSeconds(10), GetTimeToCommit());
ServiceLocator.RegisterInstance(currentIndexer);
ServiceLocator.RegisterInstance(new IndexUpdateManager());
currentIndexer.ClearIndex();
ServiceLocator.Resolve <InitialIndexingWatcher>().InitialIndexingStarted();
var dictionary = new DictionaryBasedSplitter();
dictionary.Initialize(PathManager.Instance.GetIndexPath(ServiceLocator.Resolve <SolutionKey>()));
var reformer = new QueryReformerManager(dictionary);
reformer.Initialize(null);
ServiceLocator.RegisterInstance(reformer);
var history = new SearchHistory();
history.Initialize(PathManager.Instance.GetIndexPath
(ServiceLocator.Resolve <SolutionKey>()));
ServiceLocator.RegisterInstance(history);
}
private Query GetLuceneQuery(IndexQuery indexQuery)
{
var query = indexQuery.Query;
Query luceneQuery;
if (string.IsNullOrEmpty(query))
{
log.DebugFormat("Issuing query on index {0} for all documents", name);
luceneQuery = new MatchAllDocsQuery();
}
else
{
log.DebugFormat("Issuing query on index {0} for: {1}", name, query);
var toDispose = new List <Action>();
PerFieldAnalyzerWrapper analyzer = null;
try
{
analyzer = CreateAnalyzer(toDispose);
luceneQuery = QueryBuilder.BuildQuery(query, analyzer);
}
finally
{
if (analyzer != null)
{
analyzer.Close();
}
foreach (var dispose in toDispose)
{
dispose();
}
}
}
return(luceneQuery);
}
private void AddFieldsAnalyzer(PerFieldAnalyzerWrapper analyzer, Analyzer fanalyzer, String[] fields)
{
foreach (var f in fields)
{
analyzer.AddAnalyzer(f, fanalyzer);
}
}
protected override Analyzer GetAnalyzer(Net.Util.Version version)
{
var a = new PerFieldAnalyzerWrapper(base.GetAnalyzer(version));
a.AddAnalyzer("Version", new KeywordAnalyzer());
a.AddAnalyzer("Flag", new KeywordAnalyzer());
return(a);
}
/// <summary>
/// Get the query resulted from an Hebrew Analyzer
/// </summary>
/// <param name="text"></param>
/// <param name="searchType"></param>
/// <returns></returns>
private static Query GetMorphAnalyzedQuery(string text, List <string> searchType)
{
PerFieldAnalyzerWrapper pfAnalyzer = new PerFieldAnalyzerWrapper(new MorphAnalyzer(ConfigurationController.MorphFilesPath));
MultiFieldQueryParser mParser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30, searchType.ToArray(), pfAnalyzer);
return(GetQueryFromText(text, mParser));
}
/// <summary>
/// Get the query resulted from a Spanish Analyzer
/// </summary>
/// <param name="text"></param>
/// <param name="searchType"></param>
/// <returns></returns>
public static Query GetSpanishAnalyzedQuery(string text, List <string> searchType)
{
PerFieldAnalyzerWrapper pfAnalyzer = new PerFieldAnalyzerWrapper(new SpanishAnalyzer(ConfigurationController.Stop_Words));
MultiFieldQueryParser mParser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_29, searchType.ToArray(), pfAnalyzer);
return(GetQueryFromText(text, mParser));
}
protected void Initialize(ILuceneIndex index, bool close)
{
Assert.ArgumentNotNull(index, "index");
PerFieldAnalyzerWrapper aw = new PerFieldAnalyzerWrapper(index.Analyzer);
aw.AddAnalyzer("_language", new KeywordAnalyzer());
this._analyzer = aw;
Assert.IsNotNull(this._analyzer, "Failed to request analyzer from the index");
}
public bool Open()
{
_writer = new IndexWriter(_index_path, new StandardAnalyzer(), _create_index);
_default_analyzer = new PerFieldAnalyzerWrapper(new StandardAnalyzer());
_default_analyzer.AddAnalyzer("contents", new SourceCodeAnalyzer());
_default_analyzer.AddAnalyzer("path2", new PathAnalyzer());
return(true);
}
public PerFieldAnalyzerWrapper CreateAnalyzer(Analyzer defaultAnalyzer, ICollection <Action> toDispose, bool forQuerying = false)
{
toDispose.Add(defaultAnalyzer.Close);
//string value;
//if (indexDefinition.Analyzers.TryGetValue(Constants.AllFields, out value))
//{
// defaultAnalyzer = IndexingExtensions.CreateAnalyzerInstance(Constants.AllFields, value);
// toDispose.Add(defaultAnalyzer.Close);
//}
var perFieldAnalyzerWrapper = new PerFieldAnalyzerWrapper(defaultAnalyzer);
foreach (var analyzer in indexDefinition.Analyzers)
{
//Analyzer analyzerInstance = IndexingExtensions.CreateAnalyzerInstance(analyzer.Key, analyzer.Value);
//toDispose.Add(analyzerInstance.Close);
//if (forQuerying)
//{
// var customAttributes = analyzerInstance.GetType().GetCustomAttributes(typeof(NotForQueryingAttribute), false);
// if (customAttributes.Length > 0)
// continue;
//}
//perFieldAnalyzerWrapper.AddAnalyzer(analyzer.Key, analyzerInstance);
}
StandardAnalyzer standardAnalyzer = null;
KeywordAnalyzer keywordAnalyzer = null;
foreach (var fieldIndexing in indexDefinition.Indexes)
{
switch (fieldIndexing.Value)
{
case FieldIndexing.NotAnalyzed:
if (keywordAnalyzer == null)
{
keywordAnalyzer = new KeywordAnalyzer();
toDispose.Add(keywordAnalyzer.Close);
}
perFieldAnalyzerWrapper.AddAnalyzer(fieldIndexing.Key, keywordAnalyzer);
break;
case FieldIndexing.Analyzed:
if (indexDefinition.Analyzers.ContainsKey(fieldIndexing.Key))
{
continue; // already added
}
if (standardAnalyzer == null)
{
standardAnalyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
toDispose.Add(standardAnalyzer.Close);
}
perFieldAnalyzerWrapper.AddAnalyzer(fieldIndexing.Key, standardAnalyzer);
break;
}
}
return(perFieldAnalyzerWrapper);
}
/// <summary>
/// Gets the customized Analyzer used for indexing and searching.
/// </summary>
/// <returns>Customized analyzer</returns>
private PerFieldAnalyzerWrapper getAnalyzer()
{
PerFieldAnalyzerWrapper analyzer = new PerFieldAnalyzerWrapper(new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30));
// Use WhitespaceAnalyzer for flags field so underscored terms are not split apart
analyzer.AddAnalyzer("flag", new WhitespaceAnalyzer());
return(analyzer);
}
private Analyzer GetAnalyzer()
{
PerFieldAnalyzerWrapper analyzer = new PerFieldAnalyzerWrapper(new SnowballAnalyzer("English"));
analyzer.AddAnalyzer(SandoField.Source.ToString(), new KeywordAnalyzer());
analyzer.AddAnalyzer(SandoField.AccessLevel.ToString(), new KeywordAnalyzer());
analyzer.AddAnalyzer(SandoField.ProgramElementType.ToString(), new KeywordAnalyzer());
return(analyzer);
}
/// <summary>
/// Indexes the document.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="document">The document.</param>
/// <param name="indexName">Name of the index.</param>
/// <param name="mappingType">Type of the mapping.</param>
public override void IndexDocument <T>(T document, string indexName = null, string mappingType = null)
{
try
{
Type documentType = document.GetType();
if (indexName == null)
{
indexName = documentType.Name.ToLower();
}
if (mappingType == null)
{
mappingType = documentType.Name.ToLower();
}
if (!_indexes.ContainsKey(mappingType))
{
CreateIndex(documentType);
}
var index = _indexes[mappingType];
Document doc = new Document();
foreach (var typeMappingProperty in index.MappingProperties.Values)
{
TextField textField = new TextField(typeMappingProperty.Name, documentType.GetProperty(typeMappingProperty.Name).GetValue(document, null).ToStringSafe().ToLower(), global::Lucene.Net.Documents.Field.Store.YES);
textField.Boost = typeMappingProperty.Boost;
doc.Add(textField);
}
IndexModelBase docIndexModelBase = document as IndexModelBase;
string indexValue = LuceneID(mappingType, docIndexModelBase.Id);
doc.AddStringField("type", mappingType, global::Lucene.Net.Documents.Field.Store.YES);
doc.AddStringField("id", docIndexModelBase.Id.ToString(), global::Lucene.Net.Documents.Field.Store.YES);
doc.AddStringField("index", indexValue, global::Lucene.Net.Documents.Field.Store.YES);
// Stores all the properties as JSON to retrieve object on lookup.
doc.AddStoredField("JSON", document.ToJson());
// Use the analyzer in fieldAnalyzers if that field is in that dictionary, otherwise use StandardAnalyzer.
var analyzer = new PerFieldAnalyzerWrapper(defaultAnalyzer: new StandardAnalyzer(_matchVersion, new CharArraySet(_matchVersion, 0, true)), fieldAnalyzers: index.FieldAnalyzers);
OpenWriter();
lock ( _lockWriter )
{
if (_writer != null)
{
_writer.UpdateDocument(new Term("index", indexValue), doc, analyzer); // Must specify analyzer because the default analyzer that is specified in indexWriterConfig is null.
}
}
}
catch (Exception ex)
{
HttpContext context2 = HttpContext.Current;
ExceptionLogService.LogException(ex, context2);
}
}
public PerFieldAnalyzerWrapper CreateAnalyzer(Analyzer defaultAnalyzer, ICollection <Action> toDispose, bool forQuerying = false)
{
toDispose.Add(defaultAnalyzer.Close);
var perFieldAnalyzerWrapper = new PerFieldAnalyzerWrapper(defaultAnalyzer);
foreach (var analyzer in indexDefinition.Analyzers)
{
Analyzer analyzerInstance = IndexingExtensions.CreateAnalyzerInstance(analyzer.Key, analyzer.Value);
if (analyzerInstance == null)
{
continue;
}
toDispose.Add(analyzerInstance.Close);
if (forQuerying)
{
var customAttributes = analyzerInstance.GetType().GetCustomAttributes(typeof(NotForQueryingAttribute), false);
if (customAttributes.Length > 0)
{
continue;
}
}
perFieldAnalyzerWrapper.AddAnalyzer(analyzer.Key, analyzerInstance);
}
StandardAnalyzer standardAnalyzer = null;
KeywordAnalyzer keywordAnalyzer = null;
foreach (var fieldIndexing in indexDefinition.Indexes)
{
switch (fieldIndexing.Value)
{
case FieldIndexing.NotAnalyzed:
if (keywordAnalyzer == null)
{
keywordAnalyzer = new KeywordAnalyzer();
toDispose.Add(keywordAnalyzer.Close);
}
perFieldAnalyzerWrapper.AddAnalyzer(fieldIndexing.Key, keywordAnalyzer);
break;
case FieldIndexing.Analyzed:
if (indexDefinition.Analyzers.ContainsKey(fieldIndexing.Key))
{
continue;
}
if (standardAnalyzer == null)
{
standardAnalyzer = new StandardAnalyzer(Version.LUCENE_29);
toDispose.Add(standardAnalyzer.Close);
}
perFieldAnalyzerWrapper.AddAnalyzer(fieldIndexing.Key, standardAnalyzer);
break;
}
}
return(perFieldAnalyzerWrapper);
}
private Analyzer CreateAnalyzerWrapper()
{
Analyzer analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
PerFieldAnalyzerWrapper analyzerWrapper = new PerFieldAnalyzerWrapper(analyzer);
analyzerWrapper.AddAnalyzer("Name", new PanGuAnalyzer());
analyzerWrapper.AddAnalyzer("Age", new PanGuAnalyzer());
return(analyzerWrapper);
}
public LuceneFileProcessor(string indexPath, bool create, DocumentFactory factory)
{
_is_started = false;
_writer = null;
_nb_indexed = 0;
_index_path = indexPath;
_create_index = create;
_default_analyzer = null;
_doc_factory = factory;
}
