private TopDocs ExecuteQuery(Query documentQuery, int start, int pageSize, Sort sort)
{
if (sort == null && _indexHasBoostedFields == false && IsBoostedQuery(documentQuery) == false)
{
if (pageSize == int.MaxValue || pageSize >= _searcher.MaxDoc) // we want all docs, no sorting required
{
var gatherAllCollector = new GatherAllCollector(Math.Min(pageSize, _searcher.MaxDoc));
_searcher.Search(documentQuery, gatherAllCollector, _state);
return(gatherAllCollector.ToTopDocs());
}
var noSortingCollector = new NonSortingCollector(Math.Abs(pageSize + start));
_searcher.Search(documentQuery, noSortingCollector, _state);
return(noSortingCollector.ToTopDocs());
}
var minPageSize = GetPageSize(_searcher, (long)pageSize + start);
if (sort != null)
{
_searcher.SetDefaultFieldSortScoring(true, false);
try
{
return(_searcher.Search(documentQuery, null, minPageSize, sort, _state));
}
finally
{
_searcher.SetDefaultFieldSortScoring(false, false);
}
}
return(_searcher.Search(documentQuery, null, minPageSize, _state));
}
/// <summary>
/// Open de Lucene index
/// </summary>
/// <returns></returns>
protected virtual bool OpenIndex()
{
CDRLogger.FileLogger.LogInfo(String.Format("OpenIndex(): begin using path {0}", IndexName));
bool result = false;
if (index != null)
{
CloseIndex();
}
try
{
index = new IndexSearcher(IndexReader.Open(FSDirectory.Open(new System.IO.DirectoryInfo(indexBasePath)), true));
index.SetDefaultFieldSortScoring(true, true);
result = true;
}
catch (Exception e)
{
CDRLogger.Logger.LogInfo("CloseIndex(): " + e.Message);
result = false;
// voor de zekerheid!
CloseIndex();
}
CDRLogger.FileLogger.LogInfo("OpenIndex(): end");
return(result);
}
public override Searcher GetSearcher()
{
ValidateSearcher(false);
//ensure scoring is turned on for sorting
_searcher.SetDefaultFieldSortScoring(true, true);
return(_searcher);
}
// main search method
private static ResultObject _search(string searchQuery, int pad, string searchField = "")
{
// validation
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new ResultObject());
}
// set up lucene searcher
using (var searcher = new IndexSearcher(_directory, false))
{
var hits_limit = 10000;
var analyzer = new StandardAnalyzer(Version.LUCENE_30);
int start = (pad - 1) * hitsPerPage;
int end = start + hitsPerPage;
var parser = new MultiFieldQueryParser
(Version.LUCENE_30, new[] { "Contents", "Title" }, analyzer);
var query = parseQuery(searchQuery, parser);
// return all scoredoc for all searched document
searcher.SetDefaultFieldSortScoring(true, true);
var sort = new Sort(new SortField("Contents", SortField.SCORE));
var hits = searcher.Search(query, null, hits_limit, sort).ScoreDocs;
ResultObject results = new ResultObject();
List <CustomresultObject> listsite = new List <CustomresultObject>();
for (int i = start; i < Math.Min(end, hits.Length); ++i)
{
listsite.Add(_mapLuceneToDataList(hits[i], searcher, query, analyzer));
}
results.sites = listsite;
results.NumberResult = hits.Length;
results.Resultperpage = hitsPerPage;
analyzer.Close();
searcher.Dispose();
// WRITE LOG
string datenow = DateTime.Now.ToString("h:mm:ss tt");
string path = @"D:\MyTest.txt";
// This text is added only once to the file.
if (!File.Exists(path))
{
// Create a file to write to.
string createText = "Time: " + datenow + "|query: " + searchQuery + "|Resultnum: " + hits.Length + Environment.NewLine;
File.WriteAllText(path, createText);
}
// This text is always added, making the file longer over time
// if it is not deleted.
string appendText = "Time: " + datenow + "|query: " + searchQuery + "|Resultnum: " + hits.Length + Environment.NewLine;
File.AppendAllText(path, appendText);
return(results);
}
}
private static List <Document> doSearch(string text)
{
//string text = RemoveControlCharsFromString(textSearch);
if (text == null || text == "" || text.Contains('\n') || text.Contains('\t') || text.Contains('\r') || text.Contains('\b'))
{
return(null);
}
//The array-list of title strings for the matching results
List <Document> list = new List <Document>();
//The IndexReader reads the index table -- opens the directory(IN MEMORY)
IndexReader reader = IndexReader.Open(dir, true);
//The indexSearcher is used to search for matches
IndexSearcher searcher = new IndexSearcher(reader);
searcher.SetDefaultFieldSortScoring(true, false);
//Similarity -- relevence
searcher.Similarity = new DefaultSimilarity();
//The analyzer -- Maybe it has something to do with the relevence
StandardAnalyzer analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
MultiFieldQueryParser queryParser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30, new string[] { "ad_id", "ad_title", "ad_desc" }, analyzer);
//The queryParser defines which fields are to be used for the search
//True so we can use wildcards in the search *
queryParser.AllowLeadingWildcard = true;
//Used when searching now it matches results if the hit has one of the words
//example: "the house" will match only in text with both words
queryParser.DefaultOperator = QueryParser.OR_OPERATOR;
//A query is being created with the given text
Query query = queryParser.Parse(text);
TopScoreDocCollector collector = TopScoreDocCollector.Create(1000, true);
searcher.Search(query, collector);
ScoreDoc[] matches = collector.TopDocs().ScoreDocs;
//Itereate in matches array
foreach (ScoreDoc item in matches)
{
int id = item.Doc;
//search by id in the index table -- very fast
Document doc = searcher.Doc(id);
//We add the document to the list
list.Add(doc);
}
//the list is always with order by score
return(list);
}
public IndexSearcher CreateSearcher(bool readOnly, bool calcScore)
{
var result = new IndexSearcher(Directory, readOnly);
if (calcScore)
{
result.SetDefaultFieldSortScoring(true, true);
}
return(result);
}
public override Searcher GetSearcher()
{
if (_searcher == null)
{
_searcher = new IndexSearcher(GetLuceneDirectory(), true);
}
//ensure scoring is turned on for sorting
_searcher.SetDefaultFieldSortScoring(true, true);
return(_searcher);
}
// поиск с указанием найденной позиции в тексте
public void DoSearch(String db, String querystr, global::Lucene.Net.Store.Directory indexDirectory)
{
// 1. Specify the analyzer for tokenizing text.
// The same analyzer should be used as was used for indexing
StandardAnalyzer analyzer = new StandardAnalyzer(Version.LUCENE_30, ListStopWords);
// 2. query
Query q = new QueryParser(Version.LUCENE_30, "LineText", analyzer).Parse(querystr);
// 3. search
int hitsPerPage = 10;
IndexSearcher searcher = new IndexSearcher(indexDirectory, true);
IndexReader reader = IndexReader.Open(indexDirectory, true);
searcher.SetDefaultFieldSortScoring(true, false);
TopScoreDocCollector collector = TopScoreDocCollector.Create(hitsPerPage, true);
searcher.Search(q, collector);
ScoreDoc[] hits = collector.TopDocs().ScoreDocs;
// 4. display term positions, and term indexes
MessageBox.Show("Found " + hits.Length + " hits.");
for (int i = 0; i < hits.Length; ++i)
{
int docId = hits[i].Doc;
ITermFreqVector tfvector = reader.GetTermFreqVector(docId, "LineText");
TermPositionVector tpvector = (TermPositionVector)tfvector;
// this part works only if there is one term in the query string,
// otherwise you will have to iterate this section over the query terms.
int termidx = tfvector.IndexOf(querystr);
int[] termposx = tpvector.GetTermPositions(termidx);
TermVectorOffsetInfo[] tvoffsetinfo = tpvector.GetOffsets(termidx);
for (int j = 0; j < termposx.Length; j++)
{
MessageBox.Show("termpos : " + termposx[j]);
}
for (int j = 0; j < tvoffsetinfo.Length; j++)
{
int offsetStart = tvoffsetinfo[j].StartOffset;
int offsetEnd = tvoffsetinfo[j].EndOffset;
MessageBox.Show("offsets : " + offsetStart + " " + offsetEnd);
}
// print some info about where the hit was found...
Document d = searcher.Doc(docId);
MessageBox.Show((i + 1) + ". " + d.Get("path"));
}
// searcher can only be closed when there
// is no need to access the documents any more.
searcher.Dispose();
}
/// <summary>
/// Gets the searcher for this instance, this method will also ensure that the searcher is up to date whenever this method is called.
/// </summary>
/// <returns>
/// Returns null if the underlying index doesn't exist
/// </returns>
public override Searcher GetLuceneSearcher()
{
if (!ValidateSearcher())
{
return(null);
}
//ensure scoring is turned on for sorting
_searcher.SetDefaultFieldSortScoring(true, true);
return(_searcher);
}
public LuceneDotNetHowToExamplesFacade setIndexSearcherFieldSortScoring(bool doTrackScores, bool doMaxScore)
{
if (IndexSearcher == null)
{
throw new Exception("IndexParser not created.");
}
IndexSearcher.SetDefaultFieldSortScoring(doTrackScores, doMaxScore);
return(this);
}
// main search method
private static IEnumerable <LuceneSearchModel> _search(string searchQuery, int amountToTake, string searchField = "")
{
// validation
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <LuceneSearchModel>());
}
// set up lucene searcher
using (var searcher = new IndexSearcher(_directory, false))
{
const int hitsLimit = 1000;
var analyzer = new StandardAnalyzer(Version.LUCENE_30);
// search by single field
if (!string.IsNullOrEmpty(searchField))
{
var parser = new QueryParser(Version.LUCENE_30, searchField, analyzer);
var query = parseQuery(searchQuery, parser);
searcher.SetDefaultFieldSortScoring(true, true);
var hits = searcher.Search(query, hitsLimit).ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher, amountToTake);
analyzer.Close();
searcher.Dispose();
return(results);
}
// search by multiple fields (ordered by RELEVANCE)
else
{
var parser = new MultiFieldQueryParser(Version.LUCENE_30, new[] { AppConstants.LucId, AppConstants.LucTopicName, AppConstants.LucPostContent }, analyzer);
var query = parseQuery(searchQuery, parser);
searcher.SetDefaultFieldSortScoring(true, true);
var hits = searcher.Search(query, null, hitsLimit, Sort.INDEXORDER).ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher, amountToTake);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
}
private TopDocs ExecuteQuery(Query documentQuery, int start, int pageSize, Sort sort)
{
if (sort == null && _indexHasBoostedFields == false && IsBoostedQuery(documentQuery) == false)
{
if (pageSize == int.MaxValue) // we want all docs, no sorting required
{
var gatherAllCollector = new GatherAllCollector();
_searcher.Search(documentQuery, gatherAllCollector);
return(gatherAllCollector.ToTopDocs());
}
var noSortingCollector = new NonSortingCollector(Math.Abs(pageSize + start));
_searcher.Search(documentQuery, noSortingCollector);
return(noSortingCollector.ToTopDocs());
}
var absFullPage = Math.Abs(pageSize + start); // need to protect against ridiculously high values of pageSize + start that overflow
var minPageSize = Math.Max(absFullPage, 1);
if (sort != null)
{
_searcher.SetDefaultFieldSortScoring(true, false);
try
{
return(_searcher.Search(documentQuery, null, minPageSize, sort));
}
finally
{
_searcher.SetDefaultFieldSortScoring(false, false);
}
}
return(_searcher.Search(documentQuery, null, minPageSize));
}
/// <summary>
/// Get the configuration details of an Exmaine searcher, so Lucene can be queried in the same way,
/// consumer needs to know Lucene directory, the analyser (for the text field) and whether to use wildcards)
/// TODO: move validation logic out into initialize, so quicker to get content during a query
/// </summary>
/// <param name="searcherName">The name of the Examine seracher (see ExamineSettings.config)</param>
/// <returns>SearchingContext if found, otherwise null</returns>
private static SearchingContext GetSearchingContext(string searcherName)
{
LuceneSearcher searcher = null;
if (string.IsNullOrWhiteSpace(searcherName))
{
searcher = ExamineManager.Instance.DefaultSearchProvider as LuceneSearcher;
}
else
{
searcher = ExamineManager.Instance.SearchProviderCollection[searcherName] as LuceneSearcher;
if (searcher == null && !searcherName.EndsWith("Searcher"))
{
searcher = ExamineManager.Instance.SearchProviderCollection[searcherName + "Searcher"] as LuceneSearcher;
}
}
if (searcher == null)
{
LogHelper.Debug(typeof(LookService), $"Unable to find Examine Lucene Searcher '{ searcherName }'");
}
else
{
var indexSetDirectory = LookService.Instance.IndexSetDirectories[searcher.IndexSetName];
if (indexSetDirectory != null)
{
var indexSearcher = new IndexSearcher(indexSetDirectory, true); // TODO: handle reuse
indexSearcher.SetDefaultFieldSortScoring(true, true);
return(new SearchingContext()
{
Analyzer = searcher.IndexingAnalyzer,
IndexSearcher = indexSearcher,
EnableLeadingWildcards = searcher.EnableLeadingWildcards
});
}
}
return(null);
}
private static IEnumerable <LuceneData_BO> _searchFrontEnd(string searchQuery, string searchField = "")
{
// validation
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <LuceneData_BO>());
}
// set up lucene searcher
using (var searcher = new IndexSearcher(_directoryFrontEnd, false))
{
var hits_limit = 1000;
var analyzer = new StandardAnalyzer(Version.LUCENE_30);
// search by single field
if (!string.IsNullOrEmpty(searchField))
{
var parser = new QueryParser(Version.LUCENE_30, searchField, analyzer);
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search(query, hits_limit).ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
// search by multiple fields (ordered by RELEVANCE)
else
{
var parser = new MultiFieldQueryParser
(Version.LUCENE_30, new[] { "Title", "Url", "Description" }, analyzer);
var query = parseQuery(searchQuery, parser);
searcher.SetDefaultFieldSortScoring(true, true);
var hits = searcher.Search(query, null, hits_limit, Sort.RELEVANCE).ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
}
private static IEnumerable <Offer> _search(string searchQuery, string searchField = "")
{
// validation
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <Offer>());
}
// set up lucene searcher
using (var searcher = new IndexSearcher(_directory, true))
{
var hits_limit = 1000;
//var analyzer = new StandardAnalyzer(Version.LUCENE_30);
var analyzer = new SnowballAnalyzer(Lucene.Net.Util.Version.LUCENE_30, "English", StopAnalyzer.ENGLISH_STOP_WORDS_SET);
searcher.SetDefaultFieldSortScoring(true, true);
// search by single field
if (!string.IsNullOrEmpty(searchField))
{
var parser = new QueryParser(Version.LUCENE_30, searchField, analyzer);
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search(query, hits_limit).ScoreDocs;
var results = _mapLuceneToOfferList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
// search by multiple fields (ordered by RELEVANCE)
else
{
var parser = new MultiFieldQueryParser(Version.LUCENE_30, _fields.Keys.ToArray(), analyzer);
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search(query, null, hits_limit, Sort.RELEVANCE).ScoreDocs;
var results = _mapLuceneToOfferList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
}
private static IEnumerable <Offer> _fuzzysearch(string searchQuery, string searchField)
{
// validation
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <Offer>());
}
// set up lucene searcher
using (var searcher = new IndexSearcher(_directory, true))
{
var hits_limit = 1000;
searcher.SetDefaultFieldSortScoring(true, true);
// search by single field for fuzzy
var query = fuzzyParseQuery(searchQuery);
var hits = searcher.Search(query, hits_limit).ScoreDocs;
var results = _mapLuceneToOfferList(hits, searcher);
searcher.Dispose();
return(results);
}
}
public ActionResult ArtistSearch(string term)
{
Analyzer analyzer = new ASCIIFoldingAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
var hits_limit = 5000;
BooleanQuery finalQuery = getPrefixQuery(Constants.ARTIST_FIELD, 3, term, analyzer);
IndexSearcher searcher = getSearcher();
searcher.SetDefaultFieldSortScoring(true, true);
ScoreDoc[] hits = searcher.Search(finalQuery, null, hits_limit, Sort.RELEVANCE).ScoreDocs;
ScoreDoc[] fuzzyHits = searcher.Search(getFuzzyQuery(Constants.ARTIST_FIELD, term, analyzer),
null, hits_limit, Sort.RELEVANCE).ScoreDocs;
List <String> searchResults = new List <String>();
foreach (ScoreDoc hit in hits)
{
var document = searcher.IndexReader.Document(hit.Doc);
string artist = document.Get(Constants.ARTIST_FIELD);
if (!searchResults.Contains(artist))
{
searchResults.Add(document.Get(Constants.ARTIST_FIELD));
}
}
foreach (ScoreDoc hit in fuzzyHits)
{
var document = searcher.IndexReader.Document(hit.Doc);
string artist = document.Get(Constants.ARTIST_FIELD);
if (!searchResults.Contains(artist))
{
searchResults.Add(document.Get(Constants.ARTIST_FIELD));
}
}
searcher.Dispose();
return(Json(searchResults.ToArray().Take(10)));
}
private static PagedList <LuceneSearchModel> _search(string searchQuery, int pageIndex, int pageSize)
{
// validation
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(null);
}
// set up lucene searcher
using (var searcher = new IndexSearcher(_directory, false))
{
const int hitsLimit = 1000;
var analyzer = new StandardAnalyzer(Version.LUCENE_30);
var parser = new MultiFieldQueryParser(Version.LUCENE_30, new[] { AppConstants.LucId, AppConstants.LucTopicName, AppConstants.LucPostContent }, analyzer);
var query = parseQuery(searchQuery, parser);
searcher.SetDefaultFieldSortScoring(true, true);
var hits = searcher.Search(query, null, hitsLimit, Sort.INDEXORDER).ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher, pageIndex, pageSize);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
// search methods
public static IEnumerable <LuceneSearchModel> GetAllIndexRecords()
{
// validate search index
if (!System.IO.Directory.EnumerateFiles(_luceneDir).Any())
{
return(new List <LuceneSearchModel>());
}
// set up lucene searcher
var searcher = new IndexSearcher(_directory, false);
var reader = IndexReader.Open(_directory, false);
searcher.SetDefaultFieldSortScoring(true, true);
var docs = new List <Document>();
var term = reader.TermDocs();
while (term.Next())
{
docs.Add(searcher.Doc(term.Doc));
}
reader.Dispose();
searcher.Dispose();
return(_mapLuceneToDataList(docs));
}
public static IndexSearcher BuildSearcher(ISearchFactoryImplementor searchFactory,
out ISet <System.Type> classesAndSubclasses,
params System.Type[] classes)
{
IDictionary <System.Type, DocumentBuilder> builders = searchFactory.DocumentBuilders;
ISet <IDirectoryProvider> directories = new HashSet <IDirectoryProvider>();
if (classes == null || classes.Length == 0)
{
// no class means all classes
foreach (DocumentBuilder builder in builders.Values)
{
foreach (IDirectoryProvider provider in builder.DirectoryProvidersSelectionStrategy.GetDirectoryProvidersForAllShards())
{
directories.Add(provider);
}
}
// Give them back an empty set
classesAndSubclasses = null;
}
else
{
ISet <System.Type> involvedClasses = new HashSet <System.Type>();
involvedClasses.AddAll(classes);
foreach (System.Type clazz in classes)
{
DocumentBuilder builder;
builders.TryGetValue(clazz, out builder);
if (builder != null)
{
involvedClasses.AddAll(builder.MappedSubclasses);
}
}
foreach (System.Type clazz in involvedClasses)
{
DocumentBuilder builder;
builders.TryGetValue(clazz, out builder);
// TODO should we rather choose a polymorphic path and allow non mapped entities
if (builder == null)
{
throw new HibernateException("Not a mapped entity: " + clazz);
}
foreach (IDirectoryProvider provider in builder.DirectoryProvidersSelectionStrategy.GetDirectoryProvidersForAllShards())
{
directories.Add(provider);
}
}
classesAndSubclasses = involvedClasses;
}
IDirectoryProvider[] directoryProviders = new List <IDirectoryProvider>(directories).ToArray();
var searcher = new IndexSearcher(searchFactory.ReaderProvider.OpenReader(directoryProviders));
searcher.SetDefaultFieldSortScoring(true, true);
return(searcher);
}
/// <summary>
/// core search method
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
protected IXQueryCollection DoSearch(IXRequest request)
{
// validation
if (String.IsNullOrEmpty(request.Query.Replace("*", "").Replace("?", "")))
{
return new IXQueryCollection()
{
Count = 0, Start = 0, Take = 0, Results = new IXQuery[] { }, Status = IXQueryStatus.ErrorQuerySyntax
}
}
;
QueryParser parser = null;
if (request.Fields.Count() < 1)
{
parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, null, analyzer);
}
else if (request.Fields.Count() == 1)
{
parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, request.Fields.ElementAt(0), analyzer);
}
else
{
parser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30, request.Fields.ToArray(), analyzer);
}
Query query = ParseQuery(request.Query, parser);
if (query == null)
{
return new IXQueryCollection()
{
Count = 0, Start = 0, Take = 0, Results = new IXQuery[] { }, Status = IXQueryStatus.ErrorQuerySyntax
}
}
;;
bool useScoring = ((request.Flags & IXRequestFlags.UseScore) == IXRequestFlags.UseScore);
if (useScoring)
{
indexSearcher.SetDefaultFieldSortScoring(true, true);
}
else
{
indexSearcher.SetDefaultFieldSortScoring(false, false);
}
TopFieldDocs hits = indexSearcher.Search(query, null, this.MaxSearchHits, Sort.RELEVANCE);
int skip = request.Skip;
int take = request.Take;
if (skip < 0)
{
skip = 0;
}
if (take < 1)
{
take = this.MaxSearchHits;
}
return(new IXQueryCollection
{
Results = MapLuceneIndexToDataList(hits.ScoreDocs.Skip(skip).Take(take), indexSearcher, useScoring, request.Fields),
Start = skip,
Take = take,
Count = hits.TotalHits,
Status = (hits.TotalHits > 0) ? IXQueryStatus.Success : IXQueryStatus.NoData
});
}
private ILuceneSearchResultCollection PerformSearch(SearchOptions options, bool safeSearch)
{
// Results collection
ILuceneSearchResultCollection results = new LuceneSearchResultCollection();
using (var reader = IndexReader.Open(directory, true))
using (var searcher = new IndexSearcher(reader))
{
Query query;
// calculate the scores - this has a cpu hit!!!
searcher.SetDefaultFieldSortScoring(true, true);
// Escape our search if we're performing a safe search
if (safeSearch == true)
{
options.SearchText = QueryParser.Escape(options.SearchText);
}
if (options.Fields.Count() == 1)
{
// Single field search
QueryParser queryParser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, options.Fields[0], analyzer);
query = queryParser.Parse(options.SearchText);
}
else
{
// Parse the boosts against the fields
// Multifield search
MultiFieldQueryParser multiFieldQueryParser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30, options.Fields.ToArray(), analyzer, options.Boosts);
query = multiFieldQueryParser.Parse(options.SearchText);
}
List <SortField> sortFields = new List <SortField>();
sortFields.Add(SortField.FIELD_SCORE);
// if we have any sort fields then add them
foreach (var sortField in options.OrderBy)
{
sortFields.Add(new SortField(sortField, SortField.STRING));
}
// create our sort
Sort sort = new Sort(sortFields.ToArray());
ScoreDoc[] matches = searcher.Search(query, null, options.MaximumNumberOfHits, sort).ScoreDocs;
results.TotalHits = matches.Count();
// perform skip and take if needed
if (options.Skip.HasValue)
{
matches = matches.Skip(options.Skip.Value).ToArray();
}
if (options.Take.HasValue)
{
matches = matches.Take(options.Take.Value).ToArray();
}
// create a list of documents from the results
foreach (var match in matches)
{
var id = match.Doc;
var doc = searcher.Doc(id);
// filter out unwanted documents if a type has been set
if (options.Type != null)
{
var t = doc.Get("Type");
if (options.Type.AssemblyQualifiedName == t)
{
results.Results.Add(new LuceneSearchResult()
{
Score = match.Score,
Document = doc
});
}
}
else
{
results.Results.Add(new LuceneSearchResult()
{
Score = match.Score,
Document = doc
});
}
}
}
return(results);
}