private static NumericType GetNumericDataType(J2N.Numerics.Number number)
{
if (number is J2N.Numerics.Int64)
{
return(NumericType.INT64);
}
else if (number is J2N.Numerics.Int32)
{
return(NumericType.INT32);
}
else if (number is J2N.Numerics.Double)
{
return(NumericType.DOUBLE);
}
else if (number is J2N.Numerics.Single)
{
return(NumericType.SINGLE);
}
else
{
// LUCENENET: Factored out NLS/Message/IMessage so end users can optionally utilize the built-in .NET localization.
throw new QueryNodeException(
string.Format(
QueryParserMessages.NUMBER_CLASS_NOT_SUPPORTED_BY_NUMERIC_RANGE_QUERY,
number.GetType()));
}
}
public virtual Query Build(IQueryNode queryNode)
{
NumericRangeQueryNode numericRangeNode = (NumericRangeQueryNode)queryNode;
NumericQueryNode lowerNumericNode = (NumericQueryNode)numericRangeNode.LowerBound;
NumericQueryNode upperNumericNode = (NumericQueryNode)numericRangeNode.UpperBound;
J2N.Numerics.Number lowerNumber = lowerNumericNode.Value;
J2N.Numerics.Number upperNumber = upperNumericNode.Value;
NumericConfig numericConfig = numericRangeNode.NumericConfig;
NumericType numberType = numericConfig.Type;
string field = StringUtils.ToString(numericRangeNode.Field);
bool minInclusive = numericRangeNode.IsLowerInclusive;
bool maxInclusive = numericRangeNode.IsUpperInclusive;
int precisionStep = numericConfig.PrecisionStep;
switch (numberType)
{
case NumericType.INT64:
return(NumericRangeQuery.NewInt64Range(field, precisionStep,
lowerNumber?.ToInt64(), upperNumber?.ToInt64(), minInclusive, maxInclusive));
case NumericType.INT32:
return(NumericRangeQuery.NewInt32Range(field, precisionStep,
lowerNumber?.ToInt32(), upperNumber?.ToInt32(), minInclusive,
maxInclusive));
case NumericType.SINGLE:
return(NumericRangeQuery.NewSingleRange(field, precisionStep,
lowerNumber?.ToSingle(), upperNumber?.ToSingle(), minInclusive,
maxInclusive));
case NumericType.DOUBLE:
return(NumericRangeQuery.NewDoubleRange(field, precisionStep,
lowerNumber?.ToDouble(), upperNumber?.ToDouble(), minInclusive,
maxInclusive));
default:
// LUCENENET: Factored out NLS/Message/IMessage so end users can optionally utilize the built-in .NET localization.
throw new QueryNodeException(string.Format(
QueryParserMessages.UNSUPPORTED_NUMERIC_DATA_TYPE, numberType));
}
}
protected override IQueryNode PostProcessNode(IQueryNode node)
{
if (node is TermRangeQueryNode termRangeNode)
{
QueryConfigHandler config = GetQueryConfigHandler();
if (config != null)
{
FieldConfig fieldConfig = config.GetFieldConfig(StringUtils
.ToString(termRangeNode.Field));
if (fieldConfig != null)
{
NumericConfig numericConfig = fieldConfig
.Get(ConfigurationKeys.NUMERIC_CONFIG);
if (numericConfig != null)
{
FieldQueryNode lower = (FieldQueryNode)termRangeNode.LowerBound;
FieldQueryNode upper = (FieldQueryNode)termRangeNode.UpperBound;
string lowerText = lower.GetTextAsString();
string upperText = upper.GetTextAsString();
NumberFormat numberFormat = numericConfig.NumberFormat;
J2N.Numerics.Number lowerNumber = null, upperNumber = null;
if (lowerText.Length > 0)
{
try
{
lowerNumber = numberFormat.Parse(lowerText);
}
catch (FormatException e) // LUCENENET: In .NET we are expecting the framework to throw FormatException, not ParseException
{
// LUCENENET: Factored out NLS/Message/IMessage so end users can optionally utilize the built-in .NET localization.
throw new QueryNodeParseException(string.Format(
QueryParserMessages.COULD_NOT_PARSE_NUMBER, lower
.GetTextAsString(), numberFormat.ToString()), e);
}
}
if (upperText.Length > 0)
{
try
{
upperNumber = numberFormat.Parse(upperText);
}
catch (FormatException e) // LUCENENET: In .NET we are expecting the framework to throw FormatException, not ParseException
{
// LUCENENET: Factored out NLS/Message/IMessage so end users can optionally utilize the built-in .NET localization.
throw new QueryNodeParseException(string.Format(
QueryParserMessages.COULD_NOT_PARSE_NUMBER, upper
.GetTextAsString(), numberFormat.ToString()), e);
}
}
switch (numericConfig.Type)
{
case NumericType.INT64:
if (upperNumber != null)
{
upperNumber = J2N.Numerics.Int64.GetInstance(upperNumber.ToInt64());
}
if (lowerNumber != null)
{
lowerNumber = J2N.Numerics.Int64.GetInstance(lowerNumber.ToInt64());
}
break;
case NumericType.INT32:
if (upperNumber != null)
{
upperNumber = J2N.Numerics.Int32.GetInstance(upperNumber.ToInt32());
}
if (lowerNumber != null)
{
lowerNumber = J2N.Numerics.Int32.GetInstance(lowerNumber.ToInt32());
}
break;
case NumericType.DOUBLE:
if (upperNumber != null)
{
upperNumber = J2N.Numerics.Double.GetInstance(upperNumber.ToDouble());
}
if (lowerNumber != null)
{
lowerNumber = J2N.Numerics.Double.GetInstance(lowerNumber.ToDouble());
}
break;
case NumericType.SINGLE:
if (upperNumber != null)
{
upperNumber = J2N.Numerics.Single.GetInstance(upperNumber.ToSingle());
}
if (lowerNumber != null)
{
lowerNumber = J2N.Numerics.Single.GetInstance(lowerNumber.ToSingle());
}
break;
}
NumericQueryNode lowerNode = new NumericQueryNode(
termRangeNode.Field, lowerNumber, numberFormat);
NumericQueryNode upperNode = new NumericQueryNode(
termRangeNode.Field, upperNumber, numberFormat);
bool lowerInclusive = termRangeNode.IsLowerInclusive;
bool upperInclusive = termRangeNode.IsUpperInclusive;
return(new NumericRangeQueryNode(lowerNode, upperNode,
lowerInclusive, upperInclusive, numericConfig));
}
}
}
}
return(node);
}
public virtual void TestNumericField()
{
using Directory dir = NewDirectory();
DirectoryReader r = null;
try
{
var numDocs = AtLeast(500);
var answers = new Number[numDocs];
using (var w = new RandomIndexWriter(Random, dir))
{
NumericType[] typeAnswers = new NumericType[numDocs];
for (int id = 0; id < numDocs; id++)
{
Document doc = new Document();
Field nf;
Field sf;
Number answer;
NumericType typeAnswer;
if (Random.NextBoolean())
{
// float/double
if (Random.NextBoolean())
{
float f = Random.NextSingle();
answer = Single.GetInstance(f);
nf = new SingleField("nf", f, Field.Store.NO);
sf = new StoredField("nf", f);
typeAnswer = NumericType.SINGLE;
}
else
{
double d = Random.NextDouble();
answer = Double.GetInstance(d);
nf = new DoubleField("nf", d, Field.Store.NO);
sf = new StoredField("nf", d);
typeAnswer = NumericType.DOUBLE;
}
}
else
{
// int/long
if (Random.NextBoolean())
{
int i = Random.Next();
answer = Int32.GetInstance(i);
nf = new Int32Field("nf", i, Field.Store.NO);
sf = new StoredField("nf", i);
typeAnswer = NumericType.INT32;
}
else
{
long l = Random.NextInt64();
answer = Int64.GetInstance(l);
nf = new Int64Field("nf", l, Field.Store.NO);
sf = new StoredField("nf", l);
typeAnswer = NumericType.INT64;
}
}
doc.Add(nf);
doc.Add(sf);
answers[id] = answer;
typeAnswers[id] = typeAnswer;
FieldType ft = new FieldType(Int32Field.TYPE_STORED);
ft.NumericPrecisionStep = int.MaxValue;
doc.Add(new Int32Field("id", id, ft));
w.AddDocument(doc);
}
r = w.GetReader();
} // w.Dispose();
Assert.AreEqual(numDocs, r.NumDocs);
foreach (AtomicReaderContext ctx in r.Leaves)
{
AtomicReader sub = ctx.AtomicReader;
FieldCache.Int32s ids = FieldCache.DEFAULT.GetInt32s(sub, "id", false);
for (int docID = 0; docID < sub.NumDocs; docID++)
{
Document doc = sub.Document(docID);
Field f = doc.GetField <Field>("nf");
Assert.IsTrue(f is StoredField, "got f=" + f);
#pragma warning disable 612, 618
Assert.AreEqual(answers[ids.Get(docID)], f.GetNumericValue());
#pragma warning restore 612, 618
}
}
}
finally
{
r?.Dispose();
}
}
