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);
AreEqual(3, hits.TotalHits);
AreEqual("3", r.Document(hits.ScoreDocs[0].Doc).Get("id"));
AreEqual("1", r.Document(hits.ScoreDocs[1].Doc).Get("id"));
AreEqual("2", r.Document(hits.ScoreDocs[2].Doc).Get("id"));
// Now, rescore:
Expression e = JavascriptCompiler.Compile("sqrt(_score) + ln(popularity)");
SimpleBindings bindings = new SimpleBindings();
bindings.Add(new SortField("popularity", SortField.Type_e.INT));
bindings.Add(new SortField("_score", SortField.Type_e.SCORE));
Rescorer rescorer = e.GetRescorer(bindings);
hits = rescorer.Rescore(searcher, hits, 10);
AreEqual(3, hits.TotalHits);
AreEqual("2", r.Document(hits.ScoreDocs[0].Doc).Get("id"));
AreEqual("1", r.Document(hits.ScoreDocs[1].Doc).Get("id"));
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
// variables:
IsTrue(expl.Contains("= variable \"popularity\""));
// Confirm the explanation includes first pass details:
IsTrue(expl.Contains("= first pass score"));
IsTrue(expl.Contains("body:contents in"));
}
public virtual void TestRangeScorer()
{
Expression expr = JavascriptCompiler.Compile("2*popularity");
SimpleBindings bindings = new SimpleBindings();
bindings.Add(new SortField("popularity", SortField.Type_e.LONG));
ValueSource vs = expr.GetValueSource(bindings);
AreEqual(1, reader.Leaves.Count);
AtomicReaderContext leaf = reader.Leaves[0];
FunctionValues values = vs.GetValues(new Dictionary <string, object>(), leaf);
// everything
ValueSourceScorer scorer = values.GetRangeScorer(leaf.Reader, "4"
, "40", true, true);
AreEqual(-1, scorer.DocID());
AreEqual(0, scorer.NextDoc());
AreEqual(1, scorer.NextDoc());
AreEqual(2, scorer.NextDoc());
AreEqual(DocIdSetIterator.NO_MORE_DOCS, scorer.NextDoc());
// just the first doc
scorer = values.GetRangeScorer(leaf.Reader, "4", "40", false, false);
AreEqual(-1, scorer.DocID());
AreEqual(0, scorer.NextDoc());
AreEqual(DocIdSetIterator.NO_MORE_DOCS, scorer.NextDoc());
}
public virtual void TestEquals()
{
Expression expr = JavascriptCompiler.Compile("sqrt(_score) + ln(popularity)");
SimpleBindings bindings = new SimpleBindings();
bindings.Add(new SortField("_score", SortField.Type_e.SCORE));
bindings.Add(new SortField("popularity", SortField.Type_e.INT));
SimpleBindings otherBindings = new SimpleBindings();
otherBindings.Add(new SortField("_score", SortField.Type_e.LONG));
otherBindings.Add(new SortField("popularity", SortField.Type_e.INT));
SortField sf1 = expr.GetSortField(bindings, true);
// different order
SortField sf2 = expr.GetSortField(bindings, false);
IsFalse(sf1.Equals(sf2));
// different bindings
sf2 = expr.GetSortField(otherBindings, true);
IsFalse(sf1.Equals(sf2));
// different expression
Expression other = JavascriptCompiler.Compile("popularity/2");
sf2 = other.GetSortField(bindings, true);
IsFalse(sf1.Equals(sf2));
// null
IsFalse(sf1.Equals(null));
// same instance:
AreEqual(sf1, sf1);
}
// TODO: ideally we'd test > Short.MAX_VALUE too, but compilation is currently recursive.
// so if we want to test such huge expressions, we need to instead change parser to use an explicit Stack
/// <exception cref="System.Exception"></exception>
private void DoTestLotsOfBindings(int n)
{
SimpleBindings bindings = new SimpleBindings();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i++)
{
if (i > 0)
{
sb.Append("+");
}
sb.Append("x" + i);
bindings.Add(new SortField("x" + i, SortField.Type_e.SCORE));
}
var expr = JavascriptCompiler.Compile(sb.ToString());
var sort = new Sort(expr.GetSortField(bindings, true));
Query query = new TermQuery(new Term("body", "contents"));
TopFieldDocs td = searcher.Search(query, null, 3, sort, true, true);
for (int i_1 = 0; i_1 < 3; i_1++)
{
FieldDoc d = (FieldDoc)td.ScoreDocs[i_1];
float expected = n * d.Score;
float actual = (float)((double)d.Fields[0]);
AreEqual(expected, actual, CheckHits.ExplainToleranceDelta(expected, actual));
}
}
/// <summary>User runs a query and aggregates facets.</summary>
private FacetResult Search()
{
using DirectoryReader indexReader = DirectoryReader.Open(indexDir);
using TaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoDir);
IndexSearcher searcher = new IndexSearcher(indexReader);
// Aggregate categories by an expression that combines the document's score
// and its popularity field
Expression expr = JavascriptCompiler.Compile("_score * sqrt(popularity)");
SimpleBindings bindings = new SimpleBindings
{
new SortField("_score", SortFieldType.SCORE), // the score of the document
new SortField("popularity", SortFieldType.INT64), // the value of the 'popularity' field
};
// Aggregates the facet values
FacetsCollector fc = new FacetsCollector(true);
// MatchAllDocsQuery is for "browsing" (counts facets
// for all non-deleted docs in the index); normally
// you'd use a "normal" query:
FacetsCollector.Search(searcher, new MatchAllDocsQuery(), 10, fc);
// Retrieve results
Facets facets = new TaxonomyFacetSumValueSource(taxoReader, config, fc, expr.GetValueSource(bindings));
FacetResult result = facets.GetTopChildren(10, "A");
return(result);
}
public virtual void TestToString()
{
Expression expr = JavascriptCompiler.Compile("sqrt(_score) + ln(popularity)");
SimpleBindings bindings = new SimpleBindings();
bindings.Add(new SortField("_score", SortField.Type_e.SCORE));
bindings.Add(new SortField("popularity", SortField.Type_e.INT));
SortField sf = expr.GetSortField(bindings, true);
AreEqual("<expr \"sqrt(_score) + ln(popularity)\">!", sf.ToString());
}
private ValueSource GetDistanceValueSource()
{
Expression distance = JavascriptCompiler.Compile(
string.Format(CultureInfo.InvariantCulture, "haversin({0:R},{1:R},latitude,longitude)", ORIGIN_LATITUDE, ORIGIN_LONGITUDE));
SimpleBindings bindings = new SimpleBindings();
bindings.Add(new SortField("latitude", SortFieldType.DOUBLE));
bindings.Add(new SortField("longitude", SortFieldType.DOUBLE));
return(distance.GetValueSource(bindings));
}
public virtual void TestSelfRecursion()
{
SimpleBindings bindings = new SimpleBindings();
bindings.Add("cycle0", JavascriptCompiler.Compile("cycle0"));
try
{
bindings.Validate();
Fail("didn't get expected exception");
}
catch (ArgumentException expected)
{
IsTrue(expected.Message.Contains("Cycle detected"));
}
}
public virtual void Test()
{
// compile an expression:
var expr = JavascriptCompiler.Compile("sqrt(_score) + ln(popularity)");
// we use SimpleBindings: which just maps variables to SortField instances
SimpleBindings bindings = new SimpleBindings();
bindings.Add(new SortField("_score", SortField.Type_e.SCORE));
bindings.Add(new SortField("popularity", SortField.Type_e.INT));
// create a sort field and sort by it (reverse order)
Sort sort = new Sort(expr.GetSortField(bindings, true));
Query query = new TermQuery(new Term("body", "contents"));
searcher.Search(query, null, 3, sort);
}
public virtual void TestInvalidExternal2()
{
SimpleBindings bindings = new SimpleBindings();
bindings.Add(new SortField("valid", SortField.Type_e.INT));
bindings.Add("invalid", JavascriptCompiler.Compile("valid + badreference"));
try
{
bindings.Validate();
Fail("didn't get expected exception");
}
catch (ArgumentException expected)
{
IsTrue(expected.Message.Contains("Invalid reference"));
}
}
public virtual void TestValidExternals()
{
SimpleBindings bindings = new SimpleBindings();
bindings.Add(new SortField("valid0", SortField.Type_e.INT));
bindings.Add(new SortField("valid1", SortField.Type_e.INT));
bindings.Add(new SortField("valid2", SortField.Type_e.INT));
bindings.Add(new SortField("_score", SortField.Type_e.SCORE));
bindings.Add("valide0", JavascriptCompiler.Compile("valid0 - valid1 + valid2 + _score"
));
bindings.Validate();
bindings.Add("valide1", JavascriptCompiler.Compile("valide0 + valid0"));
bindings.Validate();
bindings.Add("valide2", JavascriptCompiler.Compile("valide0 * valide1"));
bindings.Validate();
}
public virtual void TestDistanceSort()
{
var distance = JavascriptCompiler.Compile("haversin(40.7143528,-74.0059731,latitude,longitude)");
SimpleBindings bindings = new SimpleBindings();
bindings.Add(new SortField("latitude", SortField.Type_e.DOUBLE));
bindings.Add(new SortField("longitude", SortField.Type_e.DOUBLE));
Sort sort = new Sort(distance.GetSortField(bindings, false));
TopFieldDocs td = searcher.Search(new MatchAllDocsQuery(), null, 3, sort);
FieldDoc d = (FieldDoc)td.ScoreDocs[0];
AreEqual(0.4619D, (double)d.Fields[0], 1E-4);
d = (FieldDoc)td.ScoreDocs[1];
AreEqual(1.0546D, (double)d.Fields[0], 1E-4);
d = (FieldDoc)td.ScoreDocs[2];
AreEqual(5.2842D, (double)d.Fields[0], 1E-4);
}
public virtual void TestSortValues()
{
var expr = JavascriptCompiler.Compile("sqrt(_score)");
SimpleBindings bindings = new SimpleBindings();
bindings.Add(new SortField("_score", SortField.Type_e.SCORE));
Sort sort = new Sort(expr.GetSortField(bindings, true));
Query query = new TermQuery(new Term("body", "contents"));
TopFieldDocs td = searcher.Search(query, null, 3, sort, true, true);
for (int i = 0; i < 3; i++)
{
FieldDoc d = (FieldDoc)td.ScoreDocs[i];
float expected = (float)Math.Sqrt(d.Score);
float actual = (float)((double)d.Fields[0]);
AreEqual(expected, actual, CheckHits.ExplainToleranceDelta(expected, actual));
}
}
public virtual void TestNeedsScores()
{
SimpleBindings bindings = new SimpleBindings();
// refers to score directly
Expression exprA = JavascriptCompiler.Compile("_score");
// constant
Expression exprB = JavascriptCompiler.Compile("0");
// field
Expression exprC = JavascriptCompiler.Compile("intfield");
// score + constant
Expression exprD = JavascriptCompiler.Compile("_score + 0");
// field + constant
Expression exprE = JavascriptCompiler.Compile("intfield + 0");
// expression + constant (score ref'd)
Expression exprF = JavascriptCompiler.Compile("a + 0");
// expression + constant
Expression exprG = JavascriptCompiler.Compile("e + 0");
// several variables (score ref'd)
Expression exprH = JavascriptCompiler.Compile("b / c + e * g - sqrt(f)");
// several variables
Expression exprI = JavascriptCompiler.Compile("b / c + e * g");
bindings.Add(new SortField("_score", SortField.Type_e.SCORE));
bindings.Add(new SortField("intfield", SortField.Type_e.INT));
bindings.Add("a", exprA);
bindings.Add("b", exprB);
bindings.Add("c", exprC);
bindings.Add("d", exprD);
bindings.Add("e", exprE);
bindings.Add("f", exprF);
bindings.Add("g", exprG);
bindings.Add("h", exprH);
bindings.Add("i", exprI);
IsTrue(exprA.GetSortField(bindings, true).NeedsScores());
IsFalse(exprB.GetSortField(bindings, true).NeedsScores());
IsFalse(exprC.GetSortField(bindings, true).NeedsScores());
IsTrue(exprD.GetSortField(bindings, true).NeedsScores());
IsFalse(exprE.GetSortField(bindings, true).NeedsScores());
IsTrue(exprF.GetSortField(bindings, true).NeedsScores());
IsFalse(exprG.GetSortField(bindings, true).NeedsScores());
IsTrue(exprH.GetSortField(bindings, true).NeedsScores());
IsFalse(exprI.GetSortField(bindings, false).NeedsScores());
}
internal virtual void AssertQuery(Query query, Filter filter, Sort sort)
{
int size = TestUtil.NextInt(Random(), 1, searcher.IndexReader.MaxDoc / 5);
TopDocs expected = searcher.Search(query, filter, size, sort, Random().NextBoolean
(), Random().NextBoolean());
// make our actual sort, mutating original by replacing some of the
// sortfields with equivalent expressions
SortField[] original = sort.GetSort();
SortField[] mutated = new SortField[original.Length];
for (int i = 0; i < mutated.Length; i++)
{
if (Random().Next(3) > 0)
{
SortField s = original[i];
Expression expr = JavascriptCompiler.Compile(s.Field);
SimpleBindings simpleBindings = new SimpleBindings();
simpleBindings.Add(s);
bool reverse = s.Type == SortField.Type_e.SCORE || s.Reverse;
mutated[i] = expr.GetSortField(simpleBindings, reverse);
}
else
{
mutated[i] = original[i];
}
}
Sort mutatedSort = new Sort(mutated);
TopDocs actual = searcher.Search(query, filter, size, mutatedSort, Random().NextBoolean
(), Random().NextBoolean());
CheckHits.CheckEqual(query, expected.ScoreDocs, actual.ScoreDocs);
if (size < actual.TotalHits)
{
expected = searcher.SearchAfter(expected.ScoreDocs[size - 1], query, filter, size
, sort);
actual = searcher.SearchAfter(actual.ScoreDocs[size - 1], query, filter, size, mutatedSort
);
CheckHits.CheckEqual(query, expected.ScoreDocs, actual.ScoreDocs);
}
}
public virtual void TestEquals()
{
Expression expr = JavascriptCompiler.Compile("sqrt(a) + ln(b)");
SimpleBindings bindings = new SimpleBindings();
bindings.Add(new SortField("a", SortField.Type_e.INT));
bindings.Add(new SortField("b", SortField.Type_e.INT));
ValueSource vs1 = expr.GetValueSource(bindings);
// same instance
AreEqual(vs1, vs1);
// null
IsFalse(vs1.Equals(null));
// other object
IsFalse(vs1.Equals("foobar"));
// same bindings and expression instances
ValueSource vs2 = expr.GetValueSource(bindings);
AreEqual(vs1.GetHashCode(), vs2.GetHashCode());
AreEqual(vs1, vs2);
// equiv bindings (different instance)
SimpleBindings bindings2 = new SimpleBindings();
bindings2.Add(new SortField("a", SortField.Type_e.INT));
bindings2.Add(new SortField("b", SortField.Type_e.INT));
ValueSource vs3 = expr.GetValueSource(bindings2);
AreEqual(vs1, vs3);
// different bindings (same names, different types)
SimpleBindings bindings3 = new SimpleBindings();
bindings3.Add(new SortField("a", SortField.Type_e.LONG));
bindings3.Add(new SortField("b", SortField.Type_e.INT));
ValueSource vs4 = expr.GetValueSource(bindings3);
IsFalse(vs1.Equals(vs4));
}
public virtual void TestTypes()
{
Expression expr = JavascriptCompiler.Compile("2*popularity");
SimpleBindings bindings = new SimpleBindings();
bindings.Add(new SortField("popularity", SortField.Type_e.LONG));
ValueSource vs = expr.GetValueSource(bindings);
AreEqual(1, reader.Leaves.Count);
AtomicReaderContext leaf = reader.Leaves[0];
FunctionValues values = vs.GetValues(new Dictionary <string, object>(), leaf);
AreEqual(10, values.DoubleVal(0), 0);
AreEqual(10, values.FloatVal(0), 0);
AreEqual(10, values.LongVal(0));
AreEqual(10, values.IntVal(0));
AreEqual(10, values.ShortVal(0));
AreEqual(10, values.ByteVal(0));
AreEqual("10", values.StrVal(0));
AreEqual(System.Convert.ToDouble(10), values.ObjectVal(0));
AreEqual(40, values.DoubleVal(1), 0);
AreEqual(40, values.FloatVal(1), 0);
AreEqual(40, values.LongVal(1));
AreEqual(40, values.IntVal(1));
AreEqual(40, values.ShortVal(1));
AreEqual(40, values.ByteVal(1));
AreEqual("40", values.StrVal(1));
AreEqual(System.Convert.ToDouble(40), values.ObjectVal(1));
AreEqual(4, values.DoubleVal(2), 0);
AreEqual(4, values.FloatVal(2), 0);
AreEqual(4, values.LongVal(2));
AreEqual(4, values.IntVal(2));
AreEqual(4, values.ShortVal(2));
AreEqual(4, values.ByteVal(2));
AreEqual("4", values.StrVal(2));
AreEqual(System.Convert.ToDouble(4), values.ObjectVal(2));
}
