private string BindOperator(UnaryOperatorQueryNode unaryOperatorNode)
{
var operand = unaryOperatorNode.Operand is ConstantQueryNode
? MakeSparqlConstant((unaryOperatorNode.Operand as ConstantQueryNode).Value)
: ProcessNode(unaryOperatorNode.Operand);
switch (unaryOperatorNode.OperatorKind)
{
case UnaryOperatorKind.Not:
return("!(" + operand + ")");
case UnaryOperatorKind.Negate:
return("-" + operand + "");
default:
throw new NotImplementedException("No support for unary operator " + unaryOperatorNode.OperatorKind);
}
}
private Expression BindUnaryOperatorQueryNode(UnaryOperatorQueryNode unaryOperatorQueryNode)
{
// No need to handle null-propagation here as CLR already handles it.
// !(null) = null
// -(null) = null
Expression inner = Bind(unaryOperatorQueryNode.Operand);
switch (unaryOperatorQueryNode.OperatorKind)
{
case UnaryOperatorKind.Negate:
return(Expression.Negate(inner));
case UnaryOperatorKind.Not:
return(Expression.Not(inner));
default:
throw Error.NotSupported(SRResources.QueryNodeBindingNotSupported, unaryOperatorQueryNode.Kind, typeof(FilterBinder).Name);
}
}
/// <summary>
/// Translates a unary operator node.
/// </summary>
/// <param name="unaryOperatorNode">The unary operator node to translate.</param>
/// <returns>Expression which evaluates to the result of the unary operator.</returns>
protected virtual Expression TranslateUnaryOperator(UnaryOperatorQueryNode unaryOperatorNode)
{
ExceptionUtils.CheckArgumentNotNull(unaryOperatorNode, "unaryOperatorNode");
ExceptionUtils.CheckArgumentNotNull(unaryOperatorNode.Operand, "unaryOperatorNode.Operand");
Expression operand = this.Translate(unaryOperatorNode.Operand);
// If the operand statically is the null literal we optimize the operator to result in the
// null literal as well (per specification) because we otherwise cannot execute such an expression tree
if (operand == nullLiteralExpression)
{
return nullLiteralExpression;
}
// throw if no type is available
if (unaryOperatorNode.TypeReference == null)
{
throw new ODataException(Strings.QueryExpressionTranslator_SingleValueQueryNodeWithoutTypeReference(unaryOperatorNode.Kind));
}
// TODO: deal with null propagation if necessary
// TODO: deal with open types
switch (unaryOperatorNode.OperatorKind)
{
case UnaryOperatorKind.Negate:
return Expression.Negate(operand);
case UnaryOperatorKind.Not:
if (operand.Type == typeof(bool) || operand.Type == typeof(bool?))
{
// Expression.Not will take numerics and apply '~' to them, thus the extra check here.
return Expression.Not(operand);
}
else
{
throw new ODataException(Strings.QueryExpressionTranslator_UnaryNotOperandNotBoolean(operand.Type));
}
default:
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.QueryExpressionTranslator_TranslateUnaryOperator_UnreachableCodepath));
}
}
private string BindOperator(UnaryOperatorQueryNode unaryOperatorNode)
{
var operand = unaryOperatorNode.Operand is ConstantQueryNode
? MakeSparqlConstant((unaryOperatorNode.Operand as ConstantQueryNode).Value)
: ProcessNode(unaryOperatorNode.Operand);
switch (unaryOperatorNode.OperatorKind)
{
case UnaryOperatorKind.Not:
return "!(" + operand + ")";
case UnaryOperatorKind.Negate:
return "-" + operand + "";
default:
throw new NotImplementedException("No support for unary operator " + unaryOperatorNode.OperatorKind);
}
}