public virtual void TestRAMDirectoryString()
{
MockRAMDirectory ramDir = new MockRAMDirectory(indexDir.FullName);
// Check size
Assert.AreEqual(ramDir.SizeInBytes(), ramDir.GetRecomputedSizeInBytes());
// open reader to test document count
IndexReader reader = IndexReader.Open(ramDir);
Assert.AreEqual(docsToAdd, reader.NumDocs());
// open search zo check if all doc's are there
IndexSearcher searcher = new IndexSearcher(reader);
// search for all documents
for (int i = 0; i < docsToAdd; i++)
{
Document doc = searcher.Doc(i);
Assert.IsTrue(doc.GetField("content") != null);
}
// cleanup
reader.Close();
searcher.Close();
}
public virtual void TestRangeFilterRand()
{
IndexReader reader = IndexReader.Open(signedIndex.index, true);
IndexSearcher search = new IndexSearcher(reader);
System.String minRP = Pad(signedIndex.minR);
System.String maxRP = Pad(signedIndex.maxR);
int numDocs = reader.NumDocs();
Assert.AreEqual(numDocs, 1 + maxId - minId, "num of docs");
ScoreDoc[] result;
Query q = new TermQuery(new Term("body", "body"));
// test extremes, bounded on both ends
result = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
result = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, T, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but biggest");
result = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but smallest");
result = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 2, result.Length, "all but extremes");
// unbounded
result = search.Search(q, new TermRangeFilter("rand", minRP, null, T, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "smallest and up");
result = search.Search(q, new TermRangeFilter("rand", null, maxRP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "biggest and down");
result = search.Search(q, new TermRangeFilter("rand", minRP, null, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not smallest, but up");
result = search.Search(q, new TermRangeFilter("rand", null, maxRP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not biggest, but down");
// very small sets
result = search.Search(q, new TermRangeFilter("rand", minRP, minRP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "min,min,F,F");
result = search.Search(q, new TermRangeFilter("rand", maxRP, maxRP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "max,max,F,F");
result = search.Search(q, new TermRangeFilter("rand", minRP, minRP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "min,min,T,T");
result = search.Search(q, new TermRangeFilter("rand", null, minRP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "nul,min,F,T");
result = search.Search(q, new TermRangeFilter("rand", maxRP, maxRP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "max,max,T,T");
result = search.Search(q, new TermRangeFilter("rand", maxRP, null, T, F), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "max,nul,T,T");
}
public virtual void TestVerifyIndex()
{
IndexReader reader = IndexReader.Open(mDirectory);
Assert.AreEqual(8, reader.NumDocs());
reader.Close();
}
public virtual void TestFieldCacheRangeFilterDoubles()
{
IndexReader reader = IndexReader.Open(signedIndex.index);
IndexSearcher search = new IndexSearcher(reader);
int numDocs = reader.NumDocs();
System.Double minIdO = (double)(minId + .5);
System.Double medIdO = (double)((float)minIdO + ((double)(maxId - minId)) / 2.0);
ScoreDoc[] result;
Query q = new TermQuery(new Term("body", "body"));
result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", minIdO, medIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs / 2, result.Length, "find all");
int count = 0;
result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, medIdO, F, T), numDocs).ScoreDocs;
count += result.Length;
result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", medIdO, null, F, F), numDocs).ScoreDocs;
count += result.Length;
Assert.AreEqual(numDocs, count, "sum of two concenatted ranges");
result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, null, T, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
System.Double tempAux = (double)System.Double.PositiveInfinity;
result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", tempAux, null, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "infinity special case");
System.Double tempAux2 = (double)System.Double.NegativeInfinity;
result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, tempAux2, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "infinity special case");
}
private void TestTermVectors()
{
// check:
int numDocs = reader.NumDocs();
long start = 0L;
for (int docId = 0; docId < numDocs; docId++)
{
start = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond);
TermFreqVector[] vectors = reader.GetTermFreqVectors(docId);
timeElapsed += (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) - start;
// verify vectors result
VerifyVectors(vectors, docId);
start = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond);
TermFreqVector vector = reader.GetTermFreqVector(docId, "field");
timeElapsed += (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) - start;
vectors = new TermFreqVector[1];
vectors[0] = vector;
VerifyVectors(vectors, docId);
}
}
private int Numdoc()
{
IndexReader rs = IndexReader.Open(spellindex);
int num = rs.NumDocs();
Assert.IsTrue(num != 0);
//System.out.println("num docs: " + num);
rs.Close();
return(num);
}
public virtual void TestBinaryFieldInIndex()
{
IFieldable binaryFldStored = new Field("binaryStored", System.Text.UTF8Encoding.UTF8.GetBytes(binaryValStored), Field.Store.YES);
IFieldable stringFldStored = new Field("stringStored", binaryValStored, Field.Store.YES, Field.Index.NO, Field.TermVector.NO);
// binary fields with store off are not allowed
Assert.Throws <ArgumentException>(
() => new Field("fail", System.Text.Encoding.UTF8.GetBytes(binaryValStored), Field.Store.NO));
Document doc = new Document();
doc.Add(binaryFldStored);
doc.Add(stringFldStored);
/* test for field count */
Assert.AreEqual(2, doc.fields_ForNUnit.Count);
/* add the doc to a ram index */
MockRAMDirectory dir = new MockRAMDirectory();
IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_CURRENT), true, IndexWriter.MaxFieldLength.LIMITED);
writer.AddDocument(doc);
writer.Close();
/* open a reader and fetch the document */
IndexReader reader = IndexReader.Open(dir, false);
Document docFromReader = reader.Document(0);
Assert.IsTrue(docFromReader != null);
/* fetch the binary stored field and compare it's content with the original one */
System.String binaryFldStoredTest = new System.String(System.Text.UTF8Encoding.UTF8.GetChars(docFromReader.GetBinaryValue("binaryStored")));
Assert.IsTrue(binaryFldStoredTest.Equals(binaryValStored));
/* fetch the string field and compare it's content with the original one */
System.String stringFldStoredTest = docFromReader.Get("stringStored");
Assert.IsTrue(stringFldStoredTest.Equals(binaryValStored));
/* delete the document from index */
reader.DeleteDocument(0);
Assert.AreEqual(0, reader.NumDocs());
reader.Close();
dir.Close();
}
/// <summary> Extracts all terms texts of a given Query into an array of WeightedTerms
///
/// </summary>
/// <param name="query"> Query to extract term texts from
/// </param>
/// <param name="reader">used to compute IDF which can be used to a) score selected fragments better
/// b) use graded highlights eg chaning intensity of font color
/// </param>
/// <param name="fieldName">the field on which Inverse Document Frequency (IDF) calculations are based
/// </param>
/// <returns> an array of the terms used in a query, plus their weights.
/// </returns>
public static WeightedTerm[] GetIdfWeightedTerms(Query query, IndexReader reader, System.String fieldName)
{
WeightedTerm[] terms = GetTerms(query, false, fieldName);
int totalNumDocs = reader.NumDocs();
for (int i = 0; i < terms.Length; i++)
{
try
{
int docFreq = reader.DocFreq(new Term(fieldName, terms[i].term));
//IDF algorithm taken from DefaultSimilarity class
float idf = (float) (System.Math.Log((float) totalNumDocs / (double) (docFreq + 1)) + 1.0);
terms[i].weight *= idf;
}
catch (System.IO.IOException e)
{
//ignore
}
}
return terms;
}
public virtual void TestMissingTerms()
{
System.String fieldName = "field1";
MockRAMDirectory rd = new MockRAMDirectory();
IndexWriter w = new IndexWriter(rd, new KeywordAnalyzer(), MaxFieldLength.UNLIMITED);
for (int i = 0; i < 100; i++)
{
Document doc = new Document();
int term = i * 10; //terms are units of 10;
doc.Add(new Field(fieldName, "" + term, Field.Store.YES, Field.Index.NOT_ANALYZED));
w.AddDocument(doc);
}
w.Close();
IndexReader reader = IndexReader.Open(rd, true);
IndexSearcher searcher = new IndexSearcher(reader);
int numDocs = reader.NumDocs();
ScoreDoc[] results;
MatchAllDocsQuery q = new MatchAllDocsQuery();
System.Collections.ArrayList terms = new System.Collections.ArrayList();
terms.Add("5");
results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[])terms.ToArray(typeof(System.String))), numDocs).ScoreDocs;
Assert.AreEqual(0, results.Length, "Must match nothing");
terms = new System.Collections.ArrayList();
terms.Add("10");
results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[])terms.ToArray(typeof(System.String))), numDocs).ScoreDocs;
Assert.AreEqual(1, results.Length, "Must match 1");
terms = new System.Collections.ArrayList();
terms.Add("10");
terms.Add("20");
results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[])terms.ToArray(typeof(System.String))), numDocs).ScoreDocs;
Assert.AreEqual(2, results.Length, "Must match 2");
reader.Close();
rd.Close();
}
/// <summary> Extracts all terms texts of a given Query into an array of WeightedTerms
///
/// </summary>
/// <param name="query"> Query to extract term texts from
/// </param>
/// <param name="reader">used to compute IDF which can be used to a) score selected fragments better
/// b) use graded highlights eg chaning intensity of font color
/// </param>
/// <param name="fieldName">the field on which Inverse Document Frequency (IDF) calculations are based
/// </param>
/// <returns> an array of the terms used in a query, plus their weights.
/// </returns>
public static WeightedTerm[] GetIdfWeightedTerms(Query query, IndexReader reader, System.String fieldName)
{
WeightedTerm[] terms = GetTerms(query, false, fieldName);
int totalNumDocs = reader.NumDocs();
for (int i = 0; i < terms.Length; i++)
{
try
{
int docFreq = reader.DocFreq(new Term(fieldName, terms[i].term));
//IDF algorithm taken from DefaultSimilarity class
float idf = (float)(System.Math.Log((float)totalNumDocs / (double)(docFreq + 1)) + 1.0);
terms[i].weight *= idf;
}
catch (System.IO.IOException e)
{
//ignore
}
}
return(terms);
}
public virtual void TestRangeFilterIdCollating()
{
IndexReader reader = IndexReader.Open(signedIndex.index, true);
IndexSearcher search = new IndexSearcher(reader);
System.Globalization.CompareInfo c = new System.Globalization.CultureInfo("en").CompareInfo;
int medId = ((maxId - minId) / 2);
System.String minIP = Pad(minId);
System.String maxIP = Pad(maxId);
System.String medIP = Pad(medId);
int numDocs = reader.NumDocs();
Assert.AreEqual(numDocs, 1 + maxId - minId, "num of docs");
Query q = new TermQuery(new Term("body", "body"));
// test id, bounded on both ends
int numHits = search.Search(q, new TermRangeFilter("id", minIP, maxIP, T, T, c), 1000).TotalHits;
Assert.AreEqual(numDocs, numHits, "find all");
numHits = search.Search(q, new TermRangeFilter("id", minIP, maxIP, T, T, c), 1000).TotalHits;
Assert.AreEqual(numDocs, numHits, "find all");
numHits = search.Search(q, new TermRangeFilter("id", minIP, maxIP, T, F, c), 1000).TotalHits;
Assert.AreEqual(numDocs - 1, numHits, "all but last");
numHits = search.Search(q, new TermRangeFilter("id", minIP, maxIP, F, T, c), 1000).TotalHits;
Assert.AreEqual(numDocs - 1, numHits, "all but first");
numHits = search.Search(q, new TermRangeFilter("id", minIP, maxIP, F, F, c), 1000).TotalHits;
Assert.AreEqual(numDocs - 2, numHits, "all but ends");
numHits = search.Search(q, new TermRangeFilter("id", medIP, maxIP, T, T, c), 1000).TotalHits;
Assert.AreEqual(1 + maxId - medId, numHits, "med and up");
numHits = search.Search(q, new TermRangeFilter("id", minIP, medIP, T, T, c), 1000).TotalHits;
Assert.AreEqual(1 + medId - minId, numHits, "up to med");
// unbounded id
numHits = search.Search(q, new TermRangeFilter("id", minIP, null, T, F, c), 1000).TotalHits;
Assert.AreEqual(numDocs, numHits, "min and up");
numHits = search.Search(q, new TermRangeFilter("id", null, maxIP, F, T, c), 1000).TotalHits;
Assert.AreEqual(numDocs, numHits, "max and down");
numHits = search.Search(q, new TermRangeFilter("id", minIP, null, F, F, c), 1000).TotalHits;
Assert.AreEqual(numDocs - 1, numHits, "not min, but up");
numHits = search.Search(q, new TermRangeFilter("id", null, maxIP, F, F, c), 1000).TotalHits;
Assert.AreEqual(numDocs - 1, numHits, "not max, but down");
numHits = search.Search(q, new TermRangeFilter("id", medIP, maxIP, T, F, c), 1000).TotalHits;
Assert.AreEqual(maxId - medId, numHits, "med and up, not max");
numHits = search.Search(q, new TermRangeFilter("id", minIP, medIP, F, T, c), 1000).TotalHits;
Assert.AreEqual(medId - minId, numHits, "not min, up to med");
// very small sets
numHits = search.Search(q, new TermRangeFilter("id", minIP, minIP, F, F, c), 1000).TotalHits;
Assert.AreEqual(0, numHits, "min,min,F,F");
numHits = search.Search(q, new TermRangeFilter("id", medIP, medIP, F, F, c), 1000).TotalHits;
Assert.AreEqual(0, numHits, "med,med,F,F");
numHits = search.Search(q, new TermRangeFilter("id", maxIP, maxIP, F, F, c), 1000).TotalHits;
Assert.AreEqual(0, numHits, "max,max,F,F");
numHits = search.Search(q, new TermRangeFilter("id", minIP, minIP, T, T, c), 1000).TotalHits;
Assert.AreEqual(1, numHits, "min,min,T,T");
numHits = search.Search(q, new TermRangeFilter("id", null, minIP, F, T, c), 1000).TotalHits;
Assert.AreEqual(1, numHits, "nul,min,F,T");
numHits = search.Search(q, new TermRangeFilter("id", maxIP, maxIP, T, T, c), 1000).TotalHits;
Assert.AreEqual(1, numHits, "max,max,T,T");
numHits = search.Search(q, new TermRangeFilter("id", maxIP, null, T, F, c), 1000).TotalHits;
Assert.AreEqual(1, numHits, "max,nul,T,T");
numHits = search.Search(q, new TermRangeFilter("id", medIP, medIP, T, T, c), 1000).TotalHits;
Assert.AreEqual(1, numHits, "med,med,T,T");
}
public virtual void TestBinaryFieldInIndex()
{
Fieldable binaryFldStored = new Field("binaryStored", System.Text.UTF8Encoding.UTF8.GetBytes(binaryValStored), Field.Store.YES);
Fieldable binaryFldCompressed = new Field("binaryCompressed", System.Text.UTF8Encoding.UTF8.GetBytes(binaryValCompressed), Field.Store.COMPRESS);
Fieldable stringFldStored = new Field("stringStored", binaryValStored, Field.Store.YES, Field.Index.NO, Field.TermVector.NO);
Fieldable stringFldCompressed = new Field("stringCompressed", binaryValCompressed, Field.Store.COMPRESS, Field.Index.NO, Field.TermVector.NO);
try
{
// binary fields with store off are not allowed
new Field("fail", System.Text.UTF8Encoding.UTF8.GetBytes(binaryValCompressed), Field.Store.NO);
Assert.Fail();
}
catch (System.ArgumentException iae)
{
;
}
Document doc = new Document();
doc.Add(binaryFldStored);
doc.Add(binaryFldCompressed);
doc.Add(stringFldStored);
doc.Add(stringFldCompressed);
/** test for field count */
Assert.AreEqual(4, doc.fields_ForNUnit.Count);
/** add the doc to a ram index */
MockRAMDirectory dir = new MockRAMDirectory();
IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
writer.AddDocument(doc);
writer.Close();
/** open a reader and fetch the document */
IndexReader reader = IndexReader.Open(dir);
Document docFromReader = reader.Document(0);
Assert.IsTrue(docFromReader != null);
/** fetch the binary stored field and compare it's content with the original one */
System.String binaryFldStoredTest = new System.String(System.Text.UTF8Encoding.UTF8.GetChars(docFromReader.GetBinaryValue("binaryStored")));
Assert.IsTrue(binaryFldStoredTest.Equals(binaryValStored));
/** fetch the binary compressed field and compare it's content with the original one */
System.String binaryFldCompressedTest = new System.String(System.Text.UTF8Encoding.UTF8.GetChars(docFromReader.GetBinaryValue("binaryCompressed")));
Assert.IsTrue(binaryFldCompressedTest.Equals(binaryValCompressed));
/** fetch the string field and compare it's content with the original one */
System.String stringFldStoredTest = docFromReader.Get("stringStored");
Assert.IsTrue(stringFldStoredTest.Equals(binaryValStored));
/** fetch the compressed string field and compare it's content with the original one */
System.String stringFldCompressedTest = docFromReader.Get("stringCompressed");
Assert.IsTrue(stringFldCompressedTest.Equals(binaryValCompressed));
/** delete the document from index */
reader.DeleteDocument(0);
Assert.AreEqual(0, reader.NumDocs());
reader.Close();
dir.Close();
}
public virtual void TestRangeQueryId()
{
// NOTE: uses index build in *super* setUp
IndexReader reader = IndexReader.Open(signedIndex.index);
IndexSearcher search = new IndexSearcher(reader);
int medId = ((maxId - minId) / 2);
System.String minIP = Pad(minId);
System.String maxIP = Pad(maxId);
System.String medIP = Pad(medId);
int numDocs = reader.NumDocs();
AssertEquals("num of docs", numDocs, 1 + maxId - minId);
ScoreDoc[] result;
// test id, bounded on both ends
result = search.Search(Csrq("id", minIP, maxIP, T, T), null, numDocs).scoreDocs;
AssertEquals("find all", numDocs, result.Length);
result = search.Search(Csrq("id", minIP, maxIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("find all", numDocs, result.Length);
result = search.Search(Csrq("id", minIP, maxIP, T, F), null, numDocs).scoreDocs;
AssertEquals("all but last", numDocs - 1, result.Length);
result = search.Search(Csrq("id", minIP, maxIP, T, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("all but last", numDocs - 1, result.Length);
result = search.Search(Csrq("id", minIP, maxIP, F, T), null, numDocs).scoreDocs;
AssertEquals("all but first", numDocs - 1, result.Length);
result = search.Search(Csrq("id", minIP, maxIP, F, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("all but first", numDocs - 1, result.Length);
result = search.Search(Csrq("id", minIP, maxIP, F, F), null, numDocs).scoreDocs;
AssertEquals("all but ends", numDocs - 2, result.Length);
result = search.Search(Csrq("id", minIP, maxIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("all but ends", numDocs - 2, result.Length);
result = search.Search(Csrq("id", medIP, maxIP, T, T), null, numDocs).scoreDocs;
AssertEquals("med and up", 1 + maxId - medId, result.Length);
result = search.Search(Csrq("id", medIP, maxIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("med and up", 1 + maxId - medId, result.Length);
result = search.Search(Csrq("id", minIP, medIP, T, T), null, numDocs).scoreDocs;
AssertEquals("up to med", 1 + medId - minId, result.Length);
result = search.Search(Csrq("id", minIP, medIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("up to med", 1 + medId - minId, result.Length);
// unbounded id
result = search.Search(Csrq("id", minIP, null, T, F), null, numDocs).scoreDocs;
AssertEquals("min and up", numDocs, result.Length);
result = search.Search(Csrq("id", null, maxIP, F, T), null, numDocs).scoreDocs;
AssertEquals("max and down", numDocs, result.Length);
result = search.Search(Csrq("id", minIP, null, F, F), null, numDocs).scoreDocs;
AssertEquals("not min, but up", numDocs - 1, result.Length);
result = search.Search(Csrq("id", null, maxIP, F, F), null, numDocs).scoreDocs;
AssertEquals("not max, but down", numDocs - 1, result.Length);
result = search.Search(Csrq("id", medIP, maxIP, T, F), null, numDocs).scoreDocs;
AssertEquals("med and up, not max", maxId - medId, result.Length);
result = search.Search(Csrq("id", minIP, medIP, F, T), null, numDocs).scoreDocs;
AssertEquals("not min, up to med", medId - minId, result.Length);
// very small sets
result = search.Search(Csrq("id", minIP, minIP, F, F), null, numDocs).scoreDocs;
AssertEquals("min,min,F,F", 0, result.Length);
result = search.Search(Csrq("id", minIP, minIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("min,min,F,F", 0, result.Length);
result = search.Search(Csrq("id", medIP, medIP, F, F), null, numDocs).scoreDocs;
AssertEquals("med,med,F,F", 0, result.Length);
result = search.Search(Csrq("id", medIP, medIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("med,med,F,F", 0, result.Length);
result = search.Search(Csrq("id", maxIP, maxIP, F, F), null, numDocs).scoreDocs;
AssertEquals("max,max,F,F", 0, result.Length);
result = search.Search(Csrq("id", maxIP, maxIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("max,max,F,F", 0, result.Length);
result = search.Search(Csrq("id", minIP, minIP, T, T), null, numDocs).scoreDocs;
AssertEquals("min,min,T,T", 1, result.Length);
result = search.Search(Csrq("id", minIP, minIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("min,min,T,T", 1, result.Length);
result = search.Search(Csrq("id", null, minIP, F, T), null, numDocs).scoreDocs;
AssertEquals("nul,min,F,T", 1, result.Length);
result = search.Search(Csrq("id", null, minIP, F, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("nul,min,F,T", 1, result.Length);
result = search.Search(Csrq("id", maxIP, maxIP, T, T), null, numDocs).scoreDocs;
AssertEquals("max,max,T,T", 1, result.Length);
result = search.Search(Csrq("id", maxIP, maxIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("max,max,T,T", 1, result.Length);
result = search.Search(Csrq("id", maxIP, null, T, F), null, numDocs).scoreDocs;
AssertEquals("max,nul,T,T", 1, result.Length);
result = search.Search(Csrq("id", maxIP, null, T, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("max,nul,T,T", 1, result.Length);
result = search.Search(Csrq("id", medIP, medIP, T, T), null, numDocs).scoreDocs;
AssertEquals("med,med,T,T", 1, result.Length);
result = search.Search(Csrq("id", medIP, medIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
AssertEquals("med,med,T,T", 1, result.Length);
}
public virtual void TestFieldCacheRangeFilterLongs()
{
IndexReader reader = IndexReader.Open(signedIndex.index);
IndexSearcher search = new IndexSearcher(reader);
int numDocs = reader.NumDocs();
int medId = ((maxId - minId) / 2);
System.Int64 minIdO = (long)minId;
System.Int64 maxIdO = (long)maxId;
System.Int64 medIdO = (long)medId;
Assert.AreEqual(numDocs, 1 + maxId - minId, "num of docs");
ScoreDoc[] result;
Query q = new TermQuery(new Term("body", "body"));
// test id, bounded on both ends
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, T, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but last");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, F, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but first");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 2, result.Length, "all but ends");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, maxIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1 + maxId - medId, result.Length, "med and up");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, medIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1 + medId - minId, result.Length, "up to med");
// unbounded id
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, null, T, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, null, T, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "min and up");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, maxIdO, F, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "max and down");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, null, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not min, but up");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, maxIdO, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not max, but down");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, maxIdO, T, F), numDocs).ScoreDocs;
Assert.AreEqual(maxId - medId, result.Length, "med and up, not max");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, medIdO, F, T), numDocs).ScoreDocs;
Assert.AreEqual(medId - minId, result.Length, "not min, up to med");
// very small sets
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, minIdO, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "min,min,F,F");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, medIdO, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "med,med,F,F");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, maxIdO, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "max,max,F,F");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, minIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "min,min,T,T");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, minIdO, F, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "nul,min,F,T");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, maxIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "max,max,T,T");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, null, T, F), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "max,nul,T,T");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, medIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "med,med,T,T");
// special cases
System.Int64 tempAux = (long)System.Int64.MaxValue;
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", tempAux, null, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "overflow special case");
System.Int64 tempAux2 = (long)System.Int64.MinValue;
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, tempAux2, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "overflow special case");
result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, minIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "inverse range");
}
public static void Main(System.String[] a)
{
System.String indexName = "localhost_index";
System.String fn = "c:/Program Files/Apache Group/Apache/htdocs/manual/vhosts/index.html.en";
System.Uri url = null;
for (int i = 0; i < a.Length; i++)
{
if (a[i].Equals("-i"))
{
indexName = a[++i];
}
else if (a[i].Equals("-f"))
{
fn = a[++i];
}
else if (a[i].Equals("-url"))
{
url = new System.Uri(a[++i]);
}
}
System.IO.StreamWriter temp_writer;
temp_writer = new System.IO.StreamWriter(System.Console.OpenStandardOutput(), System.Console.Out.Encoding);
temp_writer.AutoFlush = true;
System.IO.StreamWriter o = temp_writer;
IndexReader r = IndexReader.Open(indexName);
o.WriteLine("Open index " + indexName + " which has " + r.NumDocs() + " docs");
MoreLikeThis mlt = new MoreLikeThis(r);
o.WriteLine("Query generation parameters:");
o.WriteLine(mlt.DescribeParams());
o.WriteLine();
Query query = null;
if (url != null)
{
o.WriteLine("Parsing URL: " + url);
query = mlt.Like(url);
}
else if (fn != null)
{
o.WriteLine("Parsing file: " + fn);
query = mlt.Like(new System.IO.FileInfo(fn));
}
o.WriteLine("q: " + query);
o.WriteLine();
IndexSearcher searcher = new IndexSearcher(indexName);
Hits hits = searcher.Search(query);
int len = hits.Length();
o.WriteLine("found: " + len + " documents matching");
o.WriteLine();
for (int i = 0; i < System.Math.Min(25, len); i++)
{
Document d = hits.Doc(i);
System.String summary = d.Get("summary");
o.WriteLine("score : " + hits.Score(i));
o.WriteLine("url : " + d.Get("url"));
o.WriteLine("\ttitle : " + d.Get("title"));
if (summary != null)
{
o.WriteLine("\tsummary: " + d.Get("summary"));
}
o.WriteLine();
}
}
public virtual void TestRangeQueryIdCollating()
{
// NOTE: uses index build in *super* setUp
IndexReader reader = IndexReader.Open(signedIndex.index);
IndexSearcher search = new IndexSearcher(reader);
int medId = ((maxId - minId) / 2);
System.String minIP = Pad(minId);
System.String maxIP = Pad(maxId);
System.String medIP = Pad(medId);
int numDocs = reader.NumDocs();
AssertEquals("num of docs", numDocs, 1 + maxId - minId);
ScoreDoc[] result;
System.Globalization.CompareInfo c = new System.Globalization.CultureInfo("en").CompareInfo;
// test id, bounded on both ends
result = search.Search(Csrq("id", minIP, maxIP, T, T, c), null, numDocs).scoreDocs;
AssertEquals("find all", numDocs, result.Length);
result = search.Search(Csrq("id", minIP, maxIP, T, F, c), null, numDocs).scoreDocs;
AssertEquals("all but last", numDocs - 1, result.Length);
result = search.Search(Csrq("id", minIP, maxIP, F, T, c), null, numDocs).scoreDocs;
AssertEquals("all but first", numDocs - 1, result.Length);
result = search.Search(Csrq("id", minIP, maxIP, F, F, c), null, numDocs).scoreDocs;
AssertEquals("all but ends", numDocs - 2, result.Length);
result = search.Search(Csrq("id", medIP, maxIP, T, T, c), null, numDocs).scoreDocs;
AssertEquals("med and up", 1 + maxId - medId, result.Length);
result = search.Search(Csrq("id", minIP, medIP, T, T, c), null, numDocs).scoreDocs;
AssertEquals("up to med", 1 + medId - minId, result.Length);
// unbounded id
result = search.Search(Csrq("id", minIP, null, T, F, c), null, numDocs).scoreDocs;
AssertEquals("min and up", numDocs, result.Length);
result = search.Search(Csrq("id", null, maxIP, F, T, c), null, numDocs).scoreDocs;
AssertEquals("max and down", numDocs, result.Length);
result = search.Search(Csrq("id", minIP, null, F, F, c), null, numDocs).scoreDocs;
AssertEquals("not min, but up", numDocs - 1, result.Length);
result = search.Search(Csrq("id", null, maxIP, F, F, c), null, numDocs).scoreDocs;
AssertEquals("not max, but down", numDocs - 1, result.Length);
result = search.Search(Csrq("id", medIP, maxIP, T, F, c), null, numDocs).scoreDocs;
AssertEquals("med and up, not max", maxId - medId, result.Length);
result = search.Search(Csrq("id", minIP, medIP, F, T, c), null, numDocs).scoreDocs;
AssertEquals("not min, up to med", medId - minId, result.Length);
// very small sets
result = search.Search(Csrq("id", minIP, minIP, F, F, c), null, numDocs).scoreDocs;
AssertEquals("min,min,F,F,c", 0, result.Length);
result = search.Search(Csrq("id", medIP, medIP, F, F, c), null, numDocs).scoreDocs;
AssertEquals("med,med,F,F,c", 0, result.Length);
result = search.Search(Csrq("id", maxIP, maxIP, F, F, c), null, numDocs).scoreDocs;
AssertEquals("max,max,F,F,c", 0, result.Length);
result = search.Search(Csrq("id", minIP, minIP, T, T, c), null, numDocs).scoreDocs;
AssertEquals("min,min,T,T,c", 1, result.Length);
result = search.Search(Csrq("id", null, minIP, F, T, c), null, numDocs).scoreDocs;
AssertEquals("nul,min,F,T,c", 1, result.Length);
result = search.Search(Csrq("id", maxIP, maxIP, T, T, c), null, numDocs).scoreDocs;
AssertEquals("max,max,T,T,c", 1, result.Length);
result = search.Search(Csrq("id", maxIP, null, T, F, c), null, numDocs).scoreDocs;
AssertEquals("max,nul,T,T,c", 1, result.Length);
result = search.Search(Csrq("id", medIP, medIP, T, T, c), null, numDocs).scoreDocs;
AssertEquals("med,med,T,T,c", 1, result.Length);
}
public virtual void TestRangeQueryRand()
{
// NOTE: uses index build in *super* setUp
IndexReader reader = IndexReader.Open(signedIndex.index);
IndexSearcher search = new IndexSearcher(reader);
System.String minRP = Pad(signedIndex.minR);
System.String maxRP = Pad(signedIndex.maxR);
int numDocs = reader.NumDocs();
AssertEquals("num of docs", numDocs, 1 + maxId - minId);
ScoreDoc[] result;
// test extremes, bounded on both ends
result = search.Search(Csrq("rand", minRP, maxRP, T, T), null, numDocs).scoreDocs;
AssertEquals("find all", numDocs, result.Length);
result = search.Search(Csrq("rand", minRP, maxRP, T, F), null, numDocs).scoreDocs;
AssertEquals("all but biggest", numDocs - 1, result.Length);
result = search.Search(Csrq("rand", minRP, maxRP, F, T), null, numDocs).scoreDocs;
AssertEquals("all but smallest", numDocs - 1, result.Length);
result = search.Search(Csrq("rand", minRP, maxRP, F, F), null, numDocs).scoreDocs;
AssertEquals("all but extremes", numDocs - 2, result.Length);
// unbounded
result = search.Search(Csrq("rand", minRP, null, T, F), null, numDocs).scoreDocs;
AssertEquals("smallest and up", numDocs, result.Length);
result = search.Search(Csrq("rand", null, maxRP, F, T), null, numDocs).scoreDocs;
AssertEquals("biggest and down", numDocs, result.Length);
result = search.Search(Csrq("rand", minRP, null, F, F), null, numDocs).scoreDocs;
AssertEquals("not smallest, but up", numDocs - 1, result.Length);
result = search.Search(Csrq("rand", null, maxRP, F, F), null, numDocs).scoreDocs;
AssertEquals("not biggest, but down", numDocs - 1, result.Length);
// very small sets
result = search.Search(Csrq("rand", minRP, minRP, F, F), null, numDocs).scoreDocs;
AssertEquals("min,min,F,F", 0, result.Length);
result = search.Search(Csrq("rand", maxRP, maxRP, F, F), null, numDocs).scoreDocs;
AssertEquals("max,max,F,F", 0, result.Length);
result = search.Search(Csrq("rand", minRP, minRP, T, T), null, numDocs).scoreDocs;
AssertEquals("min,min,T,T", 1, result.Length);
result = search.Search(Csrq("rand", null, minRP, F, T), null, numDocs).scoreDocs;
AssertEquals("nul,min,F,T", 1, result.Length);
result = search.Search(Csrq("rand", maxRP, maxRP, T, T), null, numDocs).scoreDocs;
AssertEquals("max,max,T,T", 1, result.Length);
result = search.Search(Csrq("rand", maxRP, null, T, F), null, numDocs).scoreDocs;
AssertEquals("max,nul,T,T", 1, result.Length);
}
public virtual void TestRangeFilterRandCollating()
{
// using the unsigned index because collation seems to ignore hyphens
IndexReader reader = IndexReader.Open(unsignedIndex.index, true);
IndexSearcher search = new IndexSearcher(reader);
System.Globalization.CompareInfo c = new System.Globalization.CultureInfo("en").CompareInfo;
System.String minRP = Pad(unsignedIndex.minR);
System.String maxRP = Pad(unsignedIndex.maxR);
int numDocs = reader.NumDocs();
Assert.AreEqual(numDocs, 1 + maxId - minId, "num of docs");
Query q = new TermQuery(new Term("body", "body"));
// test extremes, bounded on both ends
int numHits = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, T, T, c), 1000).TotalHits;
Assert.AreEqual(numDocs, numHits, "find all");
numHits = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, T, F, c), 1000).TotalHits;
Assert.AreEqual(numDocs - 1, numHits, "all but biggest");
numHits = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, F, T, c), 1000).TotalHits;
Assert.AreEqual(numDocs - 1, numHits, "all but smallest");
numHits = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, F, F, c), 1000).TotalHits;
Assert.AreEqual(numDocs - 2, numHits, "all but extremes");
// unbounded
numHits = search.Search(q, new TermRangeFilter("rand", minRP, null, T, F, c), 1000).TotalHits;
Assert.AreEqual(numDocs, numHits, "smallest and up");
numHits = search.Search(q, new TermRangeFilter("rand", null, maxRP, F, T, c), 1000).TotalHits;
Assert.AreEqual(numDocs, numHits, "biggest and down");
numHits = search.Search(q, new TermRangeFilter("rand", minRP, null, F, F, c), 1000).TotalHits;
Assert.AreEqual(numDocs - 1, numHits, "not smallest, but up");
numHits = search.Search(q, new TermRangeFilter("rand", null, maxRP, F, F, c), 1000).TotalHits;
Assert.AreEqual(numDocs - 1, numHits, "not biggest, but down");
// very small sets
numHits = search.Search(q, new TermRangeFilter("rand", minRP, minRP, F, F, c), 1000).TotalHits;
Assert.AreEqual(0, numHits, "min,min,F,F");
numHits = search.Search(q, new TermRangeFilter("rand", maxRP, maxRP, F, F, c), 1000).TotalHits;
Assert.AreEqual(0, numHits, "max,max,F,F");
numHits = search.Search(q, new TermRangeFilter("rand", minRP, minRP, T, T, c), 1000).TotalHits;
Assert.AreEqual(1, numHits, "min,min,T,T");
numHits = search.Search(q, new TermRangeFilter("rand", null, minRP, F, T, c), 1000).TotalHits;
Assert.AreEqual(1, numHits, "nul,min,F,T");
numHits = search.Search(q, new TermRangeFilter("rand", maxRP, maxRP, T, T, c), 1000).TotalHits;
Assert.AreEqual(1, numHits, "max,max,T,T");
numHits = search.Search(q, new TermRangeFilter("rand", maxRP, null, T, F, c), 1000).TotalHits;
Assert.AreEqual(1, numHits, "max,nul,T,T");
}
public virtual void TestRangeQueryRandCollating()
{
// NOTE: uses index build in *super* setUp
// using the unsigned index because collation seems to ignore hyphens
IndexReader reader = IndexReader.Open(unsignedIndex.index);
IndexSearcher search = new IndexSearcher(reader);
System.String minRP = Pad(unsignedIndex.minR);
System.String maxRP = Pad(unsignedIndex.maxR);
int numDocs = reader.NumDocs();
AssertEquals("num of docs", numDocs, 1 + maxId - minId);
ScoreDoc[] result;
System.Globalization.CompareInfo c = new System.Globalization.CultureInfo("en").CompareInfo;
// test extremes, bounded on both ends
result = search.Search(Csrq("rand", minRP, maxRP, T, T, c), null, numDocs).scoreDocs;
AssertEquals("find all", numDocs, result.Length);
result = search.Search(Csrq("rand", minRP, maxRP, T, F, c), null, numDocs).scoreDocs;
AssertEquals("all but biggest", numDocs - 1, result.Length);
result = search.Search(Csrq("rand", minRP, maxRP, F, T, c), null, numDocs).scoreDocs;
AssertEquals("all but smallest", numDocs - 1, result.Length);
result = search.Search(Csrq("rand", minRP, maxRP, F, F, c), null, numDocs).scoreDocs;
AssertEquals("all but extremes", numDocs - 2, result.Length);
// unbounded
result = search.Search(Csrq("rand", minRP, null, T, F, c), null, numDocs).scoreDocs;
AssertEquals("smallest and up", numDocs, result.Length);
result = search.Search(Csrq("rand", null, maxRP, F, T, c), null, numDocs).scoreDocs;
AssertEquals("biggest and down", numDocs, result.Length);
result = search.Search(Csrq("rand", minRP, null, F, F, c), null, numDocs).scoreDocs;
AssertEquals("not smallest, but up", numDocs - 1, result.Length);
result = search.Search(Csrq("rand", null, maxRP, F, F, c), null, numDocs).scoreDocs;
AssertEquals("not biggest, but down", numDocs - 1, result.Length);
// very small sets
result = search.Search(Csrq("rand", minRP, minRP, F, F, c), null, numDocs).scoreDocs;
AssertEquals("min,min,F,F,c", 0, result.Length);
result = search.Search(Csrq("rand", maxRP, maxRP, F, F, c), null, numDocs).scoreDocs;
AssertEquals("max,max,F,F,c", 0, result.Length);
result = search.Search(Csrq("rand", minRP, minRP, T, T, c), null, numDocs).scoreDocs;
AssertEquals("min,min,T,T,c", 1, result.Length);
result = search.Search(Csrq("rand", null, minRP, F, T, c), null, numDocs).scoreDocs;
AssertEquals("nul,min,F,T,c", 1, result.Length);
result = search.Search(Csrq("rand", maxRP, maxRP, T, T, c), null, numDocs).scoreDocs;
AssertEquals("max,max,T,T,c", 1, result.Length);
result = search.Search(Csrq("rand", maxRP, null, T, F, c), null, numDocs).scoreDocs;
AssertEquals("max,nul,T,T,c", 1, result.Length);
}
public virtual Explanation Explain(IndexReader reader, int doc)
{
ComplexExplanation result = new ComplexExplanation();
result.SetDescription("weight(" + GetQuery() + " in " + doc + "), product of:");
Explanation idfExpl = new Explanation(idf, "idf(docFreq=" + reader.DocFreq(Enclosing_Instance.term) + ", numDocs=" + reader.NumDocs() + ")");
// explain query weight
Explanation queryExpl = new Explanation();
queryExpl.SetDescription("queryWeight(" + GetQuery() + "), product of:");
Explanation boostExpl = new Explanation(Enclosing_Instance.GetBoost(), "boost");
if (Enclosing_Instance.GetBoost() != 1.0f)
queryExpl.AddDetail(boostExpl);
queryExpl.AddDetail(idfExpl);
Explanation queryNormExpl = new Explanation(queryNorm, "queryNorm");
queryExpl.AddDetail(queryNormExpl);
queryExpl.SetValue(boostExpl.GetValue() * idfExpl.GetValue() * queryNormExpl.GetValue());
result.AddDetail(queryExpl);
// explain field weight
System.String field = Enclosing_Instance.term.Field();
ComplexExplanation fieldExpl = new ComplexExplanation();
fieldExpl.SetDescription("fieldWeight(" + Enclosing_Instance.term + " in " + doc + "), product of:");
Explanation tfExpl = Scorer(reader).Explain(doc);
fieldExpl.AddDetail(tfExpl);
fieldExpl.AddDetail(idfExpl);
Explanation fieldNormExpl = new Explanation();
byte[] fieldNorms = reader.Norms(field);
float fieldNorm = fieldNorms != null ? Similarity.DecodeNorm(fieldNorms[doc]) : 0.0f;
fieldNormExpl.SetValue(fieldNorm);
fieldNormExpl.SetDescription("fieldNorm(field=" + field + ", doc=" + doc + ")");
fieldExpl.AddDetail(fieldNormExpl);
fieldExpl.SetMatch(tfExpl.IsMatch());
fieldExpl.SetValue(tfExpl.GetValue() * idfExpl.GetValue() * fieldNormExpl.GetValue());
result.AddDetail(fieldExpl);
System.Boolean tempAux = fieldExpl.GetMatch();
result.SetMatch(tempAux);
// combine them
result.SetValue(queryExpl.GetValue() * fieldExpl.GetValue());
if (queryExpl.GetValue() == 1.0f)
return fieldExpl;
return result;
}
public virtual void TestRangeFilterId()
{
IndexReader reader = IndexReader.Open(signedIndex.index, true);
IndexSearcher search = new IndexSearcher(reader);
int medId = ((maxId - minId) / 2);
System.String minIP = Pad(minId);
System.String maxIP = Pad(maxId);
System.String medIP = Pad(medId);
int numDocs = reader.NumDocs();
Assert.AreEqual(numDocs, 1 + maxId - minId, "num of docs");
ScoreDoc[] result;
Query q = new TermQuery(new Term("body", "body"));
// test id, bounded on both ends
result = search.Search(q, new TermRangeFilter("id", minIP, maxIP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
result = search.Search(q, new TermRangeFilter("id", minIP, maxIP, T, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but last");
result = search.Search(q, new TermRangeFilter("id", minIP, maxIP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but first");
result = search.Search(q, new TermRangeFilter("id", minIP, maxIP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 2, result.Length, "all but ends");
result = search.Search(q, new TermRangeFilter("id", medIP, maxIP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1 + maxId - medId, result.Length, "med and up");
result = search.Search(q, new TermRangeFilter("id", minIP, medIP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1 + medId - minId, result.Length, "up to med");
// unbounded id
result = search.Search(q, new TermRangeFilter("id", minIP, null, T, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "min and up");
result = search.Search(q, new TermRangeFilter("id", null, maxIP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "max and down");
result = search.Search(q, new TermRangeFilter("id", minIP, null, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not min, but up");
result = search.Search(q, new TermRangeFilter("id", null, maxIP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not max, but down");
result = search.Search(q, new TermRangeFilter("id", medIP, maxIP, T, F), numDocs).ScoreDocs;
Assert.AreEqual(maxId - medId, result.Length, "med and up, not max");
result = search.Search(q, new TermRangeFilter("id", minIP, medIP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(medId - minId, result.Length, "not min, up to med");
// very small sets
result = search.Search(q, new TermRangeFilter("id", minIP, minIP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "min,min,F,F");
result = search.Search(q, new TermRangeFilter("id", medIP, medIP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "med,med,F,F");
result = search.Search(q, new TermRangeFilter("id", maxIP, maxIP, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "max,max,F,F");
result = search.Search(q, new TermRangeFilter("id", minIP, minIP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "min,min,T,T");
result = search.Search(q, new TermRangeFilter("id", null, minIP, F, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "nul,min,F,T");
result = search.Search(q, new TermRangeFilter("id", maxIP, maxIP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "max,max,T,T");
result = search.Search(q, new TermRangeFilter("id", maxIP, null, T, F), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "max,nul,T,T");
result = search.Search(q, new TermRangeFilter("id", medIP, medIP, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "med,med,T,T");
}
public virtual Explanation Explain(IndexReader reader, int doc)
{
ComplexExplanation result = new ComplexExplanation();
result.SetDescription("weight(" + GetQuery() + " in " + doc + "), product of:");
Explanation idfExpl = new Explanation(idf, "idf(docFreq=" + reader.DocFreq(Enclosing_Instance.term) + ", numDocs=" + reader.NumDocs() + ")");
// explain query weight
Explanation queryExpl = new Explanation();
queryExpl.SetDescription("queryWeight(" + GetQuery() + "), product of:");
Explanation boostExpl = new Explanation(Enclosing_Instance.GetBoost(), "boost");
if (Enclosing_Instance.GetBoost() != 1.0f)
{
queryExpl.AddDetail(boostExpl);
}
queryExpl.AddDetail(idfExpl);
Explanation queryNormExpl = new Explanation(queryNorm, "queryNorm");
queryExpl.AddDetail(queryNormExpl);
queryExpl.SetValue(boostExpl.GetValue() * idfExpl.GetValue() * queryNormExpl.GetValue());
result.AddDetail(queryExpl);
// explain field weight
System.String field = Enclosing_Instance.term.Field();
ComplexExplanation fieldExpl = new ComplexExplanation();
fieldExpl.SetDescription("fieldWeight(" + Enclosing_Instance.term + " in " + doc + "), product of:");
Explanation tfExpl = Scorer(reader).Explain(doc);
fieldExpl.AddDetail(tfExpl);
fieldExpl.AddDetail(idfExpl);
Explanation fieldNormExpl = new Explanation();
byte[] fieldNorms = reader.Norms(field);
float fieldNorm = fieldNorms != null?Similarity.DecodeNorm(fieldNorms[doc]) : 0.0f;
fieldNormExpl.SetValue(fieldNorm);
fieldNormExpl.SetDescription("fieldNorm(field=" + field + ", doc=" + doc + ")");
fieldExpl.AddDetail(fieldNormExpl);
fieldExpl.SetMatch(tfExpl.IsMatch());
fieldExpl.SetValue(tfExpl.GetValue() * idfExpl.GetValue() * fieldNormExpl.GetValue());
result.AddDetail(fieldExpl);
System.Boolean tempAux = fieldExpl.GetMatch();
result.SetMatch(tempAux);
// combine them
result.SetValue(queryExpl.GetValue() * fieldExpl.GetValue());
if (queryExpl.GetValue() == 1.0f)
{
return(fieldExpl);
}
return(result);
}
