private static IEnumerable <TvChannel> search(string searchQuery, string searchField = "")
{
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <TvChannel>());
}
using (IndexSearcher searcher = new IndexSearcher(Directory, false)) {
int n = 1000;
StandardAnalyzer standardAnalyzer = new StandardAnalyzer(Version.LUCENE_30);
if (!string.IsNullOrEmpty(searchField))
{
QueryParser parser = new QueryParser(Version.LUCENE_30, searchField, standardAnalyzer);
Query query = parseQuery(searchQuery, parser);
IEnumerable <TvChannel> enumerable = mapLuceneToDataList(searcher.Search(query, n).ScoreDocs, searcher);
standardAnalyzer.Close();
searcher.Dispose();
return(enumerable);
}
MultiFieldQueryParser fieldQueryParser = new MultiFieldQueryParser(Version.LUCENE_30, new string[3]
{
"Id",
"Name",
"Description"
}, standardAnalyzer);
Query query1 = parseQuery(searchQuery, fieldQueryParser);
IEnumerable <TvChannel> enumerable1 = mapLuceneToDataList(searcher.Search(query1, null, n, Sort.RELEVANCE).ScoreDocs, searcher);
standardAnalyzer.Close();
searcher.Dispose();
return(enumerable1);
}
}
public IEnumerable <TEntity> _search(string searchQuery, string searchField = "")
{
// set up lucene searcher
using (var searcher = new IndexSearcher(_directory, false))
{
var hits_limit = 1000;
var analyzer = _getAnalyzer();
// search by single field
if (!string.IsNullOrEmpty(searchField))
{
var parser = new QueryParser(Version.LUCENE_30, searchField, analyzer);
parser.AllowLeadingWildcard = true;
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search(query, hits_limit).ScoreDocs;
var results = _mapLuceneToDataList(query, hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
// search by multiple fields (ordered by RELEVANCE)
else
{
var parser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30,
new[] { IndexKey.Id, IndexKey.TextValue, IndexKey.TextContentId },
analyzer);
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search(query, null, hits_limit, Sort.INDEXORDER).ScoreDocs;
var results = _mapLuceneToDataList(query, hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
}
//partially taken from http://www.codeproject.com/Articles/320219/Lucene-Net-ultra-fast-search-for-MVC-or-WebForms
//START
private IEnumerable <FileToIndex> _search(string keywords, out int count, string field = "")
{
if (string.IsNullOrEmpty(keywords.Replace("*", "").Replace("?", "")))
{
count = 0;
return(new List <FileToIndex>());
}
using (var searcher = new IndexSearcher(_directory))
using (var analyzer = new Lucene.Net.Analysis.Ru.RussianAnalyzer(Version.LUCENE_30))
{
if (!string.IsNullOrEmpty(field))
{
var parser = new QueryParser(Version.LUCENE_30, field, analyzer);
var queryForField = parseQuery(keywords, parser);
var docs = searcher.Search(queryForField, 100);
count = docs.TotalHits;
var samples = _convertDocs(docs.ScoreDocs, searcher);
searcher.Dispose();
return(samples);
}
else
{
var parser = new MultiFieldQueryParser
(Version.LUCENE_30, new[] { "Title", "Authors", "Description", "Text", "Discipline" }, analyzer);
var queryForField = parseQuery(keywords, parser);
var docs = searcher.Search(queryForField, null, 100, Sort.RELEVANCE);
count = docs.TotalHits;
var samples = _convertDocs(docs.ScoreDocs, searcher);
searcher.Dispose();
return(samples);
}
}
}
private static IEnumerable <Artifact> _search(string searchQuery, string searchField = "")
{
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <Artifact>());
}
using (var searcher = new IndexSearcher(_directory, false))
{
var hits_limit = 1000;
var analyzer = new StandardAnalyzer(Version.LUCENE_30);
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);
}
else
{
var parser = new MultiFieldQueryParser(Version.LUCENE_30, getArtifactPropertiesArray(), analyzer);
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search(query, null, hits_limit, Sort.INDEXORDER).ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
}
private static IEnumerable <Task> privateSearch(string searchQuery, string searchField = "")
{
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <Task>());
}
using (var searcher = new IndexSearcher(directory, false))
{
var hits_limit = 1000;
var analyzer = new StandardAnalyzer(Version.LUCENE_30);
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);
}
else
{
var parser = new MultiFieldQueryParser
(Version.LUCENE_30, new[] { "Id", "Name", "Condition" }, analyzer);
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search
(query, null, hits_limit, Sort.RELEVANCE).ScoreDocs;
var results = mapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
}
// main search method
/// <summary>
/// return IEnumerable of interesting id
/// </summary>
/// <param name="searchQuery">that to find</param>
/// <param name="pageNumber">number of paging</param>
/// <param name="pageSize">size return collection</param>
/// <param name="searchField">if set than return result only by fiekd</param>
/// <returns></returns>
private static IEnumerable <int> _search(string searchQuery, int pageNumber, int pageSize, string searchField = "")
{
// validation
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <int>());
}
try
{
// set up lucene searcher
using (LuceneDirectory)
{
//var analyzer = new RuAnalyzer();
var analyzer = new StandardAnalyzer(Version);
using (var searcher = new IndexSearcher(LuceneDirectory, true))
{
// search by single field
if (!string.IsNullOrEmpty(searchField))
{
var parser = new QueryParser(Version, searchField, analyzer);
var query = ParseQuery(searchQuery, parser);
var hits = searcher.Search(query, HitsLimit).ScoreDocs;
//calc
var paging = CalculateArrayLocation(hits.Length, pageNumber, pageSize);
var results = MapLuceneToDataList(hits, searcher, paging);
analyzer.Close();
searcher.Close();
searcher.Dispose();
LuceneDirectory.Close();
return(results);
}
// search by multiple fields (ordered by RELEVANCE)
else
{
var parser = new MultiFieldQueryParser(Version, new[] { "ArtNo", "Name", "NameWithWiteSpace" }, analyzer);
var query = ParseQuery(searchQuery, parser);
//searcher.SetDefaultFieldSortScoring(true, true);
var hits = searcher.Search(query, null, HitsLimit, Sort.RELEVANCE).ScoreDocs;
//var hits = searcher.Search(query, HitsLimit).ScoreDocs;
//calc
var paging = CalculateArrayLocation(hits.Length, pageNumber, pageSize);
var results = MapLuceneToDataList(hits, searcher, paging);
analyzer.Close();
searcher.Close();
searcher.Dispose();
LuceneDirectory.Close();
return(results);
}
}
}
}
catch (Exception ex)
{
Debug.LogError(ex);
return(new List <int>());
}
}
public override List <TT> ExecuteSearch(string searchQuery, string searchField = "")
{
try
{
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <TT>());
}
IndexReader rdr;
try
{
rdr = IndexReader.Open(_writerPool[HostContext.Instance.Items["Contract"].ToString().ToLower()].Directory,
true);
}
catch (Exception ex)
{
throw new ArgumentException(
"DD:AllergyLuceneStrategy:ExecuteSearch(): Could not find contract name in the WriterPool." + ex.Message, ex.StackTrace);
}
using (var searcher = new IndexSearcher(rdr))
{
var hits_limit = 1000;
var analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
if (!string.IsNullOrEmpty(searchField))
{
var parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, searchField, analyzer);
parser.AllowLeadingWildcard = true;
parser.PhraseSlop = 0;
var query = ParseWholeQuery(searchQuery, parser);
var hits = searcher.Search(query, hits_limit).ScoreDocs;
var results = MapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
else
{
var parser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30, new[] { "Id", "Name" }, analyzer);
parser.AllowLeadingWildcard = true;
parser.PhraseSlop = 0;
var query = ParseWholeQuery(searchQuery, parser);
var hits = searcher.Search(query, null, hits_limit, Sort.RELEVANCE).ScoreDocs;
var results = MapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
}
catch (Exception ex)
{
FileLog.LogMessageToFile(ex.Message + " trace:" + ex.StackTrace);
throw ex;
}
}
/// <summary>
/// handler for the OnIndexSearcherUpdateRequested event: the global indexsearcher must be recreated after the index had been modified to reflect changes to the endusers
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void IndexSearcherUpdater(object sender, EventArgs e)
{
lock (indexSearcher)
{
indexSearcher.Dispose();
indexSearcher = new IndexSearcher(luceneIndexDirectory, true);
}
}
private static IEnumerable <ProductModel> _search(string searchQuery, int UserId, string searchField = "")
{
// validation
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <ProductModel>());
}
// set up lucene searcher
using (var searcher = new IndexSearcher(_directory, false))
{
var hits_limit = 20;
var analyzer = new StandardAnalyzer(Version.LUCENE_30);
Lucene.Net.Search.TermRangeFilter filter = new TermRangeFilter("OwnerIdString", UserId.ToString(), UserId.ToString(), true, true);
// search by single field
if (!string.IsNullOrEmpty(searchField))
{
var parser = new QueryParser(Version.LUCENE_30, searchField, analyzer);
var query = parseQuery(searchQuery, parser);
ScoreDoc[] hits;
hits = searcher.Search(query, hits_limit).ScoreDocs;
//if (UserId != 0)
// hits = searcher.Search(query, filter, hits_limit).ScoreDocs;
//else
// 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[] { "SrcId", "Title", "Description", "Brand", "Gtin", "Mpn" }, analyzer);
var query = parseQuery(searchQuery, parser);
ScoreDoc[] hits;
hits = searcher.Search(query, hits_limit).ScoreDocs;
//if (UserId != 0)
// hits = searcher.Search(query, filter, hits_limit, Sort.RELEVANCE).ScoreDocs;
//else
// hits = searcher.Search(query, null, hits_limit, Sort.RELEVANCE).ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
}
private IEnumerable <SearchProduct> _search(string searchQuery, string searchField = "")
{
// validation
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <SearchProduct>());
}
// set up lucene searcher
using (var searcher = new IndexSearcher(_directory, false))
{
var hits_limit = 1000;
var analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
// search by single field
if (!string.IsNullOrEmpty(searchField))
{
var parser = new QueryParser(Lucene.Net.Util.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();
List <SearchProduct> products = new List <SearchProduct>();
using (var db = new ApplicationDbContext())
{
foreach (var elem in results)
{
products.Add(new SearchProduct(elem));
}
}
return(products);
}
// search by multiple fields (ordered by RELEVANCE)
else
{
var parser = new MultiFieldQueryParser
(Lucene.Net.Util.Version.LUCENE_30, new[] { "ProductId", "Name", "Description", "Price", "Category" }, analyzer);
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search(query, null, hits_limit, Sort.RELEVANCE).ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
List <SearchProduct> products = new List <SearchProduct>();
using (var db = new ApplicationDbContext())
{
foreach (var elem in results)
{
products.Add(new SearchProduct(elem));
}
}
return(products);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="searchQuery"></param>
/// <param name="searchField"></param>
/// <returns></returns>
public IEnumerable <LearningCourseDTO> GetSearchResults(string searchQuery, string searchField = "")
{
// validation
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <LearningCourseDTO>());
}
// set up lucene searcher
using (var searcher = new IndexSearcher(_directory, false))
{
var hits_limit = 1000;
var analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
//if one need to add new field to search:
//var parser = new MultiFieldQueryParser
//(Version.LUCENE_30, new[] { "Id", "Name", "Description", "NEW_FIELD" }, analyzer);
// search by single field
if (!string.IsNullOrEmpty(searchField))
{
var parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, searchField, analyzer);
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search(query, hits_limit).ScoreDocs;
var mapper = new LearningCourseMapper();
var results = mapper.MapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
// search by multiple fields (ordered by RELEVANCE)
else
{
var parser = new MultiFieldQueryParser
(Lucene.Net.Util.Version.LUCENE_30, new[] { "Name", "Description" }, analyzer);
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search
(query, null, hits_limit, Sort.RELEVANCE).ScoreDocs;
var mapper = new LearningCourseMapper();
var results = mapper.MapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
}
public void Commit()
{
lock (_lock)
{
_writer.Commit();
if (_searcher != null)
{
_searcher.Dispose();
_searcher = null;
}
}
}
public void Close()
{
lock (searcherLock)
{
EnsureOpen();
closed = true;
if (searcher != null)
{
searcher.Dispose();
}
searcher = null;
}
}
// main search method
private static IEnumerable <IndexableEntity> _search(string searchQuery, string searchField = "")
{
// validation
if (string.IsNullOrWhiteSpace(searchQuery.Replace("*", string.Empty).Replace("?", string.Empty)))
{
return(new List <IndexableEntity>());
}
// set up lucene searcher
using (var searcher = new IndexSearcher(_directory, false))
{
var hits_limit = 1000;
var analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
// search by single field
if (!string.IsNullOrWhiteSpace(searchField))
{
var sort = new Sort(new SortField[] {
SortField.FIELD_SCORE,
new SortField(searchField, SortField.STRING)
});
TopFieldCollector topField = TopFieldCollector.Create(sort, hits_limit, true, true, true, true);
var parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, searchField, analyzer);
var query = parseQuery(searchQuery, parser);
//var hits = searcher.Search(query, hits_limit).ScoreDocs;
searcher.Search(query, topField);
var hits = topField.TopDocs().ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
// search by multiple fields (ordered by RELEVANCE)
else
{
var parser = new MultiFieldQueryParser
(Lucene.Net.Util.Version.LUCENE_30, new[] { "Id", "TitleName", "SubtitleText" }, analyzer);
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search(query, null, hits_limit, Sort.INDEXORDER).ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
}
private IEnumerable <Lecturer> search(string searchQuery, string searchField = "")
{
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <Lecturer>());
}
using (var searcher = new IndexSearcher(Directory, false))
{
var analyzer = new StandardAnalyzer(Version.LUCENE_30);
var parser = new MultiFieldQueryParser(Version.LUCENE_30, new[]
{
SearchingFields.Id.ToString(),
SearchingFields.FirstName.ToString(),
SearchingFields.MiddleName.ToString(),
SearchingFields.LastName.ToString(),
SearchingFields.Group.ToString(),
SearchingFields.Name.ToString()
}, analyzer);
var query = ParseQuery(searchQuery, parser);
var docs = searcher.Search(query, null, HitsLimits, Sort.RELEVANCE).ScoreDocs;
var results = MapSearchResults(docs, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
private IEnumerable <SampleData> _search(string searchQuery)
{
// validation
if (string.IsNullOrEmpty(searchQuery.Replace("*", "").Replace("?", "")))
{
return(new List <SampleData>());
}
// set up lucene searcher
using (var searcher = new IndexSearcher(FSDirectory.Open(@"C:\Users\Totalit\Source\Repos\FilesAnalyzer\FilesAnalyzer\FilesAnalyzer\IndexedFiles"), false))
{
var hits_limit = 1000;
var analyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30);
var parser = new MultiFieldQueryParser
(Lucene.Net.Util.Version.LUCENE_30, new[] { "Author", "title", "description" }, analyzer);
var query = parseQuery(searchQuery, parser);
var hits = searcher.Search
(query, null, hits_limit, Sort.RELEVANCE).ScoreDocs;
var results = _mapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
public IEnumerable <SampleDataFileRow> _search(string searchTerm, int precision, global::Lucene.Net.Store.Directory indexDirectory)
{
Debug.Assert(!String.IsNullOrEmpty(searchTerm));
List <SampleDataFileRow> results = new List <SampleDataFileRow>();
if (String.IsNullOrEmpty(searchTerm))
{
return(results);
}
using (IndexSearcher searcher = new IndexSearcher(indexDirectory))
{
var analyzer = new StandardAnalyzer(Version.LUCENE_30, ListStopWords);
QueryParser parser = new QueryParser(Version.LUCENE_30, "LineText", analyzer);
if (precision > 0 && precision < 100)
{
parser.FuzzyMinSim = ((float)precision) * 0.01f;
}
else if (precision == 100)
{
parser.FuzzyMinSim = 0.99f;
}
else
{
parser.FuzzyMinSim = 0.8f;
}
//parser.PhraseSlop = 5;
var query = ParseQuery(searchTerm, parser);
//var query = fparseQuery(searchTerm);
ScoreDoc[] hitsFound = searcher.Search(query, null, CountSearchResults).ScoreDocs;
foreach (var t in hitsFound)
{
var sampleDataFileRow = new SampleDataFileRow();
int docId = t.Doc;
float score = t.Score;
Explanation explanation = searcher.Explain(query, t.Doc);
Document doc = searcher.Doc(docId);
sampleDataFileRow.LineNumber = int.Parse(doc.Get("LineNumber"));
sampleDataFileRow.LineText = doc.Get("LineText");
sampleDataFileRow.Score = score;
_explanationResult = explanation.ToString();
results.Add(sampleDataFileRow);
}
analyzer.Close();
searcher.Dispose();
}
return(results.OrderByDescending(x => x.Score).ToList());
}
/// <summary>
///
/// </summary>
/// <param name="searchQuery"></param>
/// <param name="field"></param>
/// <returns></returns>
private static IEnumerable <LuceneData> _Search(string searchstring, string fields = "")
{
// validating searchstring
if (string.IsNullOrEmpty(searchstring.Replace("*", "").Replace("?", "")))
{
return(new List <LuceneData>());
}
// TEMP: adding index records
AddUpdateLuceneIndex(SampleLuceneRepository.GetAll());
// setting up and using Lucene searcher
using (var searcher = new IndexSearcher(Directory, false))
{
var hitLimit = 1000;
var analyzer = new StandardAnalyzer(Version.LUCENE_30);
var parser = new MultiFieldQueryParser(Version.LUCENE_30, new[] { "PubDate", "Author", "Title", "Type", "Tags", "Description" }, analyzer);
var query = ParseQuery(searchstring, parser);
var hits = searcher.Search(query, hitLimit).ScoreDocs;
var results = MapLuceneToDataList(hits, searcher);
// closing handlers
analyzer.Close();
searcher.Dispose();
return(results);
}
}
/// <summary>
/// 获取商品信息数据
/// </summary>
/// <param name="queryString"></param>
/// <returns></returns>
public List <Commodity> QueryIndex(string queryString)
{
IndexSearcher searcher = null;
try
{
List <Commodity> ciList = new List <Commodity>();
Directory dir = FSDirectory.Open(StaticConstant.IndexPath);
searcher = new IndexSearcher(dir);
Analyzer analyzer = new PanGuAnalyzer();
//--------------------------------------这里配置搜索条件
QueryParser parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, "title", analyzer);
Query query = parser.Parse(queryString);
Console.WriteLine(query.ToString()); //显示搜索表达式
TopDocs docs = searcher.Search(query, (Filter)null, 10000);
foreach (ScoreDoc sd in docs.ScoreDocs)
{
Document doc = searcher.Doc(sd.Doc);
ciList.Add(DocumentToCommodityInfo(doc));
}
return(ciList);
}
finally
{
if (searcher != null)
{
searcher.Dispose();
}
}
}
private static IEnumerable <LuceneSearchModel> _search(string searchQuery, string[] searchFields)
{
// 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);
var parser = new MultiFieldQueryParser
(Version.LUCENE_30, searchFields, analyzer);
Query query = parseQuery(searchQuery, parser);
ScoreDoc[] hits = searcher.Search(query, null, hitsLimit, Sort.RELEVANCE).ScoreDocs;
if (hits.Length == 0)
{
searchQuery = searchByPartialWords(searchQuery);
query = parseQuery(searchQuery, parser);
hits = searcher.Search(query, hitsLimit).ScoreDocs;
}
IEnumerable <LuceneSearchModel> results = _mapLuceneToDataList(hits, searcher);
analyzer.Close();
searcher.Dispose();
return(results);
}
}
public List <Article> GetRelatedArticles(int articleId, int count)
{
var reader = IndexReader.Open(_directory, true);
var searcher = new IndexSearcher(_directory, true);
var searchQuery = new TermQuery(new Term("Id", articleId.ToString()));
var doc = searcher.Search(searchQuery, 1);
if (doc.TotalHits == 0)
{
return(new List <Article>());
}
var docId = doc.ScoreDocs[0].Doc;
MoreLikeThis mlt = new MoreLikeThis(reader);
mlt.SetFieldNames(new[] { "Name", "Body", "TagName", "FeedName" });
Query query = mlt.Like(docId);
var hits = searcher.Search(query, count + 1);
var articles = ConvertToArticles(hits, searcher, 1, count).Where(a => a.Id != articleId);
reader.Dispose();
searcher.Dispose();
return(articles.ToList());
}
private void BooleanQuery_Click(object sender, EventArgs e)
{
textBox2.Text = " ";
indexDir = FSDirectory.Open(selectedPathToIndexDir);
getQuerySubstrs();
BooleanQuery booleanQuery = new BooleanQuery();
foreach (var queryString in querySubstrs)
{
booleanQuery.Add(new TermQuery(new Term("text", queryString)), Occur.MUST);
}
IndexSearcher indexSearcher = new IndexSearcher(indexDir);
TopDocs results = indexSearcher.Search(booleanQuery, null, Int32.MaxValue);
foreach (var scoreDoc in results.ScoreDocs)
{
Document doc = indexSearcher.Doc(scoreDoc.Doc);
string field = doc.Get("name");
textBox2.Text += " " + field + "\r\n";
}
textBox2.Text += "Boolean Query Всего документов: " + results.ScoreDocs.Length + "\r\n";
//showResults(indexSearcher, results);
indexSearcher.Dispose();
indexDir.Dispose();
}
// search methods
public static IEnumerable <SearchData> GetAllIndexRecords()
{
// validate search index
if (!System.IO.Directory.EnumerateFiles(_luceneDir).Any())
{
return(new List <SearchData>());
}
// set up lucene searcher
var searcher = new IndexSearcher(_directory, false);
var reader = IndexReader.Open(_directory, false);
var docs = new List <Document>();
var term = reader.TermDocs();
// v 2.9.4: use 'term.Doc()'
// v 3.0.3: use 'term.Doc'
while (term.Next())
{
docs.Add(searcher.Doc(term.Doc));
}
reader.Dispose();
searcher.Dispose();
return(_mapLuceneToDataList(docs));
}
private static void SearchIndex(string keyword, string title)
{
IndexSearcher searcher = new IndexSearcher(FSDirectory.Open(IndexDic), true);
QueryParser qp = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, "body", new JiebaAnalyzer());
BooleanQuery bq = new BooleanQuery();
//GetKeyWordsSplitBySpace分词空格连接 搜索结果更多联想功能。不使用时：body:"银河 大道 银河 星辰 花
//。 使用后body:银河 body:大道 body:银河 body:星辰 body:花
// keyword = GetKeyWordsSplitBySpace(keyword, new JiebaTokenizer(new JiebaSegmenter(), keyword));
Query query = qp.Parse(keyword); //2008年底
bq.Add(query, Occur.MUST);
if (!string.IsNullOrEmpty(title))
{
TermQuery tq = new TermQuery(new Term("title", title));
bq.Add(tq, Occur.MUST);
}
Sort sort = new Sort(new SortField("body", SortField.SCORE, false));
TopDocs tds = searcher.Search(bq, null, 10, sort);
List <dynamic> list = new List <dynamic>();
foreach (ScoreDoc sd in tds.ScoreDocs)
{
Console.WriteLine(sd.Score);
Document doc = searcher.Doc(sd.Doc);
list.Add(new { title = doc.Get("title"), body = doc.Get("body"), data = doc.Get("data") });
}
searcher.Dispose();
Console.WriteLine(JsonConvert.SerializeObject(list));
}
private IEnumerable <string> Search(bool reverse)
{
var searcher = new IndexSearcher(_directory, true);
Point littleMermaid = _ctx.MakePoint(12.599239, 55.692848);
var sort = new Sort(new SortField(SpartialFieldName, new PointVectorDistanceFieldComparatorSource(littleMermaid, _strategy), reverse));
var q = _strategy.MakeQuery(new SpatialArgs(SpatialOperation.IsWithin, _ctx.MakeCircle(littleMermaid.GetX(), littleMermaid.GetY(), DistanceUtils.Dist2Degrees(20000, DistanceUtils.EARTH_MEAN_RADIUS_KM))));
TopDocs hits = searcher.Search(q, null, 100, sort);
var result = new string[hits.ScoreDocs.Length];
for (int i = 0; i < hits.ScoreDocs.Length; i++)
{
ScoreDoc match = hits.ScoreDocs[i];
Document doc = searcher.Doc(match.Doc);
result[i] = doc.Get(IdFieldName);
}
searcher.Dispose();
return(result);
}
public void Dispose()
{
lock (sync)
{
disposePending = false;
if (disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
RemoveDeadReferences();
if (searcherReferences.Count == 0)
{
lock (typeof(SearcherClientTracker))
{
undisposedTrackers.Remove(this);
}
searcher.Dispose();
disposed = true;
}
else
{
disposePending = true;
}
}
}
public void Dispose()
{
searcher.Dispose();
writer.Dispose();
directory.Dispose();
analyzer = null;
}
/// <summary>
/// 分页查询
/// </summary>
/// <param name="strCondition">查询条件 lucene的查询语法</param>
/// <param name="page">分页相关</param>
/// <param name="strFilter">[100,3000]</param>
/// <returns></returns>
public List <T> QueryByPage(string strCondition, Page page, string strFilter)
{
IndexSearcher searcher = null;
try
{
List <T> ciList = new List <T>();
searcher = CreateSearcher();
Analyzer analyzer = new PanGuAnalyzer();
//--------------------------------------这里配置搜索条件
QueryParser parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, "Title", analyzer);
Query query = parser.Parse(strCondition);
int startIndex = (page.PageIndex - 1) * page.PageSize;
int endIndex = page.PageIndex * page.PageSize;
var property = Properties.Where(u => u.Name.Equals(page.Sort)).FirstOrDefault();
Sort sort = null;
if (!string.IsNullOrEmpty(page.Sort))
{
//排序
sort = new Sort();
//找到该属性
SortField sortField = new SortField(page.Sort, SortField.DOUBLE, page.Order.Equals("asc", StringComparison.CurrentCultureIgnoreCase));
sort.SetSort(sortField);
}
Filter filter = null;
TopDocs docs = null;
if (sort != null && !string.IsNullOrEmpty(strFilter))
{
Tuple <double, double> tuple = QueryTools.GetMinAndMax(strFilter);
if (tuple != null)
{
filter = QueryTools.GetNumberFilter(property, tuple.Item1, tuple.Item2);
docs = searcher.Search(query, filter, 10000, sort);
}
}
else
{
//filter = NumericRangeFilter.NewDoubleRange("Price", 100, 400, true, true);
docs = searcher.Search(query, filter, 1000);
}
//获取中标的数据
page.Total = docs.TotalHits;
//PrintScores(docs, startIndex, endIndex, searcher);
for (int i = startIndex; i < endIndex && i < page.Total; i++)
{
Document doc = searcher.Doc(docs.ScoreDocs[i].Doc);
ciList.Add(ParseDocToEntity(doc));
}
return(ciList);
}
finally
{
searcher?.Dispose();
}
}
public bool TryDispose()
{
lock (sync)
{
disposePending = false;
if (disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
RemoveDeadReferences();
if (searcherReferences.Count == 0)
{
lock (typeof(SearcherClientTracker))
{
undisposedTrackers.Remove(this);
}
var reader = searcher.IndexReader;
searcher.Dispose();
// NB IndexSearcher.Dispose() does not Dispose externally provided IndexReader:
reader.Dispose();
disposed = true;
}
else
{
disposePending = true;
}
return(disposed);
}
}
/// <summary>
/// method to return the whole Lucene search index
/// </summary>
/// <returns></returns>
public IEnumerable <LearningCourseDTO> GetAllIndexRecords()
{
// validate search index
if (!System.IO.Directory.EnumerateFiles(_luceneDir).Any())
{
return(new List <LearningCourseDTO>());
}
// set up lucene searcher
var searcher = new IndexSearcher(_directory, false);
var reader = IndexReader.Open(_directory, false);
var docs = new List <Document>();
var term = reader.TermDocs();
while (term.Next())
{
docs.Add(searcher.Doc(term.Doc));
}
reader.Dispose();
searcher.Dispose();
var mapper = new LearningCourseMapper();
return(mapper.MapLuceneToDataList(docs));
}
/// <summary>
/// Searches the datasource using the specified criteria. Criteria is parsed by the query builder specified by
/// <typeparamref
/// name="QueryBuilderType" />
/// .
/// </summary>
/// <param name="scope">Name of the application.</param>
/// <param name="criteria">The criteria.</param>
/// <returns></returns>
/// <exception cref="VirtoCommerce.Search.Providers.Lucene.LuceneSearchException"></exception>
public virtual ISearchResults Search(string scope, ISearchCriteria criteria)
{
TopDocs docs = null;
var folderName = this.GetFolderName(scope, criteria.DocumentType);
var dir = FSDirectory.Open(new DirectoryInfo(this.GetDirectoryPath(folderName)));
var searcher = new IndexSearcher(dir);
var q = (Query)this.QueryBuilder.BuildQuery(criteria);
Debug.WriteLine("Search Lucene Query:{0}", (object)q.ToString());
try
{
var numDocs = criteria.StartingRecord + criteria.RecordsToRetrieve;
if (criteria.Sort != null)
{
var fields = criteria.Sort.GetSort();
docs = searcher.Search(
q,
null,
numDocs,
new Sort(
fields.Select(field => new SortField(field.FieldName, field.DataType, field.IsDescending))
.ToArray()));
}
else
{
docs = searcher.Search(q, numDocs);
}
}
catch (Exception ex)
{
throw new LuceneSearchException("Search exception", ex);
}
var results = new LuceneSearchResults(searcher, searcher.IndexReader, docs, criteria, q);
// Cleanup here
searcher.IndexReader.Dispose();
searcher.Dispose();
return results.Results;
}
