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); }