public List<FacetReturn> Filter(Query query, List<SearchStringModel> searchQuery, string locationFilter, BitArray baseQuery) { var refinement = new SafeDictionary<string> { { "is facet", "1" } }; int hitsCount; var facetFields = Context.ContentDatabase.GetItem(ItemIDs.TemplateRoot) .Search(refinement, out hitsCount, location: ItemIDs.TemplateRoot.ToString(), numberOfItemsToReturn: 2000, pageNumber: 1) .ToList() .Select((item, sitecoreItem) => new { FieldId = item.ItemId, Facet = new Facet(item.Name) }) .ToList(); facetFields.Sort((f1, f2) => System.String.Compare(f1.Facet.FieldName, f2.Facet.FieldName, System.StringComparison.Ordinal)); var returnFacets = (from facetField in facetFields from facet in facetField.Facet.GetValues(query, locationFilter, baseQuery).Select(facet => new FacetReturn { KeyName = facet.Key, Value = facet.Value.ToString(), Type = facetField.Facet.FieldName.ToLower(), ID = facetField.FieldId + "|" + facet.Key }) select facet).ToList(); return returnFacets.ToList(); }
public virtual SortCollector GetSortCollector( SortField[] sort, Lucene.Net.Search.Query q, int offset, int count, bool fetchStoredFields, IEnumerable <string> termVectorsToFetch, bool forceScoring, string[] groupBy, int maxPerGroup, bool collectDocIdCache) { return(SortCollector.BuildSortCollector( this, q, sort, offset, count, forceScoring, fetchStoredFields, termVectorsToFetch, groupBy, maxPerGroup, collectDocIdCache)); }
public static void CheckHits_(Query query, System.String defaultFieldName, Searcher searcher, int[] results, TestCase testCase) { Hits hits = searcher.Search(query); System.Collections.Hashtable correct = new System.Collections.Hashtable(); for (int i = 0; i < results.Length; i++) { correct.Add((System.Int32) results[i], null); } System.Collections.Hashtable actual = new System.Collections.Hashtable(); for (int i = 0; i < hits.Length(); i++) { actual.Add((System.Int32) hits.Id(i), null); } //Assert.AreEqual(correct, actual, query.ToString(defaultFieldName)); if (correct.Count != 0) { System.Collections.IDictionaryEnumerator iter = correct.GetEnumerator(); bool status = false; while (iter.MoveNext()) { status = actual.ContainsKey(iter.Key); if (status == false) break; } Assert.IsTrue(status, query.ToString(defaultFieldName)); } }
private static void Visit(Query query, AzureQueryLogger.IndentedTextWriter writer) { writer.WriteLine("Query Type: {0}", (object)query.GetType().FullName); ++writer.Indent; writer.WriteLine("Boost: {0}", (object)query.Boost); if (query is BooleanQuery) AzureQueryLogger.VisitQuery((BooleanQuery)query, writer); if (query is TermQuery) AzureQueryLogger.VisitQuery((TermQuery)query, writer); if (query is PhraseQuery) AzureQueryLogger.VisitQuery((PhraseQuery)query, writer); if (query is MultiTermQuery) AzureQueryLogger.VisitQuery((MultiTermQuery)query, writer); if (query is MultiPhraseQuery) AzureQueryLogger.VisitQuery((MultiPhraseQuery)query, writer); if (query is MatchAllDocsQuery) AzureQueryLogger.VisitQuery((MatchAllDocsQuery)query, writer); if (query is FieldScoreQuery) AzureQueryLogger.VisitQuery((FieldScoreQuery)query, writer); if (query is ValueSourceQuery) AzureQueryLogger.VisitQuery((ValueSourceQuery)query, writer); if (query is CustomScoreQuery) AzureQueryLogger.VisitQuery((CustomScoreQuery)query, writer); if (query is FilteredQuery) AzureQueryLogger.VisitQuery((FilteredQuery)query, writer); if (query is DisjunctionMaxQuery) AzureQueryLogger.VisitQuery((DisjunctionMaxQuery)query, writer); if (query is ConstantScoreQuery) AzureQueryLogger.VisitQuery((ConstantScoreQuery)query, writer); if (query is SpanQuery) AzureQueryLogger.VisitQuery((SpanQuery)query, writer); --writer.Indent; }
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary <string, IFilter> enabledFilters) { System.Type type = GetCriteriaClass(criteria); ISearchFactoryImplementor searchFactory = ContextHelper.GetSearchFactory(GetSession(criteria)); Iesi.Collections.Generic.ISet <System.Type> types; IndexSearcher searcher = FullTextSearchHelper.BuildSearcher(searchFactory, out types, type); if (searcher == null) { throw new SearchException("Could not find a searcher for class: " + type.FullName); } Lucene.Net.Search.Query query = FullTextSearchHelper.FilterQueryByClasses(types, luceneQuery); Hits hits = searcher.Search(query); List <object> ids = new List <object>(); for (int i = 0; i < hits.Length(); i++) { object id = DocumentBuilder.GetDocumentId(searchFactory, type, hits.Doc(i)); ids.Add(id); } base.Values = ids.ToArray(); return(base.ToSqlString(criteria, criteriaQuery, enabledFilters)); }
public TopDocs SearchForQuery(string querytext, out Lucene.Net.Search.Query query, bool toProcess, bool toExpand) // Searches index with query text { Stopwatch stopwatch2 = Stopwatch.StartNew(); if (!toProcess) { querytext = "\"" + querytext + "\""; } else { if (toExpand) { var standardParser = new QueryParser(VERSION, URL_FN, new StandardAnalyzer(VERSION)); querytext = standardParser.Parse(querytext).ToString().Replace("Url:", "").Replace("Query:", ""); querytext = GetSynonyms(querytext); } querytext = querytext.ToLower(); } if (querytext != string.Empty) { query = parser.Parse(querytext); currentQuery = query; stopwatch2.Stop(); queryTime = stopwatch2.Elapsed.TotalSeconds.ToString(); finalQuery = query.ToString(); TopDocs results = searcher.Search(query, 100); return(results); } else { query = null; return(null); } }
private static Query HandleMethods(Query query) { var termQuery = query as TermQuery; if (termQuery != null && termQuery.Term.Field.StartsWith("@")) { return HandleMethodsForQueryAndTerm(query, termQuery.Term); } var wildcardQuery = query as WildcardQuery; if (wildcardQuery != null) { return HandleMethodsForQueryAndTerm(query, wildcardQuery.Term); } var booleanQuery = query as BooleanQuery; if (booleanQuery != null) { foreach (var c in booleanQuery.Clauses) { c.Query = HandleMethods(c.Query); } var requiresMerging = booleanQuery.Clauses.All(x => x.Query is IRavenLuceneMethodQuery); if (requiresMerging == false) return booleanQuery; if (booleanQuery.Clauses.Count == 0) return booleanQuery; var first = (IRavenLuceneMethodQuery)booleanQuery.Clauses[0].Query; var ravenLuceneMethodQuery = booleanQuery.Clauses.Skip(1).Aggregate(first, (methodQuery, clause) => methodQuery.Merge(clause.Query)); return (Query)ravenLuceneMethodQuery; } return query; }
private void LogResult(System.String msg, IndexSearcher s, Query q, int doc, float score1) { QueryUtils.Check(q, s); Log(msg + " " + score1); Log("Explain by: " + q); Log(s.Explain(q, doc)); }
/// <summary> /// Gets results that match the given query with a limit applied /// </summary> /// <param name="text">Search Query</param> /// <param name="limit">Result Limit</param> /// <returns></returns> public virtual IEnumerable <IFullTextSearchResult> Match(string text, int limit) { LucSearch.Query q = this._parser.Parse(text); LucSearch.TopDocs docs = this._searcher.Search(q, limit); return(from doc in docs.scoreDocs select this._searcher.Doc(doc.doc).ToResult(doc.score, this._schema)); }
/// <summary> /// Create a ToChildBlockJoinQuery. /// </summary> /// <param name="parentQuery">Query that matches parent documents</param> /// <param name="parentsFilter">Filter (must produce FixedBitSet per-segment, like <see cref="FixedBitSetCachingWrapperFilter"/>) /// identifying the parent documents.</param> /// <param name="doScores">True if parent scores should be calculated.</param> public ToChildBlockJoinQuery(Query parentQuery, Filter parentsFilter, bool doScores) { _origParentQuery = parentQuery; _parentQuery = parentQuery; _parentsFilter = parentsFilter; _doScores = doScores; }
internal SearchResults(Query query, IEnumerable<SortField> sortField, Searcher searcher, int maxResults) { LuceneQuery = query; LuceneSearcher = searcher; DoSearch(query, sortField, maxResults); }
private IList<SearchResult> RunQuery(Query query) { // If two threads ran this method simultaneously, there would be issues with this.IndexReader. // Alternatively, there could be one RAMDirectory per filesystem directory. lock (this) { IndexReader newReader = this.indexReader.Reopen(); if (newReader != this.indexReader) { this.indexReader.Dispose(); this.indexReader = newReader; } IndexSearcher searcher; searcher = new IndexSearcher(newReader); if (query == null) { return new List<SearchResult>(); } TopDocs hits = searcher.Search(query, 1000); return hits.ScoreDocs .Select(scoreDoc => searcher.Doc(scoreDoc.Doc).Get(FullTextFieldType.Path.ToString())) .Select(path => new SearchResult(path)) .ToList(); } }
public List<FacetReturn> Filter(Query query, List<SearchStringModel> searchQuery, string locationFilter, BitArray baseQuery) { var buckets = new List<SitecoreItem>(); using (var searcher = new IndexSearcher(Constants.Index.Name)) { if (locationFilter.IsNotEmpty()) { buckets.AddRange( searcher.GetItemsViaFieldQuery("isbucket", "1", 200).Value.Where(item => item.GetItem().IsNotNull()).Where( itm => Context.ContentDatabase.GetItem(locationFilter).Axes.IsAncestorOf(itm.GetItem()))); } } var bucketsSelectToList = buckets.OrderBy(i => i.GetItem().Name).Select(item => item.GetItem().ID.ToString()).ToList(); var returnFacets = this.GetSearch(query, bucketsSelectToList, searchQuery, locationFilter, baseQuery).Select( facet => new FacetReturn { KeyName = Context.ContentDatabase.GetItem(facet.Key).Name, Value = facet.Value.ToString(), Type = "location", ID = facet.Key }); return returnFacets.ToList(); }
public override void SetUp() { base.SetUp(); INDEX_SIZE = AtLeast(2000); Index = NewDirectory(); RandomIndexWriter writer = new RandomIndexWriter(Random(), Index); RandomGen random = new RandomGen(this, Random()); for (int i = 0; i < INDEX_SIZE; ++i) // don't decrease; if to low the { // problem doesn't show up Document doc = new Document(); if ((i % 5) != 0) // some documents must not have an entry in the first { // sort field doc.Add(NewStringField("publicationDate_", random.LuceneDate, Field.Store.YES)); } if ((i % 7) == 0) // some documents to match the query (see below) { doc.Add(NewTextField("content", "test", Field.Store.YES)); } // every document has a defined 'mandant' field doc.Add(NewStringField("mandant", Convert.ToString(i % 3), Field.Store.YES)); writer.AddDocument(doc); } Reader = writer.Reader; writer.Dispose(); Query = new TermQuery(new Term("content", "test")); }
/// <summary> /// Initializes a new instance of the <see cref="SearchResults" /> class. /// </summary> /// <param name="searcher">The searcher.</param> /// <param name="reader">The reader.</param> /// <param name="docs">The hits.</param> /// <param name="criteria">The criteria.</param> /// <param name="query">The query.</param> public LuceneSearchResults(Searcher searcher, IndexReader reader, TopDocs docs, ISearchCriteria criteria, Query query) { Results = new SearchResults(criteria, null); CreateDocuments(searcher, docs); CreateFacets(reader, query); CreateSuggestions(reader, criteria); }
private ExplanationResult GetQueryExplanations(ExplanationOptions options, Query luceneQuery, IndexSearcher searcher, ScoreDoc scoreDoc, Document document, global::Lucene.Net.Documents.Document luceneDocument) { string key; var hasGroupKey = options != null && string.IsNullOrWhiteSpace(options.GroupKey) == false; if (_indexType.IsMapReduce()) { if (hasGroupKey) { key = luceneDocument.Get(options.GroupKey, _state); if (key == null && document.Data.TryGet(options.GroupKey, out object value)) { key = value?.ToString(); } } else { key = luceneDocument.Get(Constants.Documents.Indexing.Fields.ReduceKeyHashFieldName, _state); } } else { key = hasGroupKey ? luceneDocument.Get(options.GroupKey, _state) : document.Id; } return(new ExplanationResult { Key = key, Explanation = searcher.Explain(luceneQuery, scoreDoc.Doc, _state) }); }
private bool IsNoQueryNoFilter(BrowseRequest req) { Lucene.Net.Search.Query q = req.Query; Filter filter = req.Filter; return((q == null || q is MatchAllDocsQuery) && filter == null && !_reader.HasDeletions); }
protected virtual Lucene.Net.Search.Query VisitWithinRadius(WithinRadiusNode node, LuceneQueryMapperState mappingState) { SpatialContext ctx = SpatialContext.GEO; var strategy = new PointVectorStrategy(ctx, Sitecore.ContentSearch.Spatial.Common.Constants.LocationFieldName); if (node.Latitude is double && node.Longitude is double && node.Radius is double) { var distance = DistanceUtils.Dist2Degrees((double)node.Radius, DistanceUtils.EARTH_MEAN_RADIUS_MI); Circle circle = ctx.MakeCircle((double)node.Longitude, (double)node.Latitude, distance); var spatialArgs = new SpatialArgs(SpatialOperation.IsWithin, circle); var dq = strategy.MakeQuery(spatialArgs); DistanceReverseValueSource valueSource = new DistanceReverseValueSource(strategy, circle.GetCenter(), distance); ValueSourceFilter vsf = new ValueSourceFilter(new QueryWrapperFilter(dq), valueSource, 0, distance); var filteredSpatial = new FilteredQuery(new MatchAllDocsQuery(), vsf); mappingState.FilterQuery = filteredSpatial; Lucene.Net.Search.Query spatialRankingQuery = new FunctionQuery(valueSource); Random r = new Random(DateTime.Now.Millisecond); var randomNumber = r.Next(10000101, 11000101); Lucene.Net.Search.Query dummyQuery = Lucene.Net.Search.NumericRangeQuery.NewIntRange("__smallcreateddate", randomNumber, Int32.Parse(DateTime.Now.ToString("yyyyMMdd")), true, true); BooleanQuery bq = new BooleanQuery(); bq.Add(filteredSpatial, Occur.MUST); bq.Add(spatialRankingQuery, Occur.MUST); bq.Add(dummyQuery, Occur.SHOULD); return(bq); } throw new NotSupportedException("Wrong parameters type, Radius, latitude and longitude must be of type double"); }
/// <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 IEnumerable <LuceneSearchEntry> ExecuteQuery(string indexFolder, LSearch.Query query) { var searchIndex = LStore.FSDirectory.Open(indexFolder); var searchManager = new LSearch.SearcherManager(searchIndex, null); // try to release locs searchManager.MaybeRefreshBlocking(); //execute search var searcher = searchManager.Acquire(); var rawResults = searcher.Search(query, 20); //convert raw results to model var outResults = new List <LuceneSearchEntry>(); for (var i = 0; i < rawResults.ScoreDocs.Length; i++) { var result = rawResults.ScoreDocs[i]; var doc = searcher.Doc(result.Doc); outResults.Add(new LuceneSearchEntry { Rank = i, Id = doc.Get("id"), Uri = doc.Get("uri"), Title = doc.Get("title"), Snippet = doc.Get("snippet"), Score = result.Score }); } return(outResults); }
protected internal override Query GetFieldQuery(string field, string queryText, int slop) { if (field == null) { IList <BooleanClause> clauses = new List <BooleanClause>(); for (int i = 0; i < fields.Length; i++) { Query q = base.GetFieldQuery(fields[i], queryText); if (q != null) { //If the user passes a map of boosts if (boosts != null) { //Get the boost from the map and apply them Single boost = boosts[fields[i]]; q.Boost = boost; } ApplySlop(q, slop); clauses.Add(new BooleanClause(q, Occur.SHOULD)); } } if (clauses.Count == 0) { // happens for stopwords return(null); } return(GetBooleanQuery(clauses, true)); } Query q2 = base.GetFieldQuery(field, queryText); ApplySlop(q2, slop); return(q2); }
public List<int> Get(Query searchQuery) { var indexSearcher = _productSearcher.IndexSearcher; var name = FieldDefinition.GetFieldName<ProductSearchCategoriesDefinition>(); var valueCollector = new ValueCollector(indexSearcher, name); indexSearcher.Search(searchQuery, valueCollector); var categoryIds = valueCollector.Values[name].Select(s => Convert.ToInt32(s)).Distinct().ToList(); if (!categoryIds.Any()) return categoryIds; var mainQuery = new BooleanQuery(); var idsQuery = new BooleanQuery(); const string idFieldName = "id"; foreach (var categoryId in categoryIds) { idsQuery.Add(new TermQuery(new Term(idFieldName, categoryId.ToString())), Occur.SHOULD); } mainQuery.Add(idsQuery, Occur.MUST); var publishedOn = FieldDefinition.GetFieldName<PublishedOnFieldDefinition>(); mainQuery.Add(new TermRangeQuery( publishedOn, null, DateTools.DateToString(CurrentRequestData.Now, DateTools.Resolution.SECOND), false, true), Occur.MUST); var webpageSearcher = _indexSearcher.IndexSearcher; var webpageValueCollector = new ValueCollector(webpageSearcher, idFieldName); webpageSearcher.Search(mainQuery, null, webpageValueCollector); return webpageValueCollector.Values[idFieldName].Select(s => Convert.ToInt32(s)) .Intersect(categoryIds) .ToList(); }
public virtual List<SkinnyItem> RunQuery(Query query, bool showAllVersions) { Assert.ArgumentNotNull(Index, "Aqueduct.SitecoreLib"); var items = new List<SkinnyItem>(); try { using (var context = new IndexSearchContext(Index)) { var hits = context.Search(query); if (hits == null) { return null; } var resultCollection = hits.FetchResults(0, hits.Length); SearchHelper.GetItemsFromSearchResult(resultCollection, items, showAllVersions); } } catch (Exception exception) { Log.Error("Aqueduct.SitecoreLib. There was a problem while running a search query. Details: " + exception.Message, this); Log.Error(exception.StackTrace, this); throw; } return items; }
private TopDocs ExecuteQuery(Query documentQuery, int start, int pageSize, Sort sort) { if (sort == null && _indexHasBoostedFields == false && IsBoostedQuery(documentQuery) == false) { if (pageSize == int.MaxValue || pageSize >= _searcher.MaxDoc) // we want all docs, no sorting required { var gatherAllCollector = new GatherAllCollector(Math.Min(pageSize, _searcher.MaxDoc)); _searcher.Search(documentQuery, gatherAllCollector, _state); return(gatherAllCollector.ToTopDocs()); } var noSortingCollector = new NonSortingCollector(Math.Abs(pageSize + start)); _searcher.Search(documentQuery, noSortingCollector, _state); return(noSortingCollector.ToTopDocs()); } var minPageSize = GetPageSize(_searcher, (long)pageSize + start); if (sort != null) { _searcher.SetDefaultFieldSortScoring(true, false); try { return(_searcher.Search(documentQuery, null, minPageSize, sort, _state)); } finally { _searcher.SetDefaultFieldSortScoring(false, false); } } return(_searcher.Search(documentQuery, null, minPageSize, _state)); }
public Task <SearchResult> Search(string searchQuery, int skip, int limit, string searchField = "") { if (_isRebuilding || string.IsNullOrWhiteSpace(searchQuery.Replace("*", string.Empty).Replace("?", string.Empty))) { return(new SearchResult(new List <SearchItem>(), 0).AsTask()); } using var dir = FSDirectory.Open(FileSystemLayout.SearchIndexFolder); using var reader = DirectoryReader.Open(dir); var searcher = new IndexSearcher(reader); int hitsLimit = skip + limit; using var analyzer = new StandardAnalyzer(AppLuceneVersion); QueryParser parser = !string.IsNullOrWhiteSpace(searchField) ? new QueryParser(AppLuceneVersion, searchField, analyzer) : new MultiFieldQueryParser(AppLuceneVersion, new[] { TitleField }, analyzer); parser.AllowLeadingWildcard = true; Query query = ParseQuery(searchQuery, parser); var filter = new DuplicateFilter(TitleAndYearField); var sort = new Sort(new SortField(SortTitleField, SortFieldType.STRING)); TopFieldDocs topDocs = searcher.Search(query, filter, hitsLimit, sort, true, true); IEnumerable <ScoreDoc> selectedHits = topDocs.ScoreDocs.Skip(skip).Take(limit); var searchResult = new SearchResult( selectedHits.Map(d => ProjectToSearchItem(searcher.Doc(d.Doc))).ToList(), topDocs.TotalHits); searchResult.PageMap = GetSearchPageMap(searcher, query, filter, sort, limit); return(searchResult.AsTask()); }
internal Hits(Searcher s, Query q, Filter f) { weight = q.Weight(s); searcher = s; filter = f; GetMoreDocs(50); // retrieve 100 initially }
/// <summary> /// /// </summary> /// <param name="field">The field that should contain terms that are specified in the previous parameter.</param> /// <param name="fromQuery"></param> /// <param name="terms">The terms that matching documents should have. The terms must be sorted by natural order.</param> internal TermsQuery(string field, Query fromQuery, BytesRefHash terms) : base(field) { _fromQuery = fromQuery; _terms = terms; _ords = terms.Sort(BytesRef.UTF8SortedAsUnicodeComparer); }
public static Query MakeQuery(Query existingQuery, SpatialStrategy spatialStrategy, string shapeWKT, SpatialRelation relation, double distanceErrorPct = 0.025) { SpatialOperation spatialOperation; var shape = ReadShape(shapeWKT); switch (relation) { case SpatialRelation.Within: spatialOperation = SpatialOperation.IsWithin; break; case SpatialRelation.Contains: spatialOperation = SpatialOperation.Contains; break; case SpatialRelation.Disjoint: spatialOperation = SpatialOperation.IsDisjointTo; break; case SpatialRelation.Intersects: spatialOperation = SpatialOperation.Intersects; break; case SpatialRelation.Nearby: // only sort by this, do not filter return new FunctionQuery(spatialStrategy.MakeDistanceValueSource(shape.GetCenter())); default: throw new ArgumentOutOfRangeException("relation"); } var args = new SpatialArgs(spatialOperation, shape) { DistErrPct = distanceErrorPct }; if(existingQuery is MatchAllDocsQuery) return new CustomScoreQuery(spatialStrategy.MakeQuery(args), new ValueSourceQuery(spatialStrategy.MakeRecipDistanceValueSource(shape))); return spatialStrategy.MakeQuery(args); }
private static void SearchByFld2(string fld, string txt) { string strIndexDir = @"D:\Index"; Analyzer std = new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_30); Lucene.Net.Store.Directory directory = Lucene.Net.Store.FSDirectory.Open(new System.IO.DirectoryInfo(strIndexDir)); Lucene.Net.Search.Searcher srchr = new Lucene.Net.Search.IndexSearcher(Lucene.Net.Index.IndexReader.Open(directory, true)); var parser = new Lucene.Net.QueryParsers.QueryParser(Lucene.Net.Util.Version.LUCENE_30, fld, std); Lucene.Net.Search.Query qry = parser.Parse(txt); var cllctr = srchr.Search(qry, 1000); Console.WriteLine(cllctr.TotalHits); ScoreDoc[] hits = cllctr.ScoreDocs; for (int i = 0; i < hits.Length; i++) { int docId = hits[i].Doc; float score = hits[i].Score; Lucene.Net.Documents.Document doc = srchr.Doc(docId); Console.WriteLine("索引时间:" + doc.Get("addtime")); Console.WriteLine("Searched from Text: " + doc.Get(fld)); } Console.WriteLine("over"); }
public SearchResult Search(Query searchQuery, int maxHits, string NameField = "Name", Sort sort = null) { SearchResult result = new SearchResult(); TopDocs hits = null; result.SearchResultItems = new List<SearchResultItem>(); if(sort != null) { hits = seacher.Search(searchQuery, null, maxHits, sort); } else { hits = seacher.Search(searchQuery, null, maxHits); } for (int i = 0; i < hits.ScoreDocs.Count(); i++) { Document doctemp = seacher.Doc(hits.ScoreDocs[i].Doc); result.SearchResultItems.Add(new SearchResultItem { Id = int.Parse(doctemp.Get("Id")), Name = doctemp.Get(NameField), Type = (DocumentType) Enum.Parse(typeof(DocumentType), doctemp.Get("Type")) }); } result.Hits = hits.ScoreDocs.Count(); return result; }
private readonly Query match; // query to match #endregion Fields #region Constructors public BoostingQuery(Query match, Query context, float boost) { this.match = match; this.context = (Query) context.Clone(); // clone before boost this.boost = boost; this.context.Boost = 0.0f; // ignore context-only matches }
public virtual Query Visit(Query q) { var booleanq = q as BooleanQuery; if (booleanq != null) return VisitBooleanQuery(booleanq); //var boostingq = q as BoostingQuery; if (boostingq != null) return VisitBoostingQuery(boostingq); var constantScoreq = q as ConstantScoreQuery; if (constantScoreq != null) return VisitConstantScoreQuery(constantScoreq); var constantScoreRangeq = q as ConstantScoreRangeQuery; if (constantScoreRangeq != null) return VisitConstantScoreRangeQuery(constantScoreRangeq); var customScoreq = q as CustomScoreQuery; if (customScoreq != null) return VisitCustomScoreQuery(customScoreq); var disjunctionMaxq = q as DisjunctionMaxQuery; if (disjunctionMaxq != null) return VisitDisjunctionMaxQuery(disjunctionMaxq); var filteredq = q as FilteredQuery; if (filteredq != null) return VisitFilteredQuery(filteredq); //var fuzzyLikeThisq = q as FuzzyLikeThisQuery; if (fuzzyLikeThisq != null) return VisitFuzzyLikeThisQuery(fuzzyLikeThisq); var matchAllDocsq = q as MatchAllDocsQuery; if (matchAllDocsq != null) return VisitMatchAllDocsQuery(matchAllDocsq); //var moreLikeThisq = q as MoreLikeThisQuery; if (moreLikeThisq != null) return VisitMoreLikeThisQuery(moreLikeThisq); var multiPhraseq = q as MultiPhraseQuery; if (multiPhraseq != null) return VisitMultiPhraseQuery(multiPhraseq); var fuzzyq = q as FuzzyQuery; if (fuzzyq != null) return VisitFuzzyQuery(fuzzyq); var wildcardq = q as WildcardQuery; if (wildcardq != null) return VisitWildcardQuery(wildcardq); var phraseq = q as PhraseQuery; if (phraseq != null) return VisitPhraseQuery(phraseq); var prefixq = q as PrefixQuery; if (prefixq != null) return VisitPrefixQuery(prefixq); var rangeq = q as RangeQuery; if (rangeq != null) return VisitRangeQuery(rangeq); var spanFirstq = q as SpanFirstQuery; if (spanFirstq != null) return VisitSpanFirstQuery(spanFirstq); var spanNearq = q as SpanNearQuery; if (spanNearq != null) return VisitSpanNearQuery(spanNearq); var spanNotq = q as SpanNotQuery; if (spanNotq != null) return VisitSpanNotQuery(spanNotq); var spanOrq = q as SpanOrQuery; if (spanOrq != null) return VisitSpanOrQuery(spanOrq); var spanTermq = q as SpanTermQuery; if (spanTermq != null) return VisitSpanTermQuery(spanTermq); var termq = q as TermQuery; if (termq != null) return VisitTermQuery(termq); var valueSourceq = q as ValueSourceQuery; if (valueSourceq != null) return VisitValueSourceQuery(valueSourceq); var fieldScoreq = q as FieldScoreQuery; if (fieldScoreq != null) return VisitFieldScoreQuery(fieldScoreq); // <V2.9.2> var termRangeq = q as TermRangeQuery; if (termRangeq != null) return VisitTermRangeQuery(termRangeq); var numericRangeq = q as NumericRangeQuery; if (numericRangeq != null) return VisitNumericRangeQuery(numericRangeq); // </V2.9.2> throw new NotImplementedException("Unknown query type: " + q.GetType().FullName); }
public Dictionary<string, int> GetSearch(Query query, List<string> filter, List<SearchStringModel> searchQuery, string locationFilter, BitArray baseQuery) { using (var searcher = new IndexSearcher(ItemBucket.Kernel.Util.Constants.Index.Name)) { var results = searcher.RunFacet(query, false, false, 0, 0, "size", filter, baseQuery, locationFilter); return results; } }
/// <summary> /// Initializes a new instance of the <see cref="LuceneSearcher"/> class. /// </summary> /// <param name="query">The query.</param> /// <param name="indexName">Name of the index.</param> public LuceneSearcher(Lucene.Net.Search.Query query, string indexName) { Assert.ArgumentNotNull(query, "query"); Assert.ArgumentNotNullOrEmpty(indexName, "indexName"); this.query = query; this.indexName = indexName; }
/// <summary> /// Constructs a filter which only matches documents matching /// <code>query</code>. /// </summary> public QueryWrapperFilter(Query query) { if (query == null) { throw new System.NullReferenceException("Query may not be null"); } this.Query_Renamed = query; }
private string GeneratePreviewText(Query q, string text) { var scorer = new QueryScorer(q); Highlighter highlighter = new Highlighter(htmlFormatter, scorer); highlighter.TextFragmenter = new SimpleFragmenter(250); TokenStream stream = SearchEnvironment.DefaultAnalyzer.TokenStream("html_content", new StringReader(text)); return highlighter.GetBestFragments(stream, text, 4, "<br/>"); }
internal DocSetIteratorWeight(Query query, Similarity similarity, DocIdSetIterator iter) { _query = query; _similarity = similarity; _iter = iter; _queryNorm = 1.0f; _queryWeight = _query.Boost; }
public string GetHighlight(string value, IndexSearcher searcher, string highlightField, Query luceneQuery) { var scorer = new QueryScorer(luceneQuery.Rewrite(searcher.GetIndexReader())); var highlighter = new Highlighter(HighlightFormatter, scorer); var tokenStream = HighlightAnalyzer.TokenStream(highlightField, new StringReader(value)); return highlighter.GetBestFragments(tokenStream, value, MaxNumHighlights, Separator); }
/// <summary> /// Given a Lucene Query, this will build the facets and append them to find the Bit comparison of two queries. /// </summary> /// <returns>List of FacetReturn</returns> /// <param name="query">The initial query</param> /// <param name="filter">The facet filter</param> /// <param name="searchQuery">The raw search query</param> /// <param name="locationFilter">The location used to determine which index to use</param> /// <param name="baseQuery">The initial queries bit array</param> public Dictionary<string, int> GetSearch(Query query, List<string> filter, List<SearchStringModel> searchQuery, string locationFilter, BitArray baseQuery) { using (var searcher = new IndexSearcher(Util.Constants.Index.Name)) { var results = searcher.RunFacet(query, false, true, 0, 0, "__smallCreatedDate", filter); return results; } }
/// <summary> /// Decorates the specified query adding context information. /// </summary> /// <param name="query">The source query.</param> /// <returns>The decorated query.</returns> public Lucene.Net.Search.Query Decorate(Lucene.Net.Search.Query query) { BooleanQuery result = new BooleanQuery(true); result.Add(query, Occur.MUST); this.AddDecorations(result); return(result); }
public void MakesQueriesWithProperPhrasing(string input, Query expected) { // arrange, act var actual = NuGetQuery.MakeQuery(input); // assert Assert.Equal(expected, actual); }
private ToChildBlockJoinQuery(Query origParentQuery, Query parentQuery, Filter parentsFilter, bool doScores) : base() { _origParentQuery = origParentQuery; _parentQuery = parentQuery; _parentsFilter = parentsFilter; _doScores = doScores; }
public void MakesQueriesSupportingSupportedFields(string input, Query expected) { // act var actual = NuGetQuery.MakeQuery(input); // assert Assert.Equal(expected, actual); }
public static Query MergeQueries(Query queryA, Query queryB, BooleanClause.Occur queryAOccurence, BooleanClause.Occur queryBOccurence) { BooleanQuery compoundQuery = new BooleanQuery(); compoundQuery.Add(new BooleanClause(queryA, queryAOccurence)); compoundQuery.Add(new BooleanClause(queryB, queryBOccurence)); return compoundQuery; }
public List <IndexPageResult> GetDocumentPagesWithQuery(string query) { List <IndexPageResult> results = new List <IndexPageResult>(); Dictionary <string, IndexPageResult> fingerprints_already_seen = new Dictionary <string, IndexPageResult>(); try { using (IndexReader index_reader = IndexReader.Open(LIBRARY_INDEX_BASE_PATH, true)) { using (IndexSearcher index_searcher = new IndexSearcher(index_reader)) { QueryParser query_parser = new QueryParser(Version.LUCENE_29, "content", analyzer); Lucene.Net.Search.Query query_object = query_parser.Parse(query); Lucene.Net.Search.Hits hits = index_searcher.Search(query_object); var i = hits.Iterator(); while (i.MoveNext()) { Lucene.Net.Search.Hit hit = (Lucene.Net.Search.Hit)i.Current; string fingerprint = hit.Get("fingerprint"); int page = Convert.ToInt32(hit.Get("page")); double score = hit.GetScore(); // If this is the first time we have seen this fingerprint, make the top-level record if (!fingerprints_already_seen.ContainsKey(fingerprint)) { IndexPageResult result = new IndexPageResult(); result.fingerprint = fingerprint; result.score = score; // Add to our structures results.Add(result); fingerprints_already_seen[fingerprint] = result; } // And add the page record { IndexPageResult result = fingerprints_already_seen[fingerprint]; result.page_results.Add(new PageResult { page = page, score = score }); } } // Close the index index_searcher.Close(); } index_reader.Close(); } } catch (Exception ex) { Logging.Warn(ex, $"GetDocumentPagesWithQuery: There was a problem opening the index file for searching (path: '{LIBRARY_INDEX_BASE_PATH}', query: '{query}')"); } return(results); }
/// <summary> /// classes must be immutable /// </summary> public FullTextQueryImpl(Lucene.Net.Search.Query query, System.Type[] classes, ISession session, ParameterMetadata parameterMetadata) : base(query.ToString(), FlushMode.Unspecified, session.GetSessionImplementation(), parameterMetadata) { luceneQuery = query; resultSize = -1; this.classes = classes; this.filterDefinitions = new Dictionary <string, FullTextFilterImpl>(); }
/// <summary> /// Gets results that match the given query /// </summary> /// <param name="text">Search Query</param> /// <returns></returns> public virtual IEnumerable <IFullTextSearchResult> Match(string text) { LucSearch.Query q = this._parser.Parse(text); DocCollector collector = new DocCollector(); this._searcher.Search(q, collector); return(from doc in collector.Documents select this._searcher.Doc(doc.Key).ToResult(doc.Value, this._schema)); }
// Test that FieldScoreQuery returns docs with expected score. private void DoTestCustomScore(System.String field, FieldScoreQuery.Type tp, double dboost) { float boost = (float)dboost; IndexSearcher s = new IndexSearcher(dir, true); FieldScoreQuery qValSrc = new FieldScoreQuery(field, tp); // a query that would score by the field QueryParser qp = new QueryParser(Util.Version.LUCENE_CURRENT, TEXT_FIELD, anlzr); System.String qtxt = "first aid text"; // from the doc texts in FunctionQuerySetup. // regular (boolean) query. Query q1 = qp.Parse(qtxt); Log(q1); // custom query, that should score the same as q1. CustomScoreQuery q2CustomNeutral = new CustomScoreQuery(q1); q2CustomNeutral.Boost = boost; Log(q2CustomNeutral); // custom query, that should (by default) multiply the scores of q1 by that of the field CustomScoreQuery q3CustomMul = new CustomScoreQuery(q1, qValSrc); q3CustomMul.SetStrict(true); q3CustomMul.Boost = boost; Log(q3CustomMul); // custom query, that should add the scores of q1 to that of the field CustomScoreQuery q4CustomAdd = new CustomAddQuery(q1, qValSrc); q4CustomAdd.SetStrict(true); q4CustomAdd.Boost = boost; Log(q4CustomAdd); // custom query, that multiplies and adds the field score to that of q1 CustomScoreQuery q5CustomMulAdd = new CustomMulAddQuery(q1, qValSrc, qValSrc); q5CustomMulAdd.SetStrict(true); q5CustomMulAdd.Boost = boost; Log(q5CustomMulAdd); // do al the searches TopDocs td1 = s.Search(q1, null, 1000); TopDocs td2CustomNeutral = s.Search(q2CustomNeutral, null, 1000); TopDocs td3CustomMul = s.Search(q3CustomMul, null, 1000); TopDocs td4CustomAdd = s.Search(q4CustomAdd, null, 1000); TopDocs td5CustomMulAdd = s.Search(q5CustomMulAdd, null, 1000); // put results in map so we can verify the scores although they have changed System.Collections.Hashtable h1 = TopDocsToMap(td1); System.Collections.Hashtable h2CustomNeutral = TopDocsToMap(td2CustomNeutral); System.Collections.Hashtable h3CustomMul = TopDocsToMap(td3CustomMul); System.Collections.Hashtable h4CustomAdd = TopDocsToMap(td4CustomAdd); System.Collections.Hashtable h5CustomMulAdd = TopDocsToMap(td5CustomMulAdd); VerifyResults(boost, s, h1, h2CustomNeutral, h3CustomMul, h4CustomAdd, h5CustomMulAdd, q1, q2CustomNeutral, q3CustomMul, q4CustomAdd, q5CustomMulAdd); }
public void Or(Query left, Query right) { if (_operator != OperatorType.Or) { ThrowInvalidOperator(OperatorType.Or); } AddInternal(left, Occur.SHOULD, OperatorType.Or); AddInternal(right, Occur.SHOULD, OperatorType.Or); }
/// <summary> /// Gets results that match the given query with the score threshold and limit applied /// </summary> /// <param name="text">Search Query</param> /// <param name="scoreThreshold">Score Threshold</param> /// <param name="limit">Result Limit</param> /// <returns></returns> public virtual IEnumerable <IFullTextSearchResult> Match(string text, double scoreThreshold, int limit) { this.EnsureCurrent(); LucSearch.Query q = this._parser.Parse(text); LucSearch.TopDocs docs = this._searcher.Search(q, limit); return(from doc in docs.ScoreDocs where doc.Score > scoreThreshold select this._searcher.Doc(doc.Doc).ToResult(doc.Score, this._schema)); }
public void And(Query left, Query right) { if (_operator != OperatorType.And) { ThrowInvalidOperator(OperatorType.And); } AddInternal(left, Occur.MUST, OperatorType.And); AddInternal(right, Occur.MUST, OperatorType.And); }
public bool TryOr(Query right) { if (_operator == OperatorType.Or) { AddInternal(right, Occur.SHOULD, OperatorType.Or); return(true); } return(false); }
public void And(Query left, Query right, List <string> buildSteps) { if (_operator != OperatorType.And) { ThrowInvalidOperator(OperatorType.And); } AddInternal(left, Occur.MUST, OperatorType.And, buildSteps); AddInternal(right, Occur.MUST, OperatorType.And, buildSteps); }
public bool TryAnd(Query right, List <string> buildSteps) { if (_operator == OperatorType.And) { AddInternal(right, Occur.MUST, OperatorType.And, buildSteps); return(true); } return(false); }
public bool TryOr(Query right, List <string> buildSteps) { if (_operator == OperatorType.Or) { AddInternal(right, Occur.SHOULD, OperatorType.Or, buildSteps); return(true); } return(false); }
public bool TryAnd(Query right) { if (_operator == OperatorType.And) { AddInternal(right, Occur.MUST, OperatorType.And); return(true); } return(false); }
public void Or(Query left, Query right, List <string> buildSteps) { if (_operator != OperatorType.Or) { ThrowInvalidOperator(OperatorType.Or); } AddInternal(left, Occur.SHOULD, OperatorType.Or, buildSteps); AddInternal(right, Occur.SHOULD, OperatorType.Or, buildSteps); }
public LuceneBitArray Or(LNS.Query query) { collector.Array = this; searcher.Search(query, null, collector); if (Debug) { Explain(query); } return(this); }
private void ApplySlop(Query q, int slop) { if (q is PhraseQuery) { ((PhraseQuery)q).Slop = slop; } else if (q is MultiPhraseQuery) { ((MultiPhraseQuery)q).Slop = slop; } }