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)); }