public virtual void TestBasic() { // create a sort field and sort by it (reverse order) Query query = new TermQuery(new Term("body", "contents")); IndexReader r = searcher.IndexReader; // Just first pass query TopDocs hits = searcher.Search(query, 10); Assert.AreEqual(3, hits.TotalHits); Assert.AreEqual("3", r.Document(hits.ScoreDocs[0].Doc).Get("id")); Assert.AreEqual("1", r.Document(hits.ScoreDocs[1].Doc).Get("id")); Assert.AreEqual("2", r.Document(hits.ScoreDocs[2].Doc).Get("id")); // Now, rescore: Sort sort = new Sort(new SortField("popularity", SortFieldType.INT32, true)); Rescorer rescorer = new SortRescorer(sort); hits = rescorer.Rescore(searcher, hits, 10); Assert.AreEqual(3, hits.TotalHits); Assert.AreEqual("2", r.Document(hits.ScoreDocs[0].Doc).Get("id")); Assert.AreEqual("1", r.Document(hits.ScoreDocs[1].Doc).Get("id")); Assert.AreEqual("3", r.Document(hits.ScoreDocs[2].Doc).Get("id")); string expl = rescorer.Explain(searcher, searcher.Explain(query, hits.ScoreDocs[0].Doc), hits.ScoreDocs[0].Doc).ToString(); // Confirm the explanation breaks out the individual // sort fields: Assert.IsTrue(expl.Contains("= sort field <int: \"popularity\">! value=20")); // Confirm the explanation includes first pass details: Assert.IsTrue(expl.Contains("= first pass score")); Assert.IsTrue(expl.Contains("body:contents in")); }
/// <summary> /// Performs the explanation. /// </summary> /// <param name="luceneVersion">The lucene version.</param> /// <param name="fsDirectory">The fs directory.</param> /// <param name="searchQuery">The search query.</param> /// <param name="resultId">The result identifier.</param> /// <returns></returns> protected virtual string PerformExplain(Version luceneVersion, FSDirectory fsDirectory, string searchQuery, int resultId) { /* * The obvious problem here is that we're not using the exact same search as the real one. */ var explanation = string.Empty; using (var indexSearcher = new IndexSearcher(fsDirectory, false)) { var analyzer = new StandardAnalyzer(luceneVersion); var queryParser = new MultiFieldQueryParser(luceneVersion, new[] { "Id".ToLowerInvariant() }, analyzer) { DefaultOperator = QueryParser.Operator.AND }; var query = this.searchQueryParser.ParseQuery(searchQuery, queryParser); explanation = indexSearcher.Explain(query, resultId).ToHtml(); analyzer.Close(); } return explanation; }
private IList <Document> GetSearchHits(Query q) { if (q == null) { return(null); } Lucene.Net.Search.IndexSearcher searcher = Index.CreateSearcher(); var hits = searcher.Search(q, Int32.MaxValue); if (this.Explain > -1) { this.Explanation = searcher.Explain(q, this.Explain); } IList <Document> hitsToReturn = new List <Document>(); foreach (var searchDoc in hits.ScoreDocs) { var doc = searcher.Doc(searchDoc.Doc); hitsToReturn.Add(doc); } return(hitsToReturn); }
public virtual void TestNoDocs() { Directory indexStore = NewDirectory(); RandomIndexWriter writer = new RandomIndexWriter( #if FEATURE_INSTANCE_TESTDATA_INITIALIZATION this, #endif Random, indexStore); Add("a note", "note", writer); IndexReader reader = writer.GetReader(); IndexSearcher searcher = NewSearcher(reader); MultiPhraseQuery q = new MultiPhraseQuery(); q.Add(new Term("body", "a")); q.Add(new Term[] { new Term("body", "nope"), new Term("body", "nope") }); Assert.AreEqual(0, searcher.Search(q, null, 1).TotalHits, "Wrong number of hits"); // just make sure no exc: searcher.Explain(q, 0); writer.Dispose(); reader.Dispose(); indexStore.Dispose(); }
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)); }
public virtual void Collect(int doc) { Explanation exp; // LUCENENET: IDE0059: Remove unnecessary value assignment doc = doc + @base; try { exp = s.Explain(q, doc); } catch (Exception e) when(e.IsIOException()) { throw RuntimeException.Create("exception in hitcollector of [[" + d + "]] for #" + doc, e); } Assert.IsNotNull(exp, "Explanation of [[" + d + "]] for #" + doc + " is null"); CheckHits.VerifyExplanation(d, doc, scorer.GetScore(), deep, exp); Assert.IsTrue(exp.IsMatch, "Explanation of [[" + d + "]] for #" + doc + " does not indicate match: " + exp.ToString()); }
public virtual void Collect(int doc) { Explanation exp = null; doc = doc + @base; try { exp = s.Explain(q, doc); } catch (IOException e) { throw new Exception("exception in hitcollector of [[" + d + "]] for #" + doc, e); } Assert.IsNotNull(exp, "Explanation of [[" + d + "]] for #" + doc + " is null"); CheckHits.VerifyExplanation(d, doc, scorer.GetScore(), deep, exp); Assert.IsTrue(exp.IsMatch, "Explanation of [[" + d + "]] for #" + doc + " does not indicate match: " + exp.ToString()); }
public override void Collect(int doc) { Explanation exp = null; doc = doc + @base; try { exp = s.Explain(q, doc); } catch (IOException e) { throw new Exception("exception in hitcollector of [[" + d + "]] for #" + doc, e); } Assert.IsNotNull(exp, "Explanation of [[" + d + "]] for #" + doc + " is null"); VerifyExplanation(d, doc, Scorer_Renamed.Score(), Deep, exp); Assert.IsTrue(exp.IsMatch, "Explanation of [[" + d + "]] for #" + doc + " does not indicate match: " + exp.ToString()); }
public virtual void TestDocBoost_Mem() { Directory store = NewDirectory(); RandomIndexWriter writer = new RandomIndexWriter(Random, store, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)).SetMergePolicy(NewLogMergePolicy())); Field f1 = NewTextField("field", "word", Field.Store.YES); Field f2 = NewTextField("field", "word", Field.Store.YES); f2.Boost = 2.0f; Documents.Document d1 = new Documents.Document(); Documents.Document d2 = new Documents.Document(); d1.Add(f1); // boost = 1 d2.Add(f2); // boost = 2 writer.AddDocument(d1); writer.AddDocument(d2); IndexReader reader = writer.GetReader(); writer.Dispose(); float[] scores = new float[4]; IndexSearcher searcher = NewSearcher(reader); searcher.Search(new TermQuery(new Term("field", "word")), new CollectorAnonymousInnerClassHelper(this, scores)); float lastScore = 0.0f; for (int i = 0; i < 2; i++) { if (Verbose) { Console.WriteLine(searcher.Explain(new TermQuery(new Term("field", "word")), i)); } Assert.IsTrue(scores[i] > lastScore, "score: " + scores[i] + " should be > lastScore: " + lastScore); lastScore = scores[i]; } reader.Dispose(); store.Dispose(); }
public virtual void TestBooleanQueryContainingSingleTermPrefixQuery() { // this tests against bug 33161 (now fixed) // In order to cause the bug, the outer query must have more than one term // and all terms required. // The contained PhraseMultiQuery must contain exactly one term array. Directory indexStore = NewDirectory(); RandomIndexWriter writer = new RandomIndexWriter( #if FEATURE_INSTANCE_TESTDATA_INITIALIZATION this, #endif Random, indexStore); Add("blueberry pie", writer); Add("blueberry chewing gum", writer); Add("blue raspberry pie", writer); IndexReader reader = writer.GetReader(); IndexSearcher searcher = NewSearcher(reader); // this query will be equivalent to +body:pie +body:"blue*" BooleanQuery q = new BooleanQuery(); q.Add(new TermQuery(new Term("body", "pie")), Occur.MUST); MultiPhraseQuery trouble = new MultiPhraseQuery(); trouble.Add(new Term[] { new Term("body", "blueberry"), new Term("body", "blue") }); q.Add(trouble, Occur.MUST); // exception will be thrown here without fix ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs; Assert.AreEqual(2, hits.Length, "Wrong number of hits"); // just make sure no exc: searcher.Explain(q, 0); writer.Dispose(); reader.Dispose(); indexStore.Dispose(); }
private void Explain(LNS.Query query) { int j = 0; while (j < collector.Array.Count) { int i; i = collector.Array.GetNextTrueIndex(j); if (i >= collector.Array.Count) { break; } j = i + 1; Document doc = searcher.Doc(i); LNS.Explanation exp = searcher.Explain(query, i); Log.Debug("Query: [{0}]", query); Log.Debug("Matching URI: {0}", doc.Get("Uri")); Log.Debug("Explanation: {0}", exp); } }
/// <summary> /// Tests that all documents up to maxDoc which are *not* in the /// expected result set, have an explanation which indicates that /// the document does not match /// </summary> public static void CheckNoMatchExplanations(Query q, string defaultFieldName, IndexSearcher searcher, int[] results) { string d = q.ToString(defaultFieldName); SortedSet<int?> ignore = new SortedSet<int?>(); for (int i = 0; i < results.Length; i++) { ignore.Add(Convert.ToInt32(results[i])); } int maxDoc = searcher.IndexReader.MaxDoc(); for (int doc = 0; doc < maxDoc; doc++) { if (ignore.Contains(Convert.ToInt32(doc))) { continue; } Explanation exp = searcher.Explain(q, doc); Assert.IsNotNull(exp, "Explanation of [[" + d + "]] for #" + doc + " is null"); Assert.IsFalse(exp.IsMatch, "Explanation of [[" + d + "]] for #" + doc + " doesn't indicate non-match: " + exp.ToString()); } }
public override Explanation Explain(IndexSearcher searcher, Explanation firstPassExplanation, int docID) { Explanation secondPassExplanation = searcher.Explain(query, docID); float?secondPassScore = secondPassExplanation.IsMatch ? (float?)secondPassExplanation.Value : null; float score; if (secondPassScore == null) { score = Combine(firstPassExplanation.Value, false, 0.0f); } else { score = Combine(firstPassExplanation.Value, true, (float)secondPassScore); } Explanation result = new Explanation(score, "combined first and second pass score using " + this.GetType()); Explanation first = new Explanation(firstPassExplanation.Value, "first pass score"); first.AddDetail(firstPassExplanation); result.AddDetail(first); Explanation second; if (secondPassScore == null) { second = new Explanation(0.0f, "no second pass score"); } else { second = new Explanation((float)secondPassScore, "second pass score"); } second.AddDetail(secondPassExplanation); result.AddDetail(second); return(result); }
public virtual void TestNoDocs() { Directory indexStore = NewDirectory(); RandomIndexWriter writer = new RandomIndexWriter(Random, indexStore, Similarity, TimeZone); Add("a note", "note", writer); IndexReader reader = writer.GetReader(); IndexSearcher searcher = NewSearcher(reader); MultiPhraseQuery q = new MultiPhraseQuery(); q.Add(new Term("body", "a")); q.Add(new Term[] { new Term("body", "nope"), new Term("body", "nope") }); Assert.AreEqual(0, searcher.Search(q, null, 1).TotalHits, "Wrong number of hits"); // just make sure no exc: searcher.Explain(q, 0); writer.Dispose(); reader.Dispose(); indexStore.Dispose(); }
/// <summary> /// Tests that all documents up to maxDoc which are *not* in the /// expected result set, have an explanation which indicates that /// the document does not match /// </summary> public static void CheckNoMatchExplanations(Query q, string defaultFieldName, IndexSearcher searcher, int[] results) { string d = q.ToString(defaultFieldName); SortedSet <int?> ignore = new SortedSet <int?>(); for (int i = 0; i < results.Length; i++) { ignore.Add(Convert.ToInt32(results[i], CultureInfo.InvariantCulture)); } int maxDoc = searcher.IndexReader.MaxDoc; for (int doc = 0; doc < maxDoc; doc++) { if (ignore.Contains(Convert.ToInt32(doc, CultureInfo.InvariantCulture))) { continue; } Explanation exp = searcher.Explain(q, doc); Assert.IsNotNull(exp, "Explanation of [[" + d + "]] for #" + doc + " is null"); Assert.IsFalse(exp.IsMatch, "Explanation of [[" + d + "]] for #" + doc + " doesn't indicate non-match: " + exp.ToString()); } }
public virtual void TestExplain() { Directory dir = NewDirectory(); RandomIndexWriter w = new RandomIndexWriter( #if FEATURE_INSTANCE_TESTDATA_INITIALIZATION this, #endif Random, dir); Document doc = new Document(); doc.Add(NewStringField("id", "0", Field.Store.YES)); doc.Add(NewTextField("field", "wizard the the the the the oz", Field.Store.NO)); w.AddDocument(doc); doc = new Document(); doc.Add(NewStringField("id", "1", Field.Store.YES)); // 1 extra token, but wizard and oz are close; doc.Add(NewTextField("field", "wizard oz the the the the the the", Field.Store.NO)); w.AddDocument(doc); IndexReader r = w.GetReader(); w.Dispose(); // Do ordinary BooleanQuery: BooleanQuery bq = new BooleanQuery(); bq.Add(new TermQuery(new Term("field", "wizard")), Occur.SHOULD); bq.Add(new TermQuery(new Term("field", "oz")), Occur.SHOULD); IndexSearcher searcher = GetSearcher(r); TopDocs hits = searcher.Search(bq, 10); Assert.AreEqual(2, hits.TotalHits); Assert.AreEqual("0", searcher.Doc(hits.ScoreDocs[0].Doc).Get("id")); Assert.AreEqual("1", searcher.Doc(hits.ScoreDocs[1].Doc).Get("id")); // Now, resort using PhraseQuery: PhraseQuery pq = new PhraseQuery(); pq.Add(new Term("field", "wizard")); pq.Add(new Term("field", "oz")); Rescorer rescorer = new QueryRescorerAnonymousInnerClassHelper2(this, pq); TopDocs hits2 = rescorer.Rescore(searcher, hits, 10); // Resorting changed the order: Assert.AreEqual(2, hits2.TotalHits); Assert.AreEqual("1", searcher.Doc(hits2.ScoreDocs[0].Doc).Get("id")); Assert.AreEqual("0", searcher.Doc(hits2.ScoreDocs[1].Doc).Get("id")); int docID = hits2.ScoreDocs[0].Doc; Explanation explain = rescorer.Explain(searcher, searcher.Explain(bq, docID), docID); string s = explain.ToString(); Assert.IsTrue(s.Contains("TestQueryRescorer+")); Assert.IsTrue(s.Contains("combined first and second pass score")); Assert.IsTrue(s.Contains("first pass score")); Assert.IsTrue(s.Contains("= second pass score")); Assert.AreEqual(hits2.ScoreDocs[0].Score, explain.Value, 0.0f); docID = hits2.ScoreDocs[1].Doc; explain = rescorer.Explain(searcher, searcher.Explain(bq, docID), docID); s = explain.ToString(); Assert.IsTrue(s.Contains("TestQueryRescorer+")); Assert.IsTrue(s.Contains("combined first and second pass score")); Assert.IsTrue(s.Contains("first pass score")); Assert.IsTrue(s.Contains("no second pass score")); Assert.IsFalse(s.Contains("= second pass score")); Assert.IsTrue(s.Contains("NON-MATCH")); Assert.IsTrue(Math.Abs(hits2.ScoreDocs[1].Score - explain.Value) < 0.0000001f); r.Dispose(); dir.Dispose(); }
/// <summary> /// Checks to see if the hits are what we expected. /// /// LUCENENET specific /// Is non-static because it depends on the non-static variable, <see cref="LuceneTestCase.Similarity"/> /// </summary> /// <param name="query"> the query to execute </param> /// <param name="description"> the description of the search </param> /// <param name="expectedIds"> the expected document ids of the hits </param> /// <param name="expectedScores"> the expected scores of the hits </param> protected internal void AssertHits(IndexSearcher s, Query query, string description, string[] expectedIds, float[] expectedScores) { QueryUtils.Check(Random(), query, s, Similarity); const float tolerance = 1e-5f; // Hits hits = searcher.Search(query); // hits normalizes and throws things off if one score is greater than 1.0 TopDocs topdocs = s.Search(query, null, 10000); /* /// // display the hits System.out.println(hits.Length() + /// " hits for search: \"" + description + '\"'); for (int i = 0; i < /// hits.Length(); i++) { System.out.println(" " + FIELD_ID + ':' + /// hits.Doc(i).Get(FIELD_ID) + " (score:" + hits.Score(i) + ')'); } /// **** */ // did we get the hits we expected Assert.AreEqual(expectedIds.Length, topdocs.TotalHits); for (int i = 0; i < topdocs.TotalHits; i++) { // System.out.println(i + " exp: " + expectedIds[i]); // System.out.println(i + " field: " + hits.Doc(i).Get(FIELD_ID)); int id = topdocs.ScoreDocs[i].Doc; float score = topdocs.ScoreDocs[i].Score; Document doc = s.Doc(id); Assert.AreEqual(expectedIds[i], doc.Get(FIELD_ID)); bool scoreEq = Math.Abs(expectedScores[i] - score) < tolerance; if (!scoreEq) { Console.WriteLine(i + " warning, expected score: " + expectedScores[i] + ", actual " + score); Console.WriteLine(s.Explain(query, id)); } Assert.AreEqual(expectedScores[i], score, tolerance); Assert.AreEqual(s.Explain(query, id).Value, score, tolerance); } }
public IList<ISearchResult> Search(string searchTerms, Language language, User user, ISession session) { var results = new List<ISearchResult>(); if (!IndexReader.IndexExists(LuceneFolder)) return results; if (string.IsNullOrEmpty(searchTerms)) return results; var numberOfIndexTexts = Indexer.GetNumberOfIndexedFields(); var words = searchTerms.ToLowerInvariant().Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); var contentQuery = new BooleanQuery(); foreach (var keyword in words) { if (!string.IsNullOrEmpty(keyword)) { var terms = new BooleanQuery(); for (int i = 0; i < numberOfIndexTexts; i++) { var field = string.Format("index{0}", i); terms.Add(new WildcardQuery(new Term(field, keyword + "*")), BooleanClause.Occur.SHOULD); } contentQuery.Add(terms, BooleanClause.Occur.MUST); } } var query = new BooleanQuery(); query.Add(contentQuery, BooleanClause.Occur.MUST); if (user != null) { query.Add(new WildcardQuery(new Term("user", user.Id.ToString())), BooleanClause.Occur.MUST); } query.Add(new WildcardQuery(new Term("language", language.ShortName)), BooleanClause.Occur.MUST); var searcher = new IndexSearcher(LuceneFolder); var hits = searcher.Search(query); if (hits.Length() == 0) return results; for (var i = 0; i < hits.Length(); i++) { var doc = hits.Doc(i); var typeValue = doc.Get("type"); var idValue = doc.Get("id"); var type = Type.GetType(typeValue); try { var searchable = (ISearchable) session.Get(type, Convert.ToInt32(idValue)); //Direct initialiseren, omdat anders die exception pas later zou kunnen komen. NHibernateUtil.Initialize(searchable); var title = StripTags(searchable.SearchResultTitle); var explain = searcher.Explain(query, hits.Id(i)).ToHtml(); var result = SearchResultParser(searchable, title, explain); if (result != null) results.Add(result); } catch (ObjectNotFoundException) { // Misschien hier de index entry verwijderen. Omdat het object blijkbaar niet meer bestaat. Tenzij er iets anders mis is, dan // zou verwijderen wat voorbarig zijn. } } searcher.Close(); return results; }
public virtual void TestPalyndrome3() { // search on non palyndrome, find phrase with no slop, using exact phrase scorer query.Slop = 0; // to use exact phrase scorer query.Add(new Term("field", "one")); query.Add(new Term("field", "two")); query.Add(new Term("field", "three")); ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs; Assert.AreEqual(1, hits.Length, "phrase found with exact phrase scorer"); float score0 = hits[0].Score; //System.out.println("(exact) field: one two three: "+score0); QueryUtils.Check( #if FEATURE_INSTANCE_TESTDATA_INITIALIZATION this, #endif Random, query, searcher); // just make sure no exc: searcher.Explain(query, 0); // search on non palyndrome, find phrase with slop 3, though no slop required here. query.Slop = 4; // to use sloppy scorer hits = searcher.Search(query, null, 1000).ScoreDocs; Assert.AreEqual(1, hits.Length, "just sloppy enough"); float score1 = hits[0].Score; //System.out.println("(sloppy) field: one two three: "+score1); Assert.AreEqual(score0, score1, SCORE_COMP_THRESH, "exact scorer and sloppy scorer score the same when slop does not matter"); QueryUtils.Check( #if FEATURE_INSTANCE_TESTDATA_INITIALIZATION this, #endif Random, query, searcher); // search ordered in palyndrome, find it twice query = new PhraseQuery(); query.Slop = 4; // must be at least four for both ordered and reversed to match query.Add(new Term("palindrome", "one")); query.Add(new Term("palindrome", "two")); query.Add(new Term("palindrome", "three")); hits = searcher.Search(query, null, 1000).ScoreDocs; // just make sure no exc: searcher.Explain(query, 0); Assert.AreEqual(1, hits.Length, "just sloppy enough"); //float score2 = hits[0].Score; //System.out.println("palindrome: one two three: "+score2); QueryUtils.Check( #if FEATURE_INSTANCE_TESTDATA_INITIALIZATION this, #endif Random, query, searcher); //commented out for sloppy-phrase efficiency (issue 736) - see SloppyPhraseScorer.phraseFreq(). //Assert.IsTrue("ordered scores higher in palindrome",score1+SCORE_COMP_THRESH<score2); // search reveresed in palyndrome, find it twice query = new PhraseQuery(); query.Slop = 4; // must be at least four for both ordered and reversed to match query.Add(new Term("palindrome", "three")); query.Add(new Term("palindrome", "two")); query.Add(new Term("palindrome", "one")); hits = searcher.Search(query, null, 1000).ScoreDocs; Assert.AreEqual(1, hits.Length, "just sloppy enough"); //float score3 = hits[0].Score; //System.out.println("palindrome: three two one: "+score3); QueryUtils.Check( #if FEATURE_INSTANCE_TESTDATA_INITIALIZATION this, #endif Random, query, searcher); //commented out for sloppy-phrase efficiency (issue 736) - see SloppyPhraseScorer.phraseFreq(). //Assert.IsTrue("reversed scores higher in palindrome",score1+SCORE_COMP_THRESH<score3); //Assert.AreEqual("ordered or reversed does not matter",score2, score3, SCORE_COMP_THRESH); }
public virtual void TestPhrasePrefix() { Directory indexStore = NewDirectory(); RandomIndexWriter writer = new RandomIndexWriter(Random(), indexStore); Add("blueberry pie", writer); Add("blueberry strudel", writer); Add("blueberry pizza", writer); Add("blueberry chewing gum", writer); Add("bluebird pizza", writer); Add("bluebird foobar pizza", writer); Add("piccadilly circus", writer); IndexReader reader = writer.Reader; IndexSearcher searcher = NewSearcher(reader); // search for "blueberry pi*": MultiPhraseQuery query1 = new MultiPhraseQuery(); // search for "strawberry pi*": MultiPhraseQuery query2 = new MultiPhraseQuery(); query1.Add(new Term("body", "blueberry")); query2.Add(new Term("body", "strawberry")); LinkedList <Term> termsWithPrefix = new LinkedList <Term>(); // this TermEnum gives "piccadilly", "pie" and "pizza". string prefix = "pi"; TermsEnum te = MultiFields.GetFields(reader).Terms("body").Iterator(null); te.SeekCeil(new BytesRef(prefix)); do { string s = te.Term().Utf8ToString(); if (s.StartsWith(prefix)) { termsWithPrefix.AddLast(new Term("body", s)); } else { break; } } while (te.Next() != null); query1.Add(termsWithPrefix.ToArray(/*new Term[0]*/)); Assert.AreEqual("body:\"blueberry (piccadilly pie pizza)\"", query1.ToString()); query2.Add(termsWithPrefix.ToArray(/*new Term[0]*/)); Assert.AreEqual("body:\"strawberry (piccadilly pie pizza)\"", query2.ToString()); ScoreDoc[] result; result = searcher.Search(query1, null, 1000).ScoreDocs; Assert.AreEqual(2, result.Length); result = searcher.Search(query2, null, 1000).ScoreDocs; Assert.AreEqual(0, result.Length); // search for "blue* pizza": MultiPhraseQuery query3 = new MultiPhraseQuery(); termsWithPrefix.Clear(); prefix = "blue"; te.SeekCeil(new BytesRef(prefix)); do { if (te.Term().Utf8ToString().StartsWith(prefix)) { termsWithPrefix.AddLast(new Term("body", te.Term().Utf8ToString())); } } while (te.Next() != null); query3.Add(termsWithPrefix.ToArray(/*new Term[0]*/)); query3.Add(new Term("body", "pizza")); result = searcher.Search(query3, null, 1000).ScoreDocs; Assert.AreEqual(2, result.Length); // blueberry pizza, bluebird pizza Assert.AreEqual("body:\"(blueberry bluebird) pizza\"", query3.ToString()); // test slop: query3.Slop = 1; result = searcher.Search(query3, null, 1000).ScoreDocs; // just make sure no exc: searcher.Explain(query3, 0); Assert.AreEqual(3, result.Length); // blueberry pizza, bluebird pizza, bluebird // foobar pizza MultiPhraseQuery query4 = new MultiPhraseQuery(); try { query4.Add(new Term("field1", "foo")); query4.Add(new Term("field2", "foobar")); Assert.Fail(); } catch (System.ArgumentException e) { // okay, all terms must belong to the same field } writer.Dispose(); reader.Dispose(); indexStore.Dispose(); }
public static JToken AutoCompleteMakeResult(IndexSearcher searcher, TopDocs topDocs, int skip, int take, NuGetSearcherManager searcherManager, bool includeExplanation, Query query) { JArray array = new JArray(); for (int i = skip; i < Math.Min(skip + take, topDocs.ScoreDocs.Length); i++) { ScoreDoc scoreDoc = topDocs.ScoreDocs[i]; Document document = searcher.Doc(scoreDoc.Doc); string id = document.Get("Id"); array.Add(id); } JObject result = new JObject(); result.Add("@context", new JObject { { "@vocab", "http://schema.nuget.org/schema#" } }); result.Add("totalHits", topDocs.TotalHits); result.Add("indexName", searcherManager.IndexName); result.Add("data", array); if (includeExplanation) { JArray explanations = new JArray(); for (int i = skip; i < Math.Min(skip + take, topDocs.ScoreDocs.Length); i++) { ScoreDoc scoreDoc = topDocs.ScoreDocs[i]; Explanation explanation = searcher.Explain(query, scoreDoc.Doc); explanations.Add(explanation.ToString()); } result.Add("explanations", explanations); } return result; }
public void ExtrairExplicacaoQueryComTermoPorCidade(Directory diretorio, Query query) { using (var indexSearcher = new IndexSearcher(diretorio, true)) { var topDocs = indexSearcher.Search(query, 10); foreach (var scoreDoc in topDocs.ScoreDocs) { var explanation = indexSearcher.Explain(query, scoreDoc.Doc); var document = indexSearcher.Doc(scoreDoc.Doc); Console.WriteLine("------\n{0}\n{1}", document.Get(TipoImovel), explanation); } } }
private static string AddExplanation(IndexSearcher searcher, string data, Query query, ScoreDoc scoreDoc, IDictionary<string, int> rankings) { Explanation explanation = searcher.Explain(query, scoreDoc.Doc); JObject diagnostics = new JObject(); int rankVal; string id = searcher.Doc(scoreDoc.Doc).Get("Id"); if (rankings.TryGetValue(id, out rankVal)) { float rankingScore = RankingScoreQuery.GetRankingScore(rankings, id); diagnostics.Add("Rank", rankVal); diagnostics.Add("RankScore", rankingScore); diagnostics.Add("LuceneScore", scoreDoc.Score / rankingScore); } diagnostics.Add("Score", scoreDoc.Score.ToString()); diagnostics.Add("Explanation", explanation.ToString()); diagnostics.Add("IdTerms", GetTerms(searcher, scoreDoc.Doc, "Id")); diagnostics.Add("TokenizedIdTerms", GetTerms(searcher, scoreDoc.Doc, "TokenizedId")); diagnostics.Add("ShingledIdTerms", GetTerms(searcher, scoreDoc.Doc, "ShingledId")); diagnostics.Add("VersionTerms", GetTerms(searcher, scoreDoc.Doc, "Version")); diagnostics.Add("TitleTerms", GetTerms(searcher, scoreDoc.Doc, "Title")); diagnostics.Add("TagsTerms", GetTerms(searcher, scoreDoc.Doc, "Tags")); diagnostics.Add("DescriptionTerms", GetTerms(searcher, scoreDoc.Doc, "Description")); diagnostics.Add("AuthorsTerms", GetTerms(searcher, scoreDoc.Doc, "Authors")); diagnostics.Add("OwnersTerms", GetTerms(searcher, scoreDoc.Doc, "Owners")); diagnostics.Add("PublishedDate", GetInt(searcher, scoreDoc.Doc, "PublishedDate")); diagnostics.Add("EditedDate", GetInt(searcher, scoreDoc.Doc, "EditedDate")); diagnostics.Add("CuratedFeed", GetMultiValue(searcher, scoreDoc.Doc, "CuratedFeed")); diagnostics.Add("Key", GetInt(searcher, scoreDoc.Doc, "Key")); diagnostics.Add("Checksum", GetInt(searcher, scoreDoc.Doc, "Checksum")); diagnostics.Add("ProjectGuidRankings", GetProjectGuidRankings(searcher, scoreDoc.Doc)); JObject obj = JObject.Parse(data); obj.Add("diagnostics", diagnostics); data = obj.ToString(); return data; }
private void LogResult(string msg, IndexSearcher s, Query q, int doc, float? score1) { Log(msg + " " + score1); Log("Explain by: " + q); Log(s.Explain(q, doc)); }
private static StringBuilder GetSearcResultExplanation(LuceneQuery luceneQuery, IEnumerable<ScoreDoc> scoreDocs, IndexSearcher searcher) { var sb = new StringBuilder(); sb.AppendLine("Query: " + luceneQuery.Query.ToString()); foreach (var match in scoreDocs) { var explanation = searcher.Explain(luceneQuery.Query, match.Doc); sb.AppendLine("-------------------"); var doc = searcher.Doc(match.Doc); sb.AppendLine(doc.Get(Constants.TitleTag)); sb.AppendLine(explanation.ToString()); } return sb; }
public void TestRandom() { // We build two indices at once: one normalized (which // ToParentBlockJoinQuery/Collector, // ToChildBlockJoinQuery can query) and the other w/ // the same docs, just fully denormalized: Directory dir = NewDirectory(); Directory joinDir = NewDirectory(); int numParentDocs = TestUtil.NextInt(Random(), 100 * RANDOM_MULTIPLIER, 300 * RANDOM_MULTIPLIER); //final int numParentDocs = 30; // Values for parent fields: string[][] parentFields = GetRandomFields(numParentDocs / 2); // Values for child fields: string[][] childFields = GetRandomFields(numParentDocs); bool doDeletes = Random().NextBoolean(); IList<int> toDelete = new List<int>(); // TODO: parallel star join, nested join cases too! RandomIndexWriter w = new RandomIndexWriter(Random(), dir, Similarity, TimeZone); RandomIndexWriter joinW = new RandomIndexWriter(Random(), joinDir, Similarity, TimeZone); for (int parentDocID = 0; parentDocID < numParentDocs; parentDocID++) { Document parentDoc = new Document(); Document parentJoinDoc = new Document(); Field id = NewStringField("parentID", "" + parentDocID, Field.Store.YES); parentDoc.Add(id); parentJoinDoc.Add(id); parentJoinDoc.Add(NewStringField("isParent", "x", Field.Store.NO)); for (int field = 0; field < parentFields.Length; field++) { if (Random().NextDouble() < 0.9) { Field f = NewStringField("parent" + field, parentFields[field][Random().Next(parentFields[field].Length)], Field.Store.NO); parentDoc.Add(f); parentJoinDoc.Add(f); } } if (doDeletes) { parentDoc.Add(NewStringField("blockID", "" + parentDocID, Field.Store.NO)); parentJoinDoc.Add(NewStringField("blockID", "" + parentDocID, Field.Store.NO)); } IList<Document> joinDocs = new List<Document>(); if (VERBOSE) { StringBuilder sb = new StringBuilder(); sb.Append("parentID=").Append(parentDoc.Get("parentID")); for (int fieldID = 0; fieldID < parentFields.Length; fieldID++) { string parent = parentDoc.Get("parent" + fieldID); if (parent != null) { sb.Append(" parent" + fieldID + "=" + parent); } } Console.WriteLine(" " + sb); } int numChildDocs = TestUtil.NextInt(Random(), 1, 20); for (int childDocID = 0; childDocID < numChildDocs; childDocID++) { // Denormalize: copy all parent fields into child doc: Document childDoc = TestUtil.CloneDocument(parentDoc); Document joinChildDoc = new Document(); joinDocs.Add(joinChildDoc); Field childID = NewStringField("childID", "" + childDocID, Field.Store.YES); childDoc.Add(childID); joinChildDoc.Add(childID); for (int childFieldID = 0; childFieldID < childFields.Length; childFieldID++) { if (Random().NextDouble() < 0.9) { Field f = NewStringField("child" + childFieldID, childFields[childFieldID][Random().Next(childFields[childFieldID].Length)], Field.Store.NO); childDoc.Add(f); joinChildDoc.Add(f); } } if (VERBOSE) { StringBuilder sb = new StringBuilder(); sb.Append("childID=").Append(joinChildDoc.Get("childID")); for (int fieldID = 0; fieldID < childFields.Length; fieldID++) { string child = joinChildDoc.Get("child" + fieldID); if (child != null) { sb.Append(" child" + fieldID + "=" + child); } } Console.WriteLine(" " + sb); } if (doDeletes) { joinChildDoc.Add(NewStringField("blockID", "" + parentDocID, Field.Store.NO)); } w.AddDocument(childDoc); } // Parent last: joinDocs.Add(parentJoinDoc); joinW.AddDocuments(joinDocs); if (doDeletes && Random().Next(30) == 7) { toDelete.Add(parentDocID); } } foreach (int deleteID in toDelete) { if (VERBOSE) { Console.WriteLine("DELETE parentID=" + deleteID); } w.DeleteDocuments(new Term("blockID", "" + deleteID)); joinW.DeleteDocuments(new Term("blockID", "" + deleteID)); } IndexReader r = w.Reader; w.Dispose(); IndexReader joinR = joinW.Reader; joinW.Dispose(); if (VERBOSE) { Console.WriteLine("TEST: reader=" + r); Console.WriteLine("TEST: joinReader=" + joinR); for (int docIDX = 0; docIDX < joinR.MaxDoc; docIDX++) { Console.WriteLine(" docID=" + docIDX + " doc=" + joinR.Document(docIDX)); } } IndexSearcher s = NewSearcher(r); IndexSearcher joinS = new IndexSearcher(joinR); Filter parentsFilter = new FixedBitSetCachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Term("isParent", "x")))); int iters = 200 * RANDOM_MULTIPLIER; for (int iter = 0; iter < iters; iter++) { if (VERBOSE) { Console.WriteLine("TEST: iter=" + (1 + iter) + " of " + iters); } Query childQuery; if (Random().Next(3) == 2) { int childFieldID = Random().Next(childFields.Length); childQuery = new TermQuery(new Term("child" + childFieldID, childFields[childFieldID][Random().Next(childFields[childFieldID].Length)])); } else if (Random().Next(3) == 2) { BooleanQuery bq = new BooleanQuery(); childQuery = bq; int numClauses = TestUtil.NextInt(Random(), 2, 4); bool didMust = false; for (int clauseIDX = 0; clauseIDX < numClauses; clauseIDX++) { Query clause; BooleanClause.Occur occur; if (!didMust && Random().NextBoolean()) { occur = Random().NextBoolean() ? BooleanClause.Occur.MUST : BooleanClause.Occur.MUST_NOT; clause = new TermQuery(RandomChildTerm(childFields[0])); didMust = true; } else { occur = BooleanClause.Occur.SHOULD; int childFieldID = TestUtil.NextInt(Random(), 1, childFields.Length - 1); clause = new TermQuery(new Term("child" + childFieldID, childFields[childFieldID][Random().Next(childFields[childFieldID].Length)])); } bq.Add(clause, occur); } } else { BooleanQuery bq = new BooleanQuery(); childQuery = bq; bq.Add(new TermQuery(RandomChildTerm(childFields[0])), BooleanClause.Occur.MUST); int childFieldID = TestUtil.NextInt(Random(), 1, childFields.Length - 1); bq.Add(new TermQuery(new Term("child" + childFieldID, childFields[childFieldID][Random().Next(childFields[childFieldID].Length)])), Random().NextBoolean() ? BooleanClause.Occur.MUST : BooleanClause.Occur.MUST_NOT); } int x = Random().Next(4); ScoreMode agg; if (x == 0) { agg = ScoreMode.None; } else if (x == 1) { agg = ScoreMode.Max; } else if (x == 2) { agg = ScoreMode.Total; } else { agg = ScoreMode.Avg; } ToParentBlockJoinQuery childJoinQuery = new ToParentBlockJoinQuery(childQuery, parentsFilter, agg); // To run against the block-join index: Query parentJoinQuery; // Same query as parentJoinQuery, but to run against // the fully denormalized index (so we can compare // results): Query parentQuery; if (Random().NextBoolean()) { parentQuery = childQuery; parentJoinQuery = childJoinQuery; } else { // AND parent field w/ child field BooleanQuery bq = new BooleanQuery(); parentJoinQuery = bq; Term parentTerm = RandomParentTerm(parentFields[0]); if (Random().NextBoolean()) { bq.Add(childJoinQuery, BooleanClause.Occur.MUST); bq.Add(new TermQuery(parentTerm), BooleanClause.Occur.MUST); } else { bq.Add(new TermQuery(parentTerm), BooleanClause.Occur.MUST); bq.Add(childJoinQuery, BooleanClause.Occur.MUST); } BooleanQuery bq2 = new BooleanQuery(); parentQuery = bq2; if (Random().NextBoolean()) { bq2.Add(childQuery, BooleanClause.Occur.MUST); bq2.Add(new TermQuery(parentTerm), BooleanClause.Occur.MUST); } else { bq2.Add(new TermQuery(parentTerm), BooleanClause.Occur.MUST); bq2.Add(childQuery, BooleanClause.Occur.MUST); } } Sort parentSort = GetRandomSort("parent", parentFields.Length); Sort childSort = GetRandomSort("child", childFields.Length); if (VERBOSE) { Console.WriteLine("\nTEST: query=" + parentQuery + " joinQuery=" + parentJoinQuery + " parentSort=" + parentSort + " childSort=" + childSort); } // Merge both sorts: IList<SortField> sortFields = new List<SortField>(Arrays.AsList(parentSort.GetSort())); sortFields.AddRange(Arrays.AsList(childSort.GetSort())); Sort parentAndChildSort = new Sort(sortFields.ToArray()); TopDocs results = s.Search(parentQuery, null, r.NumDocs, parentAndChildSort); if (VERBOSE) { Console.WriteLine("\nTEST: normal index gets " + results.TotalHits + " hits"); ScoreDoc[] hits = results.ScoreDocs; for (int hitIDX = 0; hitIDX < hits.Length; hitIDX++) { Document doc = s.Doc(hits[hitIDX].Doc); //System.out.println(" score=" + hits[hitIDX].Score + " parentID=" + doc.Get("parentID") + " childID=" + doc.Get("childID") + " (docID=" + hits[hitIDX].Doc + ")"); Console.WriteLine(" parentID=" + doc.Get("parentID") + " childID=" + doc.Get("childID") + " (docID=" + hits[hitIDX].Doc + ")"); FieldDoc fd = (FieldDoc)hits[hitIDX]; if (fd.Fields != null) { Console.Write(" "); foreach (object o in fd.Fields) { if (o is BytesRef) { Console.Write(((BytesRef)o).Utf8ToString() + " "); } else { Console.Write(o + " "); } } Console.WriteLine(); } } } bool trackScores; bool trackMaxScore; if (agg == ScoreMode.None) { trackScores = false; trackMaxScore = false; } else { trackScores = Random().NextBoolean(); trackMaxScore = Random().NextBoolean(); } ToParentBlockJoinCollector c = new ToParentBlockJoinCollector(parentSort, 10, trackScores, trackMaxScore); joinS.Search(parentJoinQuery, c); int hitsPerGroup = TestUtil.NextInt(Random(), 1, 20); //final int hitsPerGroup = 100; TopGroups<int> joinResults = c.GetTopGroups(childJoinQuery, childSort, 0, hitsPerGroup, 0, true); if (VERBOSE) { Console.WriteLine("\nTEST: block join index gets " + (joinResults == null ? 0 : joinResults.Groups.Length) + " groups; hitsPerGroup=" + hitsPerGroup); if (joinResults != null) { IGroupDocs<int>[] groups = joinResults.Groups; for (int groupIDX = 0; groupIDX < groups.Length; groupIDX++) { IGroupDocs<int> group = groups[groupIDX]; if (group.GroupSortValues != null) { Console.Write(" "); foreach (object o in group.GroupSortValues) { if (o is BytesRef) { Console.Write(((BytesRef)o).Utf8ToString() + " "); } else { Console.Write(o + " "); } } Console.WriteLine(); } assertNotNull(group.GroupValue); Document parentDoc = joinS.Doc(group.GroupValue); Console.WriteLine(" group parentID=" + parentDoc.Get("parentID") + " (docID=" + group.GroupValue + ")"); for (int hitIDX = 0; hitIDX < group.ScoreDocs.Length; hitIDX++) { Document doc = joinS.Doc(group.ScoreDocs[hitIDX].Doc); //System.out.println(" score=" + group.ScoreDocs[hitIDX].Score + " childID=" + doc.Get("childID") + " (docID=" + group.ScoreDocs[hitIDX].Doc + ")"); Console.WriteLine(" childID=" + doc.Get("childID") + " child0=" + doc.Get("child0") + " (docID=" + group.ScoreDocs[hitIDX].Doc + ")"); } } } } if (results.TotalHits == 0) { assertNull(joinResults); } else { CompareHits(r, joinR, results, joinResults); TopDocs b = joinS.Search(childJoinQuery, 10); foreach (ScoreDoc hit in b.ScoreDocs) { Explanation explanation = joinS.Explain(childJoinQuery, hit.Doc); Document document = joinS.Doc(hit.Doc - 1); int childId = Convert.ToInt32(document.Get("childID")); assertTrue(explanation.IsMatch); assertEquals(hit.Score, explanation.Value, 0.0f); assertEquals(string.Format("Score based on child doc range from {0} to {1}", hit.Doc - 1 - childId, hit.Doc - 1), explanation.Description); } } // Test joining in the opposite direction (parent to // child): // Get random query against parent documents: Query parentQuery2; if (Random().Next(3) == 2) { int fieldID = Random().Next(parentFields.Length); parentQuery2 = new TermQuery(new Term("parent" + fieldID, parentFields[fieldID][Random().Next(parentFields[fieldID].Length)])); } else if (Random().Next(3) == 2) { BooleanQuery bq = new BooleanQuery(); parentQuery2 = bq; int numClauses = TestUtil.NextInt(Random(), 2, 4); bool didMust = false; for (int clauseIDX = 0; clauseIDX < numClauses; clauseIDX++) { Query clause; BooleanClause.Occur occur; if (!didMust && Random().NextBoolean()) { occur = Random().NextBoolean() ? BooleanClause.Occur.MUST : BooleanClause.Occur.MUST_NOT; clause = new TermQuery(RandomParentTerm(parentFields[0])); didMust = true; } else { occur = BooleanClause.Occur.SHOULD; int fieldID = TestUtil.NextInt(Random(), 1, parentFields.Length - 1); clause = new TermQuery(new Term("parent" + fieldID, parentFields[fieldID][Random().Next(parentFields[fieldID].Length)])); } bq.Add(clause, occur); } } else { BooleanQuery bq = new BooleanQuery(); parentQuery2 = bq; bq.Add(new TermQuery(RandomParentTerm(parentFields[0])), BooleanClause.Occur.MUST); int fieldID = TestUtil.NextInt(Random(), 1, parentFields.Length - 1); bq.Add(new TermQuery(new Term("parent" + fieldID, parentFields[fieldID][Random().Next(parentFields[fieldID].Length)])), Random().NextBoolean() ? BooleanClause.Occur.MUST : BooleanClause.Occur.MUST_NOT); } if (VERBOSE) { Console.WriteLine("\nTEST: top down: parentQuery2=" + parentQuery2); } // Maps parent query to child docs: ToChildBlockJoinQuery parentJoinQuery2 = new ToChildBlockJoinQuery(parentQuery2, parentsFilter, Random().NextBoolean()); // To run against the block-join index: Query childJoinQuery2; // Same query as parentJoinQuery, but to run against // the fully denormalized index (so we can compare // results): Query childQuery2; // apply a filter to children Filter childFilter2, childJoinFilter2; if (Random().NextBoolean()) { childQuery2 = parentQuery2; childJoinQuery2 = parentJoinQuery2; childFilter2 = null; childJoinFilter2 = null; } else { Term childTerm = RandomChildTerm(childFields[0]); if (Random().NextBoolean()) // filtered case { childJoinQuery2 = parentJoinQuery2; Filter f = new QueryWrapperFilter(new TermQuery(childTerm)); childJoinFilter2 = Random().NextBoolean() ? new FixedBitSetCachingWrapperFilter(f) : f; } else { childJoinFilter2 = null; // AND child field w/ parent query: BooleanQuery bq = new BooleanQuery(); childJoinQuery2 = bq; if (Random().NextBoolean()) { bq.Add(parentJoinQuery2, BooleanClause.Occur.MUST); bq.Add(new TermQuery(childTerm), BooleanClause.Occur.MUST); } else { bq.Add(new TermQuery(childTerm), BooleanClause.Occur.MUST); bq.Add(parentJoinQuery2, BooleanClause.Occur.MUST); } } if (Random().NextBoolean()) // filtered case { childQuery2 = parentQuery2; Filter f = new QueryWrapperFilter(new TermQuery(childTerm)); childFilter2 = Random().NextBoolean() ? new FixedBitSetCachingWrapperFilter(f) : f; } else { childFilter2 = null; BooleanQuery bq2 = new BooleanQuery(); childQuery2 = bq2; if (Random().NextBoolean()) { bq2.Add(parentQuery2, BooleanClause.Occur.MUST); bq2.Add(new TermQuery(childTerm), BooleanClause.Occur.MUST); } else { bq2.Add(new TermQuery(childTerm), BooleanClause.Occur.MUST); bq2.Add(parentQuery2, BooleanClause.Occur.MUST); } } } Sort childSort2 = GetRandomSort("child", childFields.Length); // Search denormalized index: if (VERBOSE) { Console.WriteLine("TEST: run top down query=" + childQuery2 + " filter=" + childFilter2 + " sort=" + childSort2); } TopDocs results2 = s.Search(childQuery2, childFilter2, r.NumDocs, childSort2); if (VERBOSE) { Console.WriteLine(" " + results2.TotalHits + " totalHits:"); foreach (ScoreDoc sd in results2.ScoreDocs) { Document doc = s.Doc(sd.Doc); Console.WriteLine(" childID=" + doc.Get("childID") + " parentID=" + doc.Get("parentID") + " docID=" + sd.Doc); } } // Search join index: if (VERBOSE) { Console.WriteLine("TEST: run top down join query=" + childJoinQuery2 + " filter=" + childJoinFilter2 + " sort=" + childSort2); } TopDocs joinResults2 = joinS.Search(childJoinQuery2, childJoinFilter2, joinR.NumDocs, childSort2); if (VERBOSE) { Console.WriteLine(" " + joinResults2.TotalHits + " totalHits:"); foreach (ScoreDoc sd in joinResults2.ScoreDocs) { Document doc = joinS.Doc(sd.Doc); Document parentDoc = GetParentDoc(joinR, parentsFilter, sd.Doc); Console.WriteLine(" childID=" + doc.Get("childID") + " parentID=" + parentDoc.Get("parentID") + " docID=" + sd.Doc); } } CompareChildHits(r, joinR, results2, joinResults2); } r.Dispose(); joinR.Dispose(); dir.Dispose(); joinDir.Dispose(); }
public static JToken MakeResultData(IndexSearcher searcher, string currentOwner, string scheme, TopDocs topDocs, int skip, int take, SecureSearcherManager searcherManager, bool includeExplanation, Query query) { Uri registrationBaseAddress = searcherManager.RegistrationBaseAddress[scheme]; JArray array = new JArray(); for (int i = skip; i < Math.Min(skip + take, topDocs.ScoreDocs.Length); i++) { ScoreDoc scoreDoc = topDocs.ScoreDocs[i]; Document document = searcher.Doc(scoreDoc.Doc); string url = document.Get("Url"); string id = document.Get("Id"); string version = document.Get("Version"); string owner = document.Get("Owner"); string ns = document.Get("Namespace"); if (ns != null) { id = string.Format("{0}.{1}", ns, id); } JObject obj = new JObject(); obj["@id"] = new Uri(registrationBaseAddress, url).AbsoluteUri; obj["@type"] = document.Get("@type"); obj["registration"] = new Uri(registrationBaseAddress, string.Format("{0}/index.json", id.ToLowerInvariant())).AbsoluteUri; obj["id"] = id; obj["isOwner"] = (owner == currentOwner); ServiceHelpers.AddField(obj, document, "packageContent", "PackageContent"); ServiceHelpers.AddField(obj, document, "catalogEntry", "CatalogEntry"); ServiceHelpers.AddFieldBool(obj, document, "listed", "Listed"); ServiceHelpers.AddField(obj, document, "tenantId", "TenantId"); ServiceHelpers.AddField(obj, document, "namespace", "Namespace"); ServiceHelpers.AddField(obj, document, "visibility", "Visibility"); ServiceHelpers.AddField(obj, document, "description", "Description"); ServiceHelpers.AddField(obj, document, "summary", "Summary"); ServiceHelpers.AddField(obj, document, "title", "Title"); ServiceHelpers.AddField(obj, document, "iconUrl", "IconUrl"); ServiceHelpers.AddField(obj, document, "homepage", "Homepage"); ServiceHelpers.AddField(obj, document, "licenseUrl", "LicenseUrl"); ServiceHelpers.AddField(obj, document, "projectUrl", "ProjectUrl"); ServiceHelpers.AddFieldAsObject(obj, document, "license", "LicenseDetails"); ServiceHelpers.AddFieldAsObject(obj, document, "owner", "OwnerDetails"); ServiceHelpers.AddFieldAsArray(obj, document, "tags", "Tags"); ServiceHelpers.AddFieldAsArray(obj, document, "authors", "Authors"); ServiceHelpers.AddFieldAsArray(obj, document, "categories", "Categories"); obj["version"] = version; obj["versions"] = searcherManager.GetVersions(scheme, scoreDoc.Doc); if (includeExplanation) { Explanation explanation = searcher.Explain(query, scoreDoc.Doc); obj["explanation"] = explanation.ToString(); } array.Add(obj); } return array; }
private void btnExplain_Click(object sender, System.EventArgs e) { if (listSearch.SelectedItems.Count == 0) return; if (searchedDocIds == null || searchedDocIds.Length < listSearch.Items.Count) return; if (_luke.IndexReader == null) { _luke.ShowStatus(_luke.resources.GetString("NoIndex")); return; } if (query == null) return; IndexSearcher searcher = null; try { searcher = new IndexSearcher(_luke.Directory, true); Lucene.Net.Search.Explanation expl = searcher.Explain(query, searchedDocIds[listSearch.SelectedIndices[0]]); ExplanationDialog explDialog = new ExplanationDialog(expl); explDialog.ShowDialog(this); } catch (Exception exc) { _luke.ErrorMessage(exc.Message); } finally { searcher.Close(); } }