private static IList <int> SearchCore(SearchFilter searchFilter)
{
if (!Directory.Exists(LuceneCommon.IndexDirectory))
{
return(new int[0]);
}
SortField sortField = GetSortField(searchFilter);
int numRecords = Math.Min((1 + searchFilter.Skip) * searchFilter.Take, MaximumRecordsToReturn);
using (var directory = new LuceneFileSystem(LuceneCommon.IndexDirectory))
{
var searcher = new IndexSearcher(directory, readOnly: true);
var query = ParseQuery(searchFilter);
Filter filter = null;
if (!searchFilter.IncludePrerelease)
{
var isLatestStableQuery = new TermQuery(new Term("IsLatestStable", Boolean.TrueString));
filter = new QueryWrapperFilter(isLatestStableQuery);
}
var results = searcher.Search(query, filter: filter, n: numRecords, sort: new Sort(sortField));
var keys = results.scoreDocs.Skip(searchFilter.Skip)
.Select(c => ParseKey(searcher.Doc(c.doc).Get("Key")))
.ToList();
searcher.Close();
return(keys);
}
}
public void TestWithCachingFilter()
{
Directory dir = new RAMDirectory();
Analyzer analyzer = new WhitespaceAnalyzer();
IndexWriter writer = new IndexWriter(dir, analyzer, true, IndexWriter.MaxFieldLength.LIMITED);
writer.Close();
Searcher searcher = new IndexSearcher(dir, true);
Query query = new TermQuery(new Term("none", "none"));
QueryWrapperFilter queryFilter = new QueryWrapperFilter(query);
CachingWrapperFilter cachingFilter = new CachingWrapperFilter(queryFilter);
searcher.Search(query, cachingFilter, 1);
CachingWrapperFilter cachingFilter2 = new CachingWrapperFilter(queryFilter);
Filter[] chain = new Filter[2];
chain[0] = cachingFilter;
chain[1] = cachingFilter2;
ChainedFilter cf = new ChainedFilter(chain);
// throws java.lang.ClassCastException: org.apache.lucene.util.OpenBitSet cannot be cast to java.util.BitSet
searcher.Search(new MatchAllDocsQuery(), cf, 1);
}
/// <summary>
/// 构建Query、Filter、Sort
/// </summary>
/// <param name="query"><see cref="Query"/></param>
/// <param name="filter"><see cref="Filter"/></param>
/// <param name="sort"><see cref="Sort"/></param>
public void BuildQuery(out Query query, out Filter filter, out Sort sort)
{
BooleanQuery q = new BooleanQuery();
foreach (var clause in clauses)
{
q.Add(clause);
}
query = q;
if (filters.Count > 0)
{
BooleanQuery filterQuery = new BooleanQuery();
foreach (var _filter in filters)
{
filterQuery.Add(_filter);
}
filter = new QueryWrapperFilter(filterQuery);
}
else
{
filter = null;
}
if (sortFields.Count > 0)
{
sort = new Sort(sortFields.ToArray());
}
else
{
sort = null;
}
}
public static IEnumerable <SearchModel> Search(string keyWord)
{
var result = new List <SearchModel>();
var query = new PhraseQuery();
query.Add(new Term("value", keyWord));
query.Slop = MaxLength;
var sort = new Sort(new SortField("hot", SortField.INT, true));
var filter = new QueryWrapperFilter(query);
var docs = Searcher.Search(query, filter, 1000, sort).ScoreDocs;
foreach (var scoreDoc in docs)
{
var model = new SearchModel();
var document = Searcher.Doc(scoreDoc.Doc);
model.Key = document.Get("key");
model.Content = document.Get("content");
model.Value = document.Get("value");
int hot, size;
int.TryParse(document.Get("hot"), out hot);
int.TryParse(document.Get("size"), out size);
model.Hot = hot;
model.Size = size;
result.Add(model);
}
return(result);
}
/// <summary>
/// Processes the next tweet from the queue
/// </summary>
public void ProcessNextInQueue()
{
//read the tweets with a MinValue as their index date
TermQuery query = new TermQuery(new Term(Settings.FIELD_TWEET_DATE_INDEXED, "0"));
Filter filter = new QueryWrapperFilter(query);
TopDocs results = _tweetSearcher.Search(query, filter, 1);
//if no results, return
if (results.totalHits == 0)
{
return;
}
Document tweetDoc = _tweetSearcher.Doc(results.scoreDocs[0].doc);
//construct the tweet
Tweet tweetToProcess = GetTweetFromDocument(tweetDoc);
Console.WriteLine("Processing Tweet " + tweetToProcess.TweetId);
//get the indexes
var indexes = GetIndexesFromDocument(tweetDoc);
//index the urls from the tweet
_urlIndexer.IndexUrlsInTweet(tweetToProcess, indexes);
}
protected OpenBitSetDISI CalculateOpenBitSetDisi(string facetAttributeFieldName, string value)
{
var facetQuery = new TermQuery(new Term(facetAttributeFieldName, value));
var facetQueryFilter = new QueryWrapperFilter(facetQuery);
return(new OpenBitSetDISI(facetQueryFilter.GetDocIdSet(IndexReader).Iterator(), IndexReader.MaxDoc));
}
/// <summary>
/// Returns search query filter for lucene to lookup documents based on extension
/// </summary>
/// <param name="searchContext"></param>
/// <returns></returns>
private QueryWrapperFilter CreateLuceneSearchFilter(SearchContext searchContext)
{
QueryWrapperFilter filter = null;
if (searchContext == null || searchContext.SelectedSearchFilterData == null)
{
return(null);
}
var matchedExtFilter = searchContext.SelectedSearchFilterData.Name.ToLower() != "all";
if (matchedExtFilter)
{
filter = new QueryWrapperFilter(new TermQuery(new Term("ext", searchContext.SelectedSearchFilterData.Filter)));
return(filter);
}
var matchedAllFilter = searchContext.SelectedSearchFilterData.Name.ToLower() == "all";
if (matchedAllFilter)
{
//return a null filter to match all extensions
return(filter);
}
return(filter);
}
private static IList <int> SearchCore(SearchFilter searchFilter, out int totalHits)
{
if (!Directory.Exists(LuceneCommon.IndexDirectory))
{
totalHits = 0;
return(new int[0]);
}
SortField sortField = GetSortField(searchFilter);
int numRecords = searchFilter.Skip + searchFilter.Take;
using (var directory = new LuceneFileSystem(LuceneCommon.IndexDirectory))
{
var searcher = new IndexSearcher(directory, readOnly: true);
var query = ParseQuery(searchFilter);
var filterTerm = searchFilter.IncludePrerelease ? "IsLatest" : "IsLatestStable";
var termQuery = new TermQuery(new Term(filterTerm, Boolean.TrueString));
Filter filter = new QueryWrapperFilter(termQuery);
var results = searcher.Search(query, filter: filter, n: numRecords, sort: new Sort(sortField));
var keys = results.scoreDocs.Skip(searchFilter.Skip)
.Select(c => ParseKey(searcher.Doc(c.doc).Get("Key")))
.ToList();
totalHits = results.totalHits;
searcher.Close();
return(keys);
}
}
public virtual void TestWithCachingFilter()
{
Directory dir = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
Random, dir);
IndexReader reader = writer.GetReader();
writer.Dispose();
IndexSearcher searcher = NewSearcher(reader);
Query query = new TermQuery(new Term("none", "none"));
QueryWrapperFilter queryFilter = new QueryWrapperFilter(query);
CachingWrapperFilter cachingFilter = new CachingWrapperFilter(queryFilter);
searcher.Search(query, cachingFilter, 1);
CachingWrapperFilter cachingFilter2 = new CachingWrapperFilter(queryFilter);
Filter[] chain = new Filter[2];
chain[0] = cachingFilter;
chain[1] = cachingFilter2;
ChainedFilter cf = new ChainedFilter(chain);
// throws java.lang.ClassCastException: org.apache.lucene.util.OpenBitSet cannot be cast to java.util.BitSet
searcher.Search(new MatchAllDocsQuery(), cf, 1);
reader.Dispose();
dir.Dispose();
}
public virtual void TestWithCachingFilter()
{
Directory dir = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, Similarity, TimeZone);
IndexReader reader = writer.Reader;
writer.Dispose();
IndexSearcher searcher = NewSearcher(reader);
Query query = new TermQuery(new Term("none", "none"));
QueryWrapperFilter queryFilter = new QueryWrapperFilter(query);
CachingWrapperFilter cachingFilter = new CachingWrapperFilter(queryFilter);
searcher.Search(query, cachingFilter, 1);
CachingWrapperFilter cachingFilter2 = new CachingWrapperFilter(queryFilter);
Filter[] chain = new Filter[2];
chain[0] = cachingFilter;
chain[1] = cachingFilter2;
ChainedFilter cf = new ChainedFilter(chain);
// throws java.lang.ClassCastException: org.apache.lucene.util.OpenBitSet cannot be cast to java.util.BitSet
searcher.Search(new MatchAllDocsQuery(), cf, 1);
reader.Dispose();
dir.Dispose();
}
private TopDocs RunQuery(QueryWrapperFilter queryFilter, IndexSearcher indexSearcher, Query luceneQuery)
{
TopDocs hits = queryFilter != null
? indexSearcher.Search(luceneQuery, queryFilter, 1)
: (indexSearcher).Search(luceneQuery, 1);
return(hits);
}
public FilteredQuery CreateFilteredQuery(ILuceneQueryService builder, LuceneQueryContext context, string type, JToken filter, Query toFilter)
{
if (type != "fuzzy")
{
return(null);
}
if (!(toFilter is BooleanQuery booleanQuery))
{
return(null);
}
var queryObj = filter as JObject;
var first = queryObj.Properties().First();
FuzzyQuery fuzzyQuery;
switch (first.Value.Type)
{
case JTokenType.String:
fuzzyQuery = new FuzzyQuery(new Term(first.Name, first.Value.ToString()));
break;
case JTokenType.Object:
var obj = (JObject)first.Value;
if (!obj.TryGetValue("value", out var value))
{
throw new ArgumentException("Missing value in fuzzy query");
}
obj.TryGetValue("fuzziness", out var fuzziness);
obj.TryGetValue("prefix_length", out var prefixLength);
obj.TryGetValue("max_expansions", out var maxExpansions);
fuzzyQuery = new FuzzyQuery(
new Term(first.Name, value.Value <string>()),
fuzziness?.Value <int>() ?? LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE,
prefixLength?.Value <int>() ?? 0,
maxExpansions?.Value <int>() ?? 50,
true);
if (obj.TryGetValue("boost", out var boost))
{
fuzzyQuery.Boost = boost.Value <float>();
}
break;
default: throw new ArgumentException("Invalid fuzzy query");
}
booleanQuery.Add(fuzzyQuery, Occur.MUST);
var queryFilter = new QueryWrapperFilter(fuzzyQuery);
return(new FilteredQuery(booleanQuery, queryFilter));
}
private SearchResults SearchCore(SearchFilter searchFilter)
{
// Get index timestamp
DateTime timestamp = File.GetLastWriteTimeUtc(LuceneCommon.GetIndexMetadataPath());
int numRecords = searchFilter.Skip + searchFilter.Take;
var searcher = new IndexSearcher(_directory, readOnly: true);
var query = ParseQuery(searchFilter.SearchTerm);
// IF searching by relevance, boost scores by download count.
if (searchFilter.SortOrder == SortOrder.Relevance)
{
var downloadCountBooster = new FieldScoreQuery("DownloadCount", FieldScoreQuery.Type.INT);
query = new CustomScoreQuery(query, downloadCountBooster);
}
string filterTerm;
if (SemVerLevelKey.ForSemVerLevel(searchFilter.SemVerLevel) == SemVerLevelKey.SemVer2)
{
filterTerm = searchFilter.IncludePrerelease ? "IsLatestSemVer2" : "IsLatestStableSemVer2";
}
else
{
filterTerm = searchFilter.IncludePrerelease ? "IsLatest" : "IsLatestStable";
}
Query filterQuery = new TermQuery(new Term(filterTerm, Boolean.TrueString));
if (searchFilter.CuratedFeed != null)
{
var feedFilterQuery = new TermQuery(new Term("CuratedFeedKey", searchFilter.CuratedFeed.Key.ToString(CultureInfo.InvariantCulture)));
BooleanQuery conjunctionQuery = new BooleanQuery();
conjunctionQuery.Add(filterQuery, Occur.MUST);
conjunctionQuery.Add(feedFilterQuery, Occur.MUST);
filterQuery = conjunctionQuery;
}
Filter filter = new QueryWrapperFilter(filterQuery);
var results = searcher.Search(query, filter: filter, n: numRecords, sort: new Sort(GetSortField(searchFilter)));
if (results.TotalHits == 0 || searchFilter.CountOnly)
{
return(new SearchResults(results.TotalHits, timestamp));
}
var packages = results.ScoreDocs
.Skip(searchFilter.Skip)
.Select(sd => PackageFromDoc(searcher.Doc(sd.Doc)))
.ToList();
return(new SearchResults(
results.TotalHits,
timestamp,
packages.AsQueryable()));
}
public static Filter GetTypeFilter(string type)
{
var typeTermQuery = CreateTypeQuery(type);
BooleanQuery query = new BooleanQuery();
query.Add(typeTermQuery, Occur.MUST);
Filter filter = new QueryWrapperFilter(query);
return(filter);
}
public FilteredQuery CreateFilteredQuery(ILuceneQueryService builder, LuceneQueryContext context, string type, JToken filter, Query toFilter)
{
if (type != "prefix")
{
return(null);
}
if (!(toFilter is BooleanQuery booleanQuery))
{
return(null);
}
var queryObj = filter as JObject;
var first = queryObj.Properties().First();
// A prefix query has only one member, which can either be a string or an object
PrefixQuery prefixQuery;
switch (first.Value.Type)
{
case JTokenType.String:
prefixQuery = new PrefixQuery(new Term(first.Name, first.Value.ToString()));
break;
case JTokenType.Object:
var obj = (JObject)first.Value;
if (obj.TryGetValue("value", out var value))
{
prefixQuery = new PrefixQuery(new Term(first.Name, value.Value <string>()));
}
else if (obj.TryGetValue("prefix", out var prefix))
{
prefixQuery = new PrefixQuery(new Term(first.Name, prefix.Value <string>()));
}
else
{
throw new ArgumentException("Prefix query misses prefix value");
}
if (obj.TryGetValue("boost", out var boost))
{
prefixQuery.Boost = boost.Value <float>();
}
break;
default: throw new ArgumentException("Invalid prefix query");
}
booleanQuery.Add(prefixQuery, Occur.MUST);
var queryFilter = new QueryWrapperFilter(prefixQuery);
return(new FilteredQuery(booleanQuery, queryFilter));
}
public FilteredQuery CreateFilteredQuery(ILuceneQueryService builder, LuceneQueryContext context, string type, JToken filter, Query toFilter)
{
if (type != "match_phrase")
{
return(null);
}
if (!(toFilter is BooleanQuery booleanQuery))
{
return(null);
}
var queryObj = filter as JObject;
var first = queryObj.Properties().First();
var phraseQuery = new PhraseQuery();
JToken value;
switch (first.Value.Type)
{
case JTokenType.String:
value = first.Value;
break;
case JTokenType.Object:
var obj = (JObject)first.Value;
if (!obj.TryGetValue("value", out value))
{
throw new ArgumentException("Missing value in match phrase query");
}
// TODO: read "analyzer" property
if (obj.TryGetValue("slop", out var slop))
{
phraseQuery.Slop = slop.Value <int>();
}
break;
default: throw new ArgumentException("Invalid wildcard query");
}
foreach (var term in LuceneQueryService.Tokenize(first.Name, value.Value <string>(), context.DefaultAnalyzer))
{
phraseQuery.Add(new Term(first.Name, term));
}
booleanQuery.Add(phraseQuery, Occur.MUST);
var queryFilter = new QueryWrapperFilter(phraseQuery);
return(new FilteredQuery(booleanQuery, queryFilter));
}
/// <inheritdoc />
public ISearchBit GetBits()
{
var query = CreateQuery();
var filter = new QueryWrapperFilter(query);
var indexSearcher = _indexSearcherFactory();
var context = (AtomicReaderContext)indexSearcher.IndexReader.Context;
var bits = filter.GetDocIdSet(context, context.AtomicReader.LiveDocs);
var documentSetIDInterator = new OpenBitSetDISI(bits.GetIterator(), indexSearcher.IndexReader.MaxDoc);
return(new SearchBit(documentSetIDInterator));
}
public static Filter GetTypeFilter(string type, Query filter)
{
var typeTermQuery = new TermQuery(new Term(FieldType, type));
BooleanQuery query = new BooleanQuery();
query.Add(typeTermQuery, Occur.MUST);
query.Add(filter, Occur.MUST);
Filter resultFilter = new QueryWrapperFilter(query);
return(resultFilter);
}
public IList <SearchResult> Search(string query, params string[] scopes)
{
using (IndexSearcher indexSearcher = new IndexSearcher(LuceneDirectory))
{
QueryParser queryParser = new QueryParser(Version.LUCENE_30, "data", Analyzer);
Query luceneQuery = queryParser.Parse(query);
QueryWrapperFilter queryFilter = BuildQueryFilter(scopes);
TopDocs hits = RunQuery(queryFilter, indexSearcher, luceneQuery);
return(ExtractSearchResults(hits, indexSearcher));
}
}
private SearchResults SearchCore(SearchFilter searchFilter)
{
// Get index timestamp
DateTime timestamp = File.GetLastWriteTimeUtc(LuceneCommon.IndexMetadataPath);
int numRecords = searchFilter.Skip + searchFilter.Take;
// we want all results the first time through
if (searchFilter.TakeAllResults)
{
numRecords = Int32.MaxValue;
}
var searcher = new IndexSearcher(_directory, readOnly: true);
var query = ParseQuery(searchFilter);
//// If searching by relevance, boost scores by download count.
//if (searchFilter.SortProperty == SortProperty.Relevance)
//{
// var downloadCountBooster = new FieldScoreQuery("DownloadCount", FieldScoreQuery.Type.INT);
// query = new CustomScoreQuery(query, downloadCountBooster);
//}
var filterTerm = searchFilter.IncludePrerelease ? "IsLatest" : "IsLatestStable";
Query filterQuery = new TermQuery(new Term(filterTerm, Boolean.TrueString));
Filter filter = new QueryWrapperFilter(filterQuery);
if (searchFilter.IncludeAllVersions)
{
filter = searchFilter.IncludePrerelease ?
new QueryWrapperFilter(new TermQuery(new Term("InIndex", Boolean.TrueString)))
: new QueryWrapperFilter(new TermQuery(new Term("IsPrerelease", Boolean.FalseString)));
}
var results = searcher.Search(query, filter: filter, n: numRecords, sort: new Sort(GetSortField(searchFilter)));
if (results.TotalHits == 0 || searchFilter.CountOnly)
{
return(new SearchResults(results.TotalHits, timestamp));
}
var packages = results.ScoreDocs
.Skip(searchFilter.Skip)
.Select(sd => PackageFromDoc(searcher.Doc(sd.Doc)))
.ToList();
return(new SearchResults(
results.TotalHits,
timestamp,
packages.AsQueryable()));
}
public virtual Filter GetFilter(XmlElement e)
{
UninterruptableMonitor.Enter(this);
try
{
XmlElement childElement = DOMUtils.GetFirstChildOrFail(e);
if (filterCache is null)
{
filterCache = new LurchTable <object, Filter>(LurchTableOrder.Access, cacheSize);
}
// Test to see if child Element is a query or filter that needs to be
// cached
IQueryBuilder qb = queryFactory.GetQueryBuilder(childElement.Name);
object cacheKey = null;
Query q = null;
Filter f = null;
if (qb != null)
{
q = qb.GetQuery(childElement);
cacheKey = q;
}
else
{
f = filterFactory.GetFilter(childElement);
cacheKey = f;
}
if (filterCache.TryGetValue(cacheKey, out Filter cachedFilter) && cachedFilter != null)
{
return(cachedFilter); // cache hit
}
//cache miss
if (qb != null)
{
cachedFilter = new QueryWrapperFilter(q);
}
else
{
cachedFilter = new CachingWrapperFilter(f);
}
filterCache[cacheKey] = cachedFilter;
return(cachedFilter);
}
finally
{
UninterruptableMonitor.Exit(this);
}
}
public virtual IEnumerable <TModel> List()
{
var query = new MatchAllDocsQuery();
using (var searcher = new IndexSearcher(Directory, true))
{
var filter = new QueryWrapperFilter(query);
var hits = searcher.Search(query, filter, int.MaxValue).ScoreDocs;
Logger.LogDebug($"Listing Lucene index returned {hits.Length} documents");
return(hits.Select(h => _documentToModelMapper.Map(searcher.Doc(h.Doc))).ToList());
}
}
private Query CreateQuery()
{
CreatePendingClause();
var booleanQuery = new BooleanQuery();
Query resultQuery = booleanQuery;
if (_clauses.Count == 0)
{
if (_filters.Count > 0)
{
// only filters applieds => transform to a boolean query
foreach (var clause in _filters)
{
booleanQuery.Add(clause);
}
resultQuery = booleanQuery;
}
else
{
// search all documents, without filter or clause
resultQuery = new MatchAllDocsQuery(null);
}
}
else
{
foreach (var clause in _clauses)
{
booleanQuery.Add(clause);
}
if (_filters.Count > 0)
{
var filter = new BooleanQuery();
foreach (var clause in _filters)
{
filter.Add(clause);
}
var queryFilter = new QueryWrapperFilter(filter);
resultQuery = new FilteredQuery(booleanQuery, queryFilter);
}
}
Logger.Debug("New search query: {0}", resultQuery.ToString());
return(resultQuery);
}
private Filter MakeSearchFilter(Dictionary <string, string> filter)
{
Filter luceneFilter = null;
if (filter != null && filter.Keys.Any())
{
var booleanQuery = new BooleanQuery();
foreach (KeyValuePair <string, string> keyValuePair in filter)
{
var termQuery = new TermQuery(new Term(keyValuePair.Key, keyValuePair.Value));
booleanQuery.Add(termQuery, Occur.MUST);
}
luceneFilter = new QueryWrapperFilter(booleanQuery);
}
return(luceneFilter);
}
private static Filter GetTypeTenantFilter(string type, string tenant)
{
var query = new BooleanQuery();
var typeTermQuery = new TermQuery(new Term(ItemTypeField, type));
query.Add(typeTermQuery, Occur.MUST);
var tenantTermQuery = new TermQuery(new Term(TenantField, tenant));
query.Add(tenantTermQuery, Occur.MUST);
Filter filter = new QueryWrapperFilter(query);
return(filter);
}
public override void SetUp()
{
base.SetUp();
directory = NewDirectory();
RandomIndexWriter writer = new RandomIndexWriter(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this,
#endif
Random, directory);
// we use the default Locale/TZ since LuceneTestCase randomizes it
var cal = new GregorianCalendar().ToDateTime(2003, 1, 1, 0, 0, 0, 0); // 2003 January 01
cal = TimeZoneInfo.ConvertTime(cal, TimeZoneInfo.Local);
for (int i = 0; i < Max; i++)
{
Document doc = new Document();
doc.Add(NewStringField("key", "" + (i + 1), Field.Store.YES));
doc.Add(NewStringField("owner", (i < Max / 2) ? "bob" : "sue", Field.Store.YES));
doc.Add(NewStringField("date", cal.ToString(CultureInfo.InvariantCulture), Field.Store.YES));
writer.AddDocument(doc);
cal = cal.AddDays(1);
}
reader = writer.GetReader();
writer.Dispose();
searcher = NewSearcher(reader);
// query for everything to make life easier
BooleanQuery bq = new BooleanQuery();
bq.Add(new TermQuery(new Term("owner", "bob")), Occur.SHOULD);
bq.Add(new TermQuery(new Term("owner", "sue")), Occur.SHOULD);
query = bq;
// date filter matches everything too
//Date pastTheEnd = parseDate("2099 Jan 1");
// dateFilter = DateFilter.Before("date", pastTheEnd);
// just treat dates as strings and select the whole range for now...
dateFilter = TermRangeFilter.NewStringRange("date", "", "ZZZZ", true, true);
bobFilter = new QueryWrapperFilter(
new TermQuery(new Term("owner", "bob")));
sueFilter = new QueryWrapperFilter(
new TermQuery(new Term("owner", "sue")));
}
public virtual IEnumerable <TModel> Search(TQueryParameters queryParameters)
{
var searchCriteria = _searchCriteriaBuilder.Build(queryParameters);
using (var searcher = new IndexSearcher(Directory, true))
{
var filter = new QueryWrapperFilter(searchCriteria.Query);
var hits = searchCriteria.Sort == null
? searcher.Search(searchCriteria.Query, filter, int.MaxValue).ScoreDocs
: searcher.Search(searchCriteria.Query, filter, int.MaxValue, searchCriteria.Sort).ScoreDocs;
Logger.LogDebug($"Searching Lucene index with query: {searchCriteria.Query} and sort: {searchCriteria.Sort} returned {hits.Length} documents");
return(hits.Select(h => _documentToModelMapper.Map(searcher.Doc(h.Doc))).ToList());
}
}
public FilteredQuery CreateFilteredQuery(ILuceneQueryService builder, LuceneQueryContext context, string type, JToken filter, Query toFilter)
{
if (type != "terms")
{
return(null);
}
if (!(toFilter is BooleanQuery booleanQuery))
{
return(null);
}
var queryObj = filter as JObject;
var first = queryObj.Properties().First();
var field = first.Name;
var boolQuery = new BooleanQuery();
switch (first.Value.Type)
{
case JTokenType.Array:
foreach (var item in ((JArray)first.Value))
{
if (item.Type != JTokenType.String)
{
throw new ArgumentException($"Invalid term in terms query");
}
boolQuery.Add(new TermQuery(new Term(field, item.Value <string>())), Occur.SHOULD);
}
break;
case JTokenType.Object:
throw new ArgumentException("The terms lookup query is not supported");
default: throw new ArgumentException("Invalid terms query");
}
booleanQuery.Add(boolQuery, Occur.MUST);
var queryFilter = new QueryWrapperFilter(boolQuery);
return(new FilteredQuery(booleanQuery, queryFilter));
}
public Task <IEnumerable <SearchResultItem> > SearchAsync(string searchText, int projectId)
{
return(Task.Run(() =>
{
//new searcher each time,
// because they don't see commits from any writer after being opened.
// even in huge deployments though, TD's number of concurrent searches
// would be tiny... not worth coding a mechanism to detect updates and
// reuse a searcher until the index is updated. In actuality, index
// updates would certainly be more frequent than index searches.
var searcher = new IndexSearcher(TdIndexDirectory, true);
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);
if (projectId != default(int))
{
var filterQuery = new BooleanQuery();
filterQuery.Add(new TermQuery(new Term("projectid", projectId.ToString())), Occur.MUST);
var filter = new QueryWrapperFilter(filterQuery);
searcher.Search(query, filter, collector);
}
else
{
searcher.Search(query, collector);
}
return collector.TopDocs().ScoreDocs.Select(d =>
{
var document = searcher.Doc(d.Doc);
return new SearchResultItem
{
Id = int.Parse(document.Get("id")),
SearchScore = d.Score
};
});
}));
}
public Tuple <long, List <ProductFTS> > Search(string searchTerm, int top = TOP_LIMIT, string category = null)
{
long totalHits = 0;
var prodList = new List <ProductFTS>();
try
{
TopDocs topDocs = null;
var queryParser = new MultiFieldQueryParser(Version, Fields, analyzer);
var query = new BooleanQuery();
//--- For exact match use the queryParser.Parse(searchTerm)
query.Add(queryParser.Parse(searchTerm), Occur.MUST);
//--- Split the search term into multiple search words to make fuzzy query ...
string[] terms = searchTerm.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
foreach (string term in terms)
{
query.Add(queryParser.Parse(term.Replace("~", "") + "~"), Occur.MUST);// remove the duplicate ~, if already exists
}
//--- Get the new instance of IndexSearcher, to make sure that query is being performed on the updated index
var searcher = GetIndexSearcher();
if (!string.IsNullOrEmpty(category))
{
var filter = new QueryWrapperFilter(new TermQuery(new Term(CATEGORY_FIELD, category)));
topDocs = searcher.Search(query, filter, top, Sort.RELEVANCE);
}
else
{
topDocs = searcher.Search(query, top, sort: Sort.RELEVANCE);
}
totalHits = topDocs.TotalHits;
prodList = GetSearchedDocs(searcher, topDocs);
}
catch (Exception exc)
{
throw exc;
}
return(new Tuple <long, List <ProductFTS> >(totalHits, prodList));
}
