private static HqlExpression ConvertBooleanToCase(HqlExpression node)
{
if (node is HqlBooleanExpression)
{
var builder = new HqlTreeBuilder();
return(builder.Case(
new HqlWhen[] { builder.When(node, builder.True()) },
builder.False()));
}
return(node);
}
private HqlTreeNode TranslateInequalityComparison(BinaryExpression expression)
{
var lhs = VisitExpression(expression.Left).ToArithmeticExpression();
var rhs = VisitExpression(expression.Right).ToArithmeticExpression();
// Check for nulls on left or right.
if (VisitorUtil.IsNullConstant(expression.Right))
{
rhs = null;
}
if (VisitorUtil.IsNullConstant(expression.Left))
{
lhs = null;
}
if (lhs == null && rhs == null)
{
return(_hqlTreeBuilder.False());
}
if (lhs == null)
{
return(_hqlTreeBuilder.IsNotNull(rhs));
}
if (rhs == null)
{
return(_hqlTreeBuilder.IsNotNull(lhs));
}
var lhsNullable = IsNullable(lhs);
var rhsNullable = IsNullable(rhs);
var inequality = _hqlTreeBuilder.Inequality(lhs, rhs);
if (!lhsNullable && !rhsNullable)
{
return(inequality);
}
var lhs2 = VisitExpression(expression.Left).ToArithmeticExpression();
var rhs2 = VisitExpression(expression.Right).ToArithmeticExpression();
HqlBooleanExpression booleanExpression;
if (lhsNullable && rhsNullable)
{
booleanExpression = _hqlTreeBuilder.Inequality(
_hqlTreeBuilder.IsNull(lhs2).ToArithmeticExpression(),
_hqlTreeBuilder.IsNull(rhs2).ToArithmeticExpression());
}
else if (lhsNullable)
{
booleanExpression = _hqlTreeBuilder.IsNull(lhs2);
}
else
{
booleanExpression = _hqlTreeBuilder.IsNull(rhs2);
}
return(_hqlTreeBuilder.BooleanOr(inequality, booleanExpression));
}
private HqlExpression GetExpressionForBooleanEquality(Expression @operator, HqlExpression original)
{
//When the expression is a constant then use the constant
var operandEx = @operator as ConstantExpression;
if (operandEx != null)
{
NamedParameter namedParameter;
if (_parameters.ConstantToParameterMap.TryGetValue(operandEx, out namedParameter))
{
_parameters.RequiredHqlParameters.Add(new NamedParameterDescriptor(namedParameter.Name, null, false));
return(_hqlTreeBuilder.Parameter(namedParameter.Name).AsExpression());
}
return(_hqlTreeBuilder.Constant(operandEx.Value));
}
//When the expression is a member-access not nullable then use the HbmDot
var memberAccessExpression = @operator as MemberExpression;
if (ExpressionType.MemberAccess.Equals(@operator.NodeType) && memberAccessExpression != null && typeof(bool) == memberAccessExpression.Type)
{
// this case make the difference when the property "Value" of a nullable type is used (ignore the null since the user is explicity checking the Value)
return(original);
}
var subQueryExpression = @operator as SubQueryExpression;
if (subQueryExpression != null)
{
var resultOperators = subQueryExpression.QueryModel.ResultOperators;
if (resultOperators.Count == 1 &&
(resultOperators[0] is FirstResultOperator ||
resultOperators[0] is SingleResultOperator))
{
return(original);
}
}
//When the expression is a member-access nullable then use the "case" clause to transform it to boolean (to use always .NET meaning instead leave the DB the behavior for null)
//When the expression is a complex-expression then use the "case" clause to transform it to boolean
return(_hqlTreeBuilder.Case(new[] { _hqlTreeBuilder.When(original, _hqlTreeBuilder.True()) }, _hqlTreeBuilder.False()));
}
internal static HqlExpression ToArithmeticExpression(this HqlTreeNode node)
{
var hqlBooleanExpression = node as HqlBooleanExpression;
if (hqlBooleanExpression != null)
{
var builder = new HqlTreeBuilder();
return(builder.Case(new[] { builder.When(hqlBooleanExpression, builder.True()) }, builder.False()));
}
return((HqlExpression)node);
}
