protected virtual BaseQuery HandleBetween(BetweenNode node, ElasticSearchQueryMapperState state)
{
var excludeLowerBound = !(node.Inclusion == Inclusion.Both || node.Inclusion == Inclusion.Lower);
var excludeUpperBound = !(node.Inclusion == Inclusion.Both || node.Inclusion == Inclusion.Upper);
var fieldName = GetFormattedFieldName(node.Field);
var lowerBound = ValueFormatter.FormatValueForIndexStorage(node.From);
var upperBound = ValueFormatter.FormatValueForIndexStorage(node.To);
return(Query.Range(delegate(RangeQueryDescriptor <dynamic> descriptor)
{
descriptor.From(lowerBound.ToString());
if (excludeLowerBound)
{
descriptor.FromExclusive();
}
descriptor.To(upperBound.ToString());
if (excludeUpperBound)
{
descriptor.ToExclusive();
}
descriptor.OnField(fieldName);
}));
}
/// <summary>
/// Visit Between node in DFS manner.
/// </summary>
/// <param name="node">Between node that will be visited.</param>
public void Visit(BetweenNode node)
{
foreach (var item in node.Descendants)
{
item.Accept(this);
}
node.Accept(_visitor);
}
private RdlSyntaxNode ComposeEqualityOperators()
{
var node = ComposeArithmeticOperators(Precendence.Level1);
while (IsEqualityOperator(Current))
{
switch (Current.TokenType)
{
case StatementType.GreaterEqual:
Consume(StatementType.GreaterEqual);
node = new GreaterEqualNode(node, ComposeEqualityOperators());
break;
case StatementType.Greater:
Consume(StatementType.Greater);
node = new GreaterNode(node, ComposeEqualityOperators());
break;
case StatementType.LessEqual:
Consume(StatementType.LessEqual);
node = new LessEqualNode(node, ComposeEqualityOperators());
break;
case StatementType.Less:
Consume(StatementType.Less);
node = new LessNode(node, ComposeEqualityOperators());
break;
case StatementType.Equality:
Consume(StatementType.Equality);
node = new EqualityNode(node, ComposeEqualityOperators());
break;
case StatementType.Diff:
Consume(StatementType.Diff);
node = new DiffNode(node, ComposeEqualityOperators());
break;
case StatementType.Between:
node = new BetweenNode(ConsumeAndGetToken(), node,
ComposeAndSkip(f => f.ComposeArithmeticOperators(Precendence.Level1), StatementType.And),
ComposeArithmeticOperators(Precendence.Level1));
break;
case StatementType.Not:
Consume(StatementType.Not);
node = new NotNode(Current, node);
break;
default:
throw new NotSupportedException();
}
}
return(node);
}
/// <summary>
/// Performs "Between" specific operations.
/// </summary>
/// <param name="node">The "Between" node.</param>
public void Visit(BetweenNode node)
{
switch (node.Expression.ReturnType.Name)
{
case nameof(Boolean):
case nameof(Int16):
case nameof(Int32):
case nameof(Int64):
Instructions.Add(new BetweenNumeric());
break;
case nameof(DateTimeOffset):
Instructions.Add(new BetweenDatetime());
break;
}
}
protected QueryBase VisitBetween(BetweenNode node, ElasticQueryMapperState state)
{
// TODO: Same as GreaterThan etc. - i.e. check type for date, number or string etc.
var fieldName = FormatFieldName(node.Field);
var includeLower = node.Inclusion == Inclusion.Both || node.Inclusion == Inclusion.Lower;
var includeUpper = node.Inclusion == Inclusion.Both || node.Inclusion == Inclusion.Upper;
// TODO: Allow null as one of parameters?
// TODO: If number
if (true)
{
var lowerNumber = double.Parse(node.From.ToString()); // TODO:
var upperNumber = double.Parse(node.To.ToString()); // TODO:
var query = new NumericRangeQuery
{
Field = fieldName,
Boost = node.Boost
};
// TODO: Refactor this shit to something less shitty looking
if (includeLower)
{
query.GreaterThanOrEqualTo = lowerNumber;
}
else
{
query.GreaterThan = lowerNumber;
}
if (includeUpper)
{
query.LessThanOrEqualTo = upperNumber;
}
else
{
query.LessThan = upperNumber;
}
}
// TODO: If date
// TODO: If term (string)
throw new NotImplementedException();
}
protected virtual QueryNode VisitBetween(BetweenNode node, AzureQueryOptimizerState state)
{
return((QueryNode) new BetweenNode(node.Field, node.From, node.To, node.Inclusion, state.Boost));
}
public override void Visit(BetweenNode node)
{
}
/// <summary> /// Visit Between node. /// </summary> /// <param name="node">Between node of AST</param> public abstract void Visit(BetweenNode node);
public void Visit(BetweenNode node)
{
}
