public static Query SafeGetSearchQuery(this string term, MultiFieldQueryParser q, Analyzer analyser)
{
Query query;
try
{
query = q.Parse(term.MakeFuzzy());
}
catch
{
var searchTerm = term.Sanitize(analyser);
query = q.Parse(searchTerm);
}
return(query);
}
public static IEnumerable <BaseItem> Search(string searchQuery, int maxHits)
{
var results = new List <BaseItem>();
lock (lockOb)
{
try
{
if (searcher == null)
{
searcher = new IndexSearcher(directory, true);
}
BooleanQuery finalQuery = new BooleanQuery();
MultiFieldQueryParser parser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30, new string[] { "Name", "Overview" }, analyzer, bonusTerms);
string[] terms = searchQuery.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
foreach (string term in terms)
{
finalQuery.Add(parser.Parse(term.Replace("~", "") + "~0.75"), Occur.SHOULD);
}
foreach (string term in terms)
{
finalQuery.Add(parser.Parse(term.Replace("*", "") + "*"), Occur.SHOULD);
}
logger.Debug("Querying Lucene with query: " + finalQuery.ToString());
long start = DateTime.Now.Ticks;
var searchResult = searcher.Search(finalQuery, maxHits);
foreach (var searchHit in searchResult.ScoreDocs)
{
Document hit = searcher.Doc(searchHit.Doc);
results.Add(BaseItem.LibraryManager.GetItemById(Guid.Parse(hit.Get("Id"))));
}
long total = DateTime.Now.Ticks - start;
float msTotal = (float)total / TimeSpan.TicksPerMillisecond;
logger.Debug(searchResult.ScoreDocs.Length + " result" + (searchResult.ScoreDocs.Length == 1 ? "" : "s") + " in " + msTotal + " ms.");
}
catch (Exception e)
{
logger.ErrorException("Error while searching Lucene index", e);
}
}
return(results);
}
public IEnumerable <TLauncherEntry> BySearchExpression(string exp)
{
if (string.IsNullOrEmpty(exp))
{
yield break;
}
TopDocs hits = null;
try {
var parser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_CURRENT, new string[] {
"label",
"description",
"category"
}, new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_CURRENT));
parser.AllowLeadingWildcard = true;
hits = reader.Search(parser.Parse(exp), 1000);
} catch (Exception ex) {
CoreLib.Log(ex.ToString());
}
if (hits != null)
{
for (var i = 0; i < hits.TotalHits; i++)
{
yield return(new TLauncherEntry(reader.Doc(hits.ScoreDocs[i].Doc)));
}
}
}
public IEnumerable <Ticket> SearchIndex(ITicketService ticketService, string searchText, out string queryTerm)
{
string[] fields = new[] { "title", "details", "tags", "comments" };
MultiFieldQueryParser parser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_29, fields, TdIndexAnalyzer);
Query query = parser.Parse(searchText);
queryTerm = query.ToString();
TopScoreDocCollector collector = TopScoreDocCollector.create(20, true);
TdIndexSearcher.Search(query, collector);
ScoreDoc[] hits = collector.TopDocs().scoreDocs;
SortedList <int, int> ticketIDs = new SortedList <int, int>();
var o = 0;
foreach (ScoreDoc scoreDoc in hits)
{
//Get the document that represents the search result.
Document document = TdIndexSearcher.Doc(scoreDoc.doc);
int ticketID = int.Parse(document.Get("ticketid"));
//The same document can be returned multiple times within the search results.
if (!ticketIDs.Values.Contains(ticketID))
{
ticketIDs.Add(o, ticketID);
o++;
}
}
return(ticketService.ListTickets(ticketIDs, false));
}
public IList <LuceneSearchResult> Search(string term, string screeningEntityName, int numResults)
{
using (SearcherManager manager = new SearcherManager(ScreeningResponseIndexWriterSingleton.Instance))
{
this.searcher = manager.Acquire().Searcher;
QueryParser parser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30,
new string[] { "Reason", "Commentary" },
new SimpleAnalyzer());
parser.DefaultOperator = QueryParser.Operator.AND;
parser.AllowLeadingWildcard = true;
try
{
Query query = parser.Parse(term);
BooleanQuery bq = new BooleanQuery();
bq.Add(query, Occur.MUST);
bq.Add(new TermQuery(new Term("ScreeningEntityName", screeningEntityName)), Occur.MUST);
log.Debug("Search query: " + bq.ToString());
this.topDocs = this.searcher.Search(bq, numResults);
return(TransformTopDocs());
}
catch (ParseException e)
{
log.Error("Encountered problem parsing the search term: " + term, e);
return(new List <LuceneSearchResult>());
}
}
}
public override List <SearchResult> Search(string searchStr)
{
List <SearchResult> results = new List <SearchResult>();
string cleanSearchStr = cleaner.Replace(searchStr, "").ToLower().Trim();
IndexSearcher searcher = new IndexSearcher(directory);
//QueryParser parser = new QueryParser("title", analyzer);
//Query query = parser.Parse(cleanSearchStr + "~0.7");
Query query = parser.Parse(cleanSearchStr + "~0.7");
Hits hits = searcher.Search(query);
int resultCount = hits.Length();
for (int i = 0; i < resultCount; i++)
{
SearchResult result = new SearchResult();
result.Item = DatabaseManager.Get <T>(int.Parse(hits.Doc(i).Get("id")));
result.Score = hits.Score(i);
results.Add(result);
}
return(results);
}
static void Main(string[] args)
{
Lucene.Net.Util.Version version = Lucene.Net.Util.Version.LUCENE_29;
Directory dir = new RAMDirectory();
Analyzer analyzer = new StandardAnalyzer(version);
var docs = CreateDocuments();
AddToIndex(docs, dir, analyzer);
// Search for the content
var parser = new MultiFieldQueryParser(version, new[] { "name" }, analyzer);
Query q = parser.Parse("An*");
Filter filter = TermRangeFilter.More("date", DateTools.DateToString(new DateTime(2011, 1, 1), DateTools.Resolution.DAY));
var searcher = new IndexSearcher(dir, true);
TopDocs hits = searcher.Search(q, filter, 5, Sort.RELEVANCE);
Console.WriteLine("Found {0} document(s) that matched query '{1}':", hits.TotalHits, q);
foreach (ScoreDoc match in hits.ScoreDocs)
{
Document doc = searcher.Doc(match.Doc);
Console.WriteLine("Matched id = {0}, Name = {1}", doc.Get("id"), doc.Get("name"));
}
searcher.Close();
}
IEnumerable <string> Search(string textToFind)
{
var reader = IndexReader.Open(_ramDirectory, true);
var searcher = new IndexSearcher(reader);
var analyzer = new StandardAnalyzer(Version.LUCENE_29);
var parser = new MultiFieldQueryParser(Version.LUCENE_29, _searchFields, analyzer);
var query = parser.Parse(textToFind);
var collector = TopScoreDocCollector.create(100, true);
searcher.Search(query, collector);
var hits = collector.TopDocs().scoreDocs;
var foundKeys = new List <string>();
foreach (ScoreDoc scoreDoc in hits)
{
var document = searcher.Doc(scoreDoc.doc);
var key = document.Get(_keyField);
if (key != null && !foundKeys.Contains(key))
{
foundKeys.Add(key);
}
}
reader.Close();
searcher.Close();
analyzer.Close();
return(foundKeys);
}
public SearchResult Search(string searchQuery)
{
if (string.IsNullOrEmpty(searchQuery))
{
return new SearchResult()
{
KeyWords = searchQuery
}
}
;
var terms = searchQuery.Trim().Replace("-", " ").Split(' ').Where(x => !string.IsNullOrEmpty(x)).Select(x => x.Trim());
searchQuery = string.Join(" ", terms);
using (var searcher = new IndexSearcher(directory, false))
{
var analyzer = new StandardAnalyzer(Version.LUCENE_30);
var parser = new MultiFieldQueryParser(Version.LUCENE_30, fields.ToArray(), analyzer);
var query = parser.Parse(searchQuery);
ScoreDoc[] hits = searcher.Search(query, null, maxHits, Sort.RELEVANCE).ScoreDocs;
SearchResult results = MapEntities(hits, searcher);
results.KeyWords = searchQuery;
analyzer.Close();
return(results);
}
}
}
/// <summary>
/// 多字段搜索(以空格，逗号等分隔符隔开)
/// </summary>
/// <param name="keyword"></param>
/// <returns></returns>
private TopDocs MulFieldsSearch(string keyword)
{
TopDocs docs = null;
int n = 100;
SetOutput("正在检索关键字：" + keyword);
try
{
BooleanClause.Occur[] flags = new BooleanClause.Occur[] { BooleanClause.Occur.MUST, BooleanClause.Occur.MUST };
string[] fields = new string[] { "id", "contents" };
string[] values = keyword.Trim().Split(new char[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries);
if (fields.Length != values.Length)
{
throw new Exception("字段和对应值不一致");
}
//MultiFieldQueryParser parser = new MultiFieldQueryParser(fields, new StandardAnalyzer());
//parser.SetDefaultOperator(QueryParser.Operator.OR);//或者的关系
//Query query = parser.Parse(keyword);
Query query = MultiFieldQueryParser.Parse(values, fields, flags, new StandardAnalyzer());
Stopwatch watch = new Stopwatch();
watch.Start();
docs = searcher.Search(query, (Filter)null, n); //排序获取搜索结果
watch.Stop();
StringBuffer sb = "搜索完成,共用时：" + watch.Elapsed.Hours + "时 " + watch.Elapsed.Minutes + "分 " + watch.Elapsed.Seconds + "秒 " + watch.Elapsed.Milliseconds + "毫秒";
SetOutput(sb);
}
catch (Exception ex)
{
SetOutput(ex.Message);
}
return(docs);
}
public static List <Post> Search(string terms)
{
if (string.IsNullOrEmpty(terms.Replace("*", "").Replace("?", "")))
{
return(new List <Post>());
}
using (var searcher = new IndexSearcher(Directory, false))
{
using (var analyzer = new StandardAnalyzer(Version.LUCENE_30))
{
var parser = new MultiFieldQueryParser(Version.LUCENE_30, new[] { "title", "body" }, analyzer);
var query = parser.Parse(terms.Trim());
var hits = searcher.Search(query, null, 1000, Sort.RELEVANCE).ScoreDocs;
var posts = new List <Post>();
var db = new PostRepository();
foreach (var hit in hits)
{
int id = hit.Doc;
Document doc = searcher.Doc(id);
posts.Add(db.GetPost(doc.Get("slug")));
}
return(posts);
}
}
}
/// <summary>
/// 查询所有符合条件的内容
/// </summary>
/// <param name="kw">关键词</param>
/// <param name="segment">提取长度</param>
/// <returns></returns>
public static IEnumerable <PostOutputDto> Search(string kw, int segment = 200)
{
if (string.IsNullOrEmpty(IndexPath))
{
throw new Exception("未设置索引文件夹路径，参数名：" + IndexPath);
}
string indexPath = IndexPath;
using (var analyzer = new PanGuAnalyzer())
{
var list = CutKeywords(kw);
var result = new ConcurrentQueue <PostOutputDto>();
Parallel.ForEach(list, k =>
{
if (k.Contains(new[] { @"\?", @"\*", @"\+", @"\-", @"\[", @"\]", @"\{", @"\}", @"\(", @"\)", "�" }))
{
return;
}
FSDirectory directory = FSDirectory.Open(new DirectoryInfo(indexPath), new NoLockFactory());
IndexReader reader = IndexReader.Open(directory, true);
var searcher = new IndexSearcher(reader);
QueryParser parser = new MultiFieldQueryParser(Version.LUCENE_30, new[] { nameof(Post.Id), nameof(Post.Title), nameof(Post.Content), nameof(Post.Author), nameof(Post.Label), nameof(Post.Email), nameof(Post.Keyword) }, analyzer); //多个字段查询
Query query = parser.Parse(k);
int n = 100000;
TopDocs docs = searcher.Search(query, null, n);
if (docs?.TotalHits != 0 && docs?.ScoreDocs != null)
{
foreach (ScoreDoc sd in docs.ScoreDocs) //遍历搜索到的结果
{
Document doc = searcher.Doc(sd.Doc);
if (result.Any(p => p.Id == doc.Get(nameof(Post.Id)).ToInt32()))
{
continue;
}
var simpleHtmlFormatter = new SimpleHTMLFormatter("<span style='color:red;background-color:yellow;font-size: 1.1em;font-weight:700;'>", "</span>");
var highlighter = new Highlighter(simpleHtmlFormatter, new Segment())
{
FragmentSize = segment
};
var content = doc.Get(nameof(Post.Content));
if (content.Length <= segment)
{
segment = content.Length;
}
result.Enqueue(new PostOutputDto()
{
Id = doc.Get(nameof(Post.Id)).ToInt32(),
Title = doc.Get(nameof(Post.Title)).ToLower().Contains(k.ToLower()) ? highlighter.GetBestFragment(k, doc.Get(nameof(Post.Title))) : doc.Get(nameof(Post.Title)),
Content = content.ToLower().Contains(k.ToLower()) ? highlighter.GetBestFragment(k, content) : content.Substring(0, segment),
Author = doc.Get(nameof(Post.Author)).ToLower().Contains(k.ToLower()) ? highlighter.GetBestFragment(k, doc.Get(nameof(Post.Author))) : doc.Get(nameof(Post.Author)),
Label = doc.Get(nameof(Post.Label)).ToLower().Contains(k.ToLower()) ? highlighter.GetBestFragment(k, doc.Get(nameof(Post.Label))) : doc.Get(nameof(Post.Label)),
Email = doc.Get(nameof(Post.Email)).ToLower().Contains(k.ToLower()) ? highlighter.GetBestFragment(k, doc.Get(nameof(Post.Email))) : doc.Get(nameof(Post.Email)),
Keyword = doc.Get(nameof(Post.Keyword)).ToLower().Contains(k.ToLower()) ? highlighter.GetBestFragment(k, doc.Get(nameof(Post.Keyword))) : doc.Get(nameof(Post.Keyword))
});
}
}
});
return(result.Where(p => !string.IsNullOrEmpty(p.Title)).DistinctBy(p => p.Id));
}
}
public virtual List <SearchFacet> GetSearchFacets(IQueryExpression expression, string[] groupByFields, Directory directory = null)
{
if (directory == null)
{
directory = LuceneContext.Directory;
}
groupByFields = groupByFields.Select(x => ContentIndexHelpers.GetIndexFieldName(x)).ToArray();
var result = new List <SearchFacet>();
using (IndexReader indexReader = IndexReader.Open(directory, true))
{
var queryParser = new MultiFieldQueryParser(LuceneConfiguration.LuceneVersion, expression.GetFieldName()
, LuceneConfiguration.Analyzer);
queryParser.AllowLeadingWildcard = true;
var query = queryParser.Parse(expression.GetExpression());
SimpleFacetedSearch facetSearch = new SimpleFacetedSearch(indexReader, groupByFields);
SimpleFacetedSearch.Hits hits = facetSearch.Search(query, int.MaxValue);
long totalHits = hits.TotalHitCount;
foreach (SimpleFacetedSearch.HitsPerFacet hitPerGroup in hits.HitsPerFacet)
{
long hitCountPerGroup = hitPerGroup.HitCount;
result.Add(new SearchFacet()
{
Count = hitPerGroup.HitCount,
Term = hitPerGroup.Name.ToString()
});
}
}
return(result);
}
/// <summary>
/// 查询多个字段
/// </summary>
/// <param name="searchKey"></param>
/// <param name="pageNum">页长</param>
/// <param name="currentPageNo">当前页</param>
private void SearchIndex(string searchKey, int pageNum = 10, int currentPageNo = 1)
{
Dictionary <string, string> dic = new Dictionary <string, string>();
BooleanQuery bQuery = new BooleanQuery();
#region 一个字段查询
//if (!string.IsNullOrEmpty(title))
//{
// title = GetKeyWordsSplitBySpace(title);
// QueryParser parse = new QueryParser(LN.Util.Version.LUCENE_30, "title", PanGuAnalyzer);//一个字段查询
// Query query = parse.Parse(title);
// parse.DefaultOperator = QueryParser.Operator.OR;
// bQuery.Add(query, new Occur());
// dic.Add("title", title);
//}
#endregion
string[] fileds = { "title", "content" }; //查询字段
searchKey = GetKeyWordsSplitBySpace(searchKey);
QueryParser parse = new MultiFieldQueryParser(LN.Util.Version.LUCENE_30, fileds, PanGuAnalyzer); //多个字段查询
Query query = parse.Parse(searchKey);
bQuery.Add(query, new Occur());
dic.Add("title", searchKey);
dic.Add("content", searchKey);
if (bQuery != null && bQuery.GetClauses().Length > 0)
{
GetSearchResult(bQuery, dic);
}
}
private static Query GetQuery(SearchRequest request)
{
Query result = null;
if (!string.IsNullOrEmpty(request?.SearchKeywords))
{
var searchKeywords = request.SearchKeywords;
if (request.IsFuzzySearch)
{
const string fuzzyMinSimilarity = "0.7";
var keywords = searchKeywords.Replace("~", string.Empty).Split(_keywordSeparator, StringSplitOptions.RemoveEmptyEntries);
searchKeywords = string.Empty;
searchKeywords = keywords.Aggregate(searchKeywords, (current, keyword) => current + $"{keyword}~{fuzzyMinSimilarity}");
}
var fields = request.SearchFields?.Select(LuceneSearchHelper.ToLuceneFieldName).ToArray() ?? LuceneSearchHelper.SearchableFields;
var analyzer = new StandardAnalyzer(_matchVersion);
var parser = new MultiFieldQueryParser(_matchVersion, fields, analyzer)
{
DefaultOperator = QueryParserBase.AND_OPERATOR
};
result = parser.Parse(searchKeywords);
}
return(result);
}
public static List <Book> SearchBooks(string propertyValue)
{
List <Book> books = new List <Book>();
IndexReader indexReader = IndexReader.Open(directory, true);
using (var reader = IndexReader.Open(directory, true))
using (var searcher = new IndexSearcher(reader))
{
using (Analyzer myAnalyzer = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30))
{
var queryParser = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30, "Author|Title".Split('|'), myAnalyzer);
queryParser.AllowLeadingWildcard = true;
var query = queryParser.Parse("*" + propertyValue + "*");
var collector = TopScoreDocCollector.Create(2, true);
searcher.Search(query, collector);
var matches = collector.TopDocs().ScoreDocs;
foreach (var hit in matches)
{
var id = hit.Doc;
var documentFromSearch = searcher.Doc(id);
books.Add(new Models.Book()
{
BookId = Convert.ToInt32(documentFromSearch.Get("BookId")),
Author = documentFromSearch.Get("Author"),
Title = documentFromSearch.Get("Title")
});
}
}
}
return(books);
}
public Card[] Search(string queryString = null, SorterBuilder sorterBuilder = null)
{
Query query = null;
if (string.IsNullOrWhiteSpace(queryString))
{
query = new MatchAllDocsQuery();
}
else
{
var parser = new MultiFieldQueryParser(MyLucene.LuceneVersion, MyLucene.GetSearchField(), MyLucene.GetCardAnalyzer(), MyLucene.GetFieldBoosts());
query = parser.Parse(queryString);
}
try
{
var searcher = MyLucene.GetIndexSearcher();
TopDocs topDocs = sorterBuilder == null
? searcher.Search(query, int.MaxValue)
: searcher.Search(query, int.MaxValue, sorterBuilder.ToLuceneSort());
var total = topDocs.TotalHits;
var cards = new Card[total];
for (int i = 0; i < total; i++)
{
cards[i] = GetCardByIndex(topDocs.ScoreDocs[i].Doc);
}
return(cards);
}
catch
{
return(new Card[0]);
}
}
public IEnumerable <DocumentResult> Search(string searchTerm)
{
var directory = new SimpleFSDirectory(new DirectoryInfo(_indexDir), new NativeFSLockFactory());
using (var searcher = new IndexSearcher(directory, true))
using (var analyzer = new StandardAnalyzer(Version.LUCENE_30))
{
var parser = new MultiFieldQueryParser(Version.LUCENE_30, new[] { "Entry", "Content" }, analyzer);
var query = parser.Parse(searchTerm);
var hits = searcher.Search(query, 1000).ScoreDocs;
var documents = hits
.Select(hit => searcher.Doc(hit.Doc))
.ToList();
return(documents
.Select(
document =>
new DocumentResult
{
FileName = document.Get("Entry"),
DisplayText = document.Get("Entry").CreateDisplayTextFromFileName()
})
.DistinctBy(result => result.FileName)
.ToList());
}
}
//http://www.d80.co.uk/post/2011/03/29/LuceneNet-Tutorial.aspx Lucene.Net Tutorial with Lucene 2.9.2
public void SearchV2(string indexDir, string q, int pageSize, int pageIndex)
{
indexDir = HttpContext.Current.Server.MapPath("~/Search/");
string keywords = q;
var search = new IndexSearcher(indexDir);
q = GetKeyWordsSplitBySpace(q, new PanGuTokenizer());
// 需要查询的域名称
string[] fields = { "title", "Category", "Desc" };
//将每个域Field所查询的结果设为“或”的关系，也就是取并集
BooleanClause.Occur[] clauses = { BooleanClause.Occur.SHOULD, BooleanClause.Occur.SHOULD };
//构造一个多Field查询
Query query = MultiFieldQueryParser.Parse(Lucene.Net.Util.Version.LUCENE_29, q, fields, clauses, new PanGuAnalyzer(true));
// 新的查询
TopDocs newHits = search.Search(query, 100);
ScoreDoc[] scoreDocs = newHits.ScoreDocs;
Console.WriteLine("符合条件记录:{0}; 索引库记录总数:{1}", scoreDocs.Length, search.GetIndexReader().NumDocs());
foreach (var hit in newHits.ScoreDocs)
{
var documentFromSearcher = search.Doc(hit.doc);
Console.WriteLine(documentFromSearcher.Get("Make") + " " + documentFromSearcher.Get("Model"));
}
search.Close();
}
private IList <Document> Search(string searchText, string itemsFolder, string[] fieldNames)
{
if (string.IsNullOrEmpty(searchText))
{
return(new List <Document>());
}
try
{
using var analyzer = new EnglishAnalyzer(LuceneVersion.LUCENE_48);
using var reader = DirectoryReader.Open(GetDirectory(itemsFolder));
var searcher = new IndexSearcher(reader);
var parser = new MultiFieldQueryParser(LuceneVersion.LUCENE_48, fieldNames, analyzer);
var query = parser.Parse(QueryParserBase.Escape(searchText.Trim()));
//TODO: change 100 to page size when paging is implemented
var hits = searcher.Search(query, null, 100, Sort.RELEVANCE).ScoreDocs;
return(hits.Select(x => searcher.Doc(x.Doc)).ToList());
}
catch (Exception ex)
{
throw;
}
}
public Query CreateMultiFieldQuery(string pattern)
{
// TODO: pattern should be analyzed/converted on per-field basis.
var parser = new MultiFieldQueryParser(version, fieldMap.Keys.ToArray(), externalAnalyzer);
return(parser.Parse(pattern));
}
public static LuceneResultNode SearchEx(IndexBase index, SearchNode node)
{
try
{
var query = MultiFieldQueryParser.Parse(Lucene.Net.Util.Version.LUCENE_29, node.Queries, node.Fields, node.Occurs, new PanGuAnalyzer(true));
foreach (NumberRangeNode n in node.NumberRangeFiters)
{
query = new FilteredQuery(query, NumericRangeFilter.NewIntRange(n.FieldName, n.MinValue, n.MaxValue, true, true));
}
foreach (LongRangeNode lr in node.LongRnageFilters)
{
query = new FilteredQuery(query, NumericRangeFilter.NewLongRange(lr.FieldName, lr.MinValue, lr.MaxValue, true, true));
}
foreach (ContainFilterNode cf in node.ContainFilters)
{
query = new FilteredQuery(query, new ContainFilter(new Term(cf.FieldName, cf.Text)));
}
return(ResponseSearch(index, query, node, 0));
}
catch (Lucene.Net.QueryParsers.ParseException)
{
return(new LuceneResultNode()
{
AllCount = 0, Result = new List <string>()
});
}
catch (Exception ex)
{
throw ex;
}
}
public List <SearchResultItem> Search(string text, string filter = "", int resultListLength = 250)
{
List <SearchResultItem> searchResult = new List <SearchResultItem>();
string[] fields = GetSearchFields(filter);
QueryParser qp = new MultiFieldQueryParser(Lucene.Net.Util.Version.LUCENE_30,
fields,
new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30));
qp.DefaultOperator = _defaultOperator;
Query q = qp.Parse(text);
TopDocs topDocs = _indexSearcher.Search(q, resultListLength);
//hits = topDocs.TotalHits;
foreach (var d in topDocs.ScoreDocs)
{
Document doc = _indexSearcher.Doc(d.Doc);
searchResult.Add(new SearchResultItem()
{
Path = doc.Get(SearchConstants.SEARCH_FIELD_PATH),
Table = doc.Get(SearchConstants.SEARCH_FIELD_TABLE),
Title = doc.Get(SearchConstants.SEARCH_FIELD_TITLE),
Score = d.Score,
Published = GetPublished(doc)
});
}
return(searchResult);
}
public static SearchResults Query(HttpContext ctx, string query, int page = 1)
{
if (string.IsNullOrWhiteSpace(query))
{
return(new SearchResults {
Documents = new SearchResult[0],
TotalCount = 0
});
}
var indexPath = ctx.Server.MapPath("~/App_Data/Index");
var indexSearcher = new DirectoryIndexSearcher(new DirectoryInfo(indexPath));
using (var searchService = new SearchService(indexSearcher)) {
var parser = new MultiFieldQueryParser(
Lucene.Net.Util.Version.LUCENE_29,
new[] { "Text" },
new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29));
Query multiQuery = parser.Parse(query);
var result = searchService.SearchIndex(multiQuery);
return(new SearchResults {
Documents = result.Results
.Skip(PageSize * (page - 1))
.Take(PageSize)
.Select(d => new SearchResult {
Url = d.Get("Url"),
Title = d.Get("Title"),
Summary = d.Get("Summary")
}),
TotalCount = result.Results.Count()
});
}
}
private void Search(string q)
{
IndexReader indexReader = IndexReader.Open(_directory, true);
Searcher indexSearch = new IndexSearcher(indexReader);
var queryParser = new MultiFieldQueryParser(luceneVersion, new string[] { "TITLE", "DESCRIPTION" }, _analyzer);
var query = queryParser.Parse(q);
Console.WriteLine("[검색어] {0}", query);
TopDocs resultDocs = indexSearch.Search(query, indexReader.MaxDoc);
var hits = resultDocs.ScoreDocs;
int currentRow = 0;
foreach (var hit in hits)
{
var documentFromSearch = indexSearch.Doc(hit.Doc);
Console.WriteLine("* Result {0}", ++currentRow);
Console.WriteLine("\t-도서명 : {0}", documentFromSearch.Get("TITLE"));
Console.WriteLine("\t-요약 : {0}", documentFromSearch.Get("DESCRIPTION"));
Console.WriteLine("\t-가격 : {0}", documentFromSearch.Get("PRICE"));
}
Console.WriteLine();
}
public static List <Note> Search(string text, User user, bool myOnly, DateTime from, DateTime to, int top, long?gen = null)
{
var parser = new MultiFieldQueryParser(LuceneVersion.LUCENE_48, SearchFields, analyzer)
{
DefaultOperator = Operator.AND
};
var escapedText = text.TrimToNull().EscapeText() ?? EmptyRequest;
var escapedLogin = (myOnly ? user?.Login.EscapeKeyword() : null) ?? EmptyRequest;
var query = parser.Parse($"(({escapedText}) OR ({escapedText.HashWords(user?.Key)})) login:{escapedLogin}");
if (gen != null && gen <= trackingWriter.Generation)
{
reopenThread.WaitForGeneration(gen.Value, 3000);
}
var searcher = searcherKeeper.Acquire();
try
{
var filter = NumericRangeFilter.NewInt64Range("time", from.ToUnixTimeMinutes(), to.ToUnixTimeMinutes(), true, true);
var hits = searcher.Search(query, filter, top <= 0 ? 1 : top, IndexDescSortOrder, false, false);
return(hits.ScoreDocs.Take(top).Select(hit => searcher.Doc(hit.Doc)).Select(doc => new Note
{
Author = doc.Get("author"),
Title = doc.Get("title"),
Text = doc.Get("text"),
Time = doc.GetField("time")?.GetInt64Value()?.FromUnixTimeMinutes() ?? default
}).ToList());
}
public IEnumerable <IDictionary <string, string> > Search(string q)
{
q = q.ToLower();
// by default, results will not include dropped objects, but you can add dropped:? to over-ride this
if (!q.Contains("dropped:"))
{
q = string.Format("({0}) -dropped:true", q);
}
var query = _parser.Parse(q);
var topFieldCollector = TopFieldCollector.Create(
sort: Sort.RELEVANCE,
numHits: _resultsLimit,
fillFields: false,
trackDocScores: true,
trackMaxScore: false,
docsScoredInOrder: false
);
_searcher.Search(query, topFieldCollector);
var topDocs = topFieldCollector.TopDocs();
if (topDocs == null)
{
return(Enumerable.Repeat(new Dictionary <string, string>(), 0));
}
var results = topDocs.ScoreDocs.Select(hit => Docs.DocToDict(_searcher.Doc(hit.Doc), hit.Score)).ToArray();
_logger.Debug("Search of '{0}' return {1} results.", q, results.Count());
return(results);
}
public SearchResultCollection Search(string searchQuery, int hitsStart, int hitsStop, string[] fields)
{
if (string.IsNullOrEmpty(searchQuery))
{
return(new SearchResultCollection());
}
const int hitsLimit = 100;
SearchResultCollection results;
using (var analyzer = new StandardAnalyzer(LuceneVersion))
{
using (var reader = DirectoryReader.Open(Directory))
{
var searcher = new IndexSearcher(reader);
var parser = new MultiFieldQueryParser(LuceneVersion, fields, analyzer);
var query = parser.Parse(QueryParserBase.Escape(searchQuery.Trim()));
var hits = searcher.Search(query, null, hitsLimit, Sort.RELEVANCE).ScoreDocs;
results = new SearchResultCollection
{
Count = hits.Length,
Data = hits.Where((x, i) => i >= hitsStart && i < hitsStop)
.Select(x => new SearchResult(searcher.Doc(x.Doc)))
.ToList()
};
//var res=new LuceneSearchModel()
}
}
//return results;
return(new SearchResultCollection());
}
public Task <IEnumerable <SearchResultItem> > SearchAsync(string searchText)
{
return(Task.Run(() =>
{
var fields = new[] { "id", "title", "details", "tags", "events" };
var parser = new MultiFieldQueryParser(Version.LUCENE_30,
fields,
TdIndexAnalyzer);
var query = parser.Parse(searchText);
var collector = TopScoreDocCollector.Create(20, true);
TdIndexSearcher.Search(query, collector);
return collector.TopDocs().ScoreDocs.Select(d =>
{
var document = TdIndexSearcher.Doc(d.Doc);
return new SearchResultItem
{
Id = int.Parse(document.Get("id")),
SearchScore = d.Score
};
});
}));
}
/// <summary>
/// 搜索（返回所有）
/// </summary>
/// <param name="indexPath">返回结果数据类型</param>
/// <param name="keyword"></param>
/// <param name="fields"></param>
/// <param name="flags"></param>
/// <param name="sort"></param>
/// <returns></returns>
public static List <T> Search <T>(string indexPath, string[] queries, string[] fields, Occur[] flags, Sort sort) where T : BaseIndexModel
{
if (string.IsNullOrWhiteSpace(indexPath))
{
return(null);
}
if (queries == null || queries.Length < 1)
{
return(null);
}
queries = queries.Where(p => !string.IsNullOrWhiteSpace(p)).ToArray();
if (queries.Length != fields.Length)
{
return(null);
}
if (fields.Length != flags.Length)
{
return(null);
}
Analyzer analyzer = new StandardAnalyzer(IndexConfiguration.LuceneMatchVersion);
Query query = MultiFieldQueryParser.Parse(IndexConfiguration.LuceneMatchVersion, queries, fields, flags, analyzer);
var list = Search <T>(indexPath, query, sort);
return(list);
}
/// <summary>
/// Builds the query.
/// </summary>
/// <param name="criteria">The criteria.</param>
/// <returns></returns>
public override object BuildQuery(ISearchCriteria criteria)
{
var builder = base.BuildQuery(criteria) as QueryBuilder;
var query = builder.Query as BooleanQuery;
var analyzer = new StandardAnalyzer(u.Version.LUCENE_30);
if (criteria is CatalogItemSearchCriteria)
{
var c = criteria as CatalogItemSearchCriteria;
var datesFilterStart = new TermRangeQuery(
"startdate", c.StartDateFrom.HasValue ? DateTools.DateToString(c.StartDateFrom.Value, DateTools.Resolution.SECOND) : null, DateTools.DateToString(c.StartDate, DateTools.Resolution.SECOND), false, true);
query.Add(datesFilterStart, Occur.MUST);
if (c.EndDate.HasValue)
{
var datesFilterEnd = new TermRangeQuery(
"enddate",
DateTools.DateToString(c.EndDate.Value, DateTools.Resolution.SECOND),
null,
true,
false);
query.Add(datesFilterEnd, Occur.MUST);
}
if (c.Outlines != null && c.Outlines.Count > 0)
{
AddQuery("__outline", query, c.Outlines);
}
query.Add(new TermQuery(new Term("__hidden", "false")), Occur.MUST);
if (!String.IsNullOrEmpty(c.Catalog))
{
AddQuery("catalog", query, c.Catalog);
}
// Add search
if (!String.IsNullOrEmpty(c.SearchPhrase))
{
var searchPhrase = c.SearchPhrase;
if (c.IsFuzzySearch)
{
var keywords = c.SearchPhrase.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
searchPhrase = string.Empty;
searchPhrase = keywords.Aggregate(
searchPhrase,
(current, keyword) =>
current + String.Format("{0}~{1}", keyword.Replace("~", ""), c.FuzzyMinSimilarity.ToString(CultureInfo.InvariantCulture)));
}
var fields = new List<string> { "__content" };
if (c.Locale != null)
{
var contentField = string.Format("__content_{0}", c.Locale.ToLower());
fields.Add(contentField);
}
var parser = new MultiFieldQueryParser(u.Version.LUCENE_30, fields.ToArray(), analyzer)
{
DefaultOperator =
QueryParser
.Operator.OR
};
var searchQuery = parser.Parse(searchPhrase);
query.Add(searchQuery, Occur.MUST);
}
}
else if (criteria is OrderSearchCriteria)
{
var c = criteria as OrderSearchCriteria;
if (!String.IsNullOrEmpty(c.CustomerId))
{
AddQuery("customerid", query, c.CustomerId);
}
}
return builder;
}
