public static LuceneResultNode SearchEx(IndexBase index, SearchNode node)
{
try
{
var query = MultiFieldQueryParser.Parse(Lucene.Net.Util.Version.LUCENE_29, node.Queries, node.Fields, node.Occurs, new PanGuAnalyzer(true));
foreach (NumberRangeNode n in node.NumberRangeFiters)
{
query = new FilteredQuery(query, NumericRangeFilter.NewIntRange(n.FieldName, n.MinValue, n.MaxValue, true, true));
}
foreach (LongRangeNode lr in node.LongRnageFilters)
{
query = new FilteredQuery(query, NumericRangeFilter.NewLongRange(lr.FieldName, lr.MinValue, lr.MaxValue, true, true));
}
foreach (ContainFilterNode cf in node.ContainFilters)
{
query = new FilteredQuery(query, new ContainFilter(new Term(cf.FieldName, cf.Text)));
}
return(ResponseSearch(index, query, node, 0));
}
catch (Lucene.Net.QueryParsers.ParseException)
{
return(new LuceneResultNode()
{
AllCount = 0, Result = new List <string>()
});
}
catch (Exception ex)
{
throw ex;
}
}
public static Filter CreateRangeFilterForValue(string fieldName, string lower, string upper, bool includeLower, bool includeUpper)
{
Filter result = null;
// If both bounds are empty, ignore this range
if (!string.IsNullOrEmpty(lower) || !string.IsNullOrEmpty(upper))
{
var lowerLong = ConvertToDateTimeTicks(lower);
var upperLong = ConvertToDateTimeTicks(upper);
if (lowerLong != null || upperLong != null)
{
result = NumericRangeFilter.NewLongRange(fieldName, lowerLong, upperLong, includeLower, includeUpper);
}
else
{
var lowerDouble = ConvertToDouble(lower);
var upperDouble = ConvertToDouble(upper);
if (lowerDouble != null || upperDouble != null)
{
result = NumericRangeFilter.NewDoubleRange(fieldName, lowerDouble, upperDouble, includeLower, includeUpper);
}
else
{
result = new TermRangeFilter(fieldName, lower, upper, includeLower, includeUpper);
}
}
}
return(result);
}
public virtual Filter GetFilter(XmlElement e)
{
string field = DOMUtils.GetAttributeWithInheritanceOrFail(e, "fieldName");
string lowerTerm = DOMUtils.GetAttributeOrFail(e, "lowerTerm");
string upperTerm = DOMUtils.GetAttributeOrFail(e, "upperTerm");
bool lowerInclusive = DOMUtils.GetAttribute(e, "includeLower", true);
bool upperInclusive = DOMUtils.GetAttribute(e, "includeUpper", true);
int precisionStep = DOMUtils.GetAttribute(e, "precisionStep", NumericUtils.PRECISION_STEP_DEFAULT);
string type = DOMUtils.GetAttribute(e, "type", "int");
try
{
Filter filter;
if (type.Equals("int", StringComparison.OrdinalIgnoreCase))
{
filter = NumericRangeFilter.NewIntRange(field, precisionStep, Convert.ToInt32(lowerTerm), Convert.ToInt32(upperTerm), lowerInclusive,
upperInclusive);
}
else if (type.Equals("long", StringComparison.OrdinalIgnoreCase))
{
filter = NumericRangeFilter.NewLongRange(field, precisionStep, Convert
.ToInt64(lowerTerm), Convert.ToInt64(upperTerm), lowerInclusive,
upperInclusive);
}
else if (type.Equals("double", StringComparison.OrdinalIgnoreCase))
{
filter = NumericRangeFilter.NewDoubleRange(field, precisionStep, Convert
.ToDouble(lowerTerm), Convert.ToDouble(upperTerm), lowerInclusive,
upperInclusive);
}
else if (type.Equals("float", StringComparison.OrdinalIgnoreCase))
{
filter = NumericRangeFilter.NewFloatRange(field, precisionStep, Convert
.ToSingle(lowerTerm), Convert.ToSingle(upperTerm), lowerInclusive,
upperInclusive);
}
else
{
throw new ParserException("type attribute must be one of: [long, int, double, float]");
}
return(filter);
}
catch (FormatException nfe)
{
if (strictMode)
{
throw new ParserException("Could not parse lowerTerm or upperTerm into a number", nfe);
}
return(NO_MATCH_FILTER);
}
}
public virtual void TestRandomLongs()
{
Directory dir = NewDirectory();
var w = new RandomIndexWriter(Random(), dir, Similarity, TimeZone);
int numDocs = AtLeast(1000);
if (VERBOSE)
{
Console.WriteLine("TEST: numDocs=" + numDocs);
}
long[] values = new long[numDocs];
long minValue = long.MaxValue;
long maxValue = long.MinValue;
for (int i = 0; i < numDocs; i++)
{
Document doc = new Document();
long v = Random().NextLong();
values[i] = v;
doc.Add(new NumericDocValuesField("field", v));
doc.Add(new LongField("field", v, Field.Store.NO));
w.AddDocument(doc);
minValue = Math.Min(minValue, v);
maxValue = Math.Max(maxValue, v);
}
IndexReader r = w.Reader;
IndexSearcher s = NewSearcher(r);
FacetsConfig config = new FacetsConfig();
int numIters = AtLeast(10);
for (int iter = 0; iter < numIters; iter++)
{
if (VERBOSE)
{
Console.WriteLine("TEST: iter=" + iter);
}
int numRange = TestUtil.NextInt(Random(), 1, 100);
LongRange[] ranges = new LongRange[numRange];
int[] expectedCounts = new int[numRange];
long minAcceptedValue = long.MaxValue;
long maxAcceptedValue = long.MinValue;
for (int rangeID = 0; rangeID < numRange; rangeID++)
{
long min;
if (rangeID > 0 && Random().Next(10) == 7)
{
// Use an existing boundary:
LongRange prevRange = ranges[Random().Next(rangeID)];
if (Random().NextBoolean())
{
min = prevRange.min;
}
else
{
min = prevRange.max;
}
}
else
{
min = Random().NextLong();
}
long max;
if (rangeID > 0 && Random().Next(10) == 7)
{
// Use an existing boundary:
LongRange prevRange = ranges[Random().Next(rangeID)];
if (Random().NextBoolean())
{
max = prevRange.min;
}
else
{
max = prevRange.max;
}
}
else
{
max = Random().NextLong();
}
if (min > max)
{
long x = min;
min = max;
max = x;
}
bool minIncl;
bool maxIncl;
if (min == max)
{
minIncl = true;
maxIncl = true;
}
else
{
minIncl = Random().NextBoolean();
maxIncl = Random().NextBoolean();
}
ranges[rangeID] = new LongRange("r" + rangeID, min, minIncl, max, maxIncl);
if (VERBOSE)
{
Console.WriteLine(" range " + rangeID + ": " + ranges[rangeID]);
}
// Do "slow but hopefully correct" computation of
// expected count:
for (int i = 0; i < numDocs; i++)
{
bool accept = true;
if (minIncl)
{
accept &= values[i] >= min;
}
else
{
accept &= values[i] > min;
}
if (maxIncl)
{
accept &= values[i] <= max;
}
else
{
accept &= values[i] < max;
}
if (accept)
{
expectedCounts[rangeID]++;
minAcceptedValue = Math.Min(minAcceptedValue, values[i]);
maxAcceptedValue = Math.Max(maxAcceptedValue, values[i]);
}
}
}
FacetsCollector sfc = new FacetsCollector();
s.Search(new MatchAllDocsQuery(), sfc);
Filter fastMatchFilter;
if (Random().NextBoolean())
{
if (Random().NextBoolean())
{
fastMatchFilter = NumericRangeFilter.NewLongRange("field", minValue, maxValue, true, true);
}
else
{
fastMatchFilter = NumericRangeFilter.NewLongRange("field", minAcceptedValue, maxAcceptedValue, true, true);
}
}
else
{
fastMatchFilter = null;
}
ValueSource vs = new LongFieldSource("field");
Facets facets = new LongRangeFacetCounts("field", vs, sfc, fastMatchFilter, ranges);
FacetResult result = facets.GetTopChildren(10, "field");
Assert.AreEqual(numRange, result.LabelValues.Length);
for (int rangeID = 0; rangeID < numRange; rangeID++)
{
if (VERBOSE)
{
Console.WriteLine(" range " + rangeID + " expectedCount=" + expectedCounts[rangeID]);
}
LabelAndValue subNode = result.LabelValues[rangeID];
Assert.AreEqual("r" + rangeID, subNode.label);
Assert.AreEqual(expectedCounts[rangeID], (int)subNode.value);
LongRange range = ranges[rangeID];
// Test drill-down:
DrillDownQuery ddq = new DrillDownQuery(config);
if (Random().NextBoolean())
{
if (Random().NextBoolean())
{
ddq.Add("field", NumericRangeFilter.NewLongRange("field", range.min, range.max, range.minInclusive, range.maxInclusive));
}
else
{
ddq.Add("field", NumericRangeQuery.NewLongRange("field", range.min, range.max, range.minInclusive, range.maxInclusive));
}
}
else
{
ddq.Add("field", range.GetFilter(fastMatchFilter, vs));
}
Assert.AreEqual(expectedCounts[rangeID], s.Search(ddq, 10).TotalHits);
}
}
IOUtils.Close(w, r, dir);
}