internal override SqlExpression VisitLift(SqlLift lift) {
     lift.Expression = base.VisitExpression(lift.Expression);
     return lift;
 }
Ejemplo n.º 2
0
 internal override SqlExpression VisitLift(SqlLift lift) {
     this.Visit(lift.Expression);
     return lift;
 }
Ejemplo n.º 3
0
 internal override SqlExpression VisitLift(SqlLift lift) {
     return new SqlLift(lift.ClrType, this.VisitExpression(lift.Expression), lift.SourceExpression);
 }
Ejemplo n.º 4
0
 internal virtual SqlExpression VisitLift(SqlLift lift) {
     lift.Expression = this.VisitExpression(lift.Expression);
     return lift;
 }
        internal static bool?CanBeNull(SqlExpression expr)
        {
            switch (expr.NodeType)
            {
            case SqlNodeType.ExprSet:
                SqlExprSet exprSet = (SqlExprSet)expr;
                return(CanBeNull(exprSet.Expressions));

            case SqlNodeType.SimpleCase:
                SqlSimpleCase sc = (SqlSimpleCase)expr;
                return(CanBeNull(sc.Whens.Select(w => w.Value)));

            case SqlNodeType.Column:
                SqlColumn col = (SqlColumn)expr;
                if (col.MetaMember != null)
                {
                    return(col.MetaMember.CanBeNull);
                }
                else if (col.Expression != null)
                {
                    return(CanBeNull(col.Expression));
                }
                return(null);     // Don't know.

            case SqlNodeType.ColumnRef:
                SqlColumnRef cref = (SqlColumnRef)expr;
                return(CanBeNull(cref.Column));

            case SqlNodeType.Value:
                return(((SqlValue)expr).Value == null);

            case SqlNodeType.New:
            case SqlNodeType.Multiset:
            case SqlNodeType.Grouping:
            case SqlNodeType.DiscriminatedType:
            case SqlNodeType.IsNotNull:     // IsNull\IsNotNull always return true or false and can never return NULL.
            case SqlNodeType.IsNull:
            case SqlNodeType.Exists:
                return(false);

            case SqlNodeType.Add:
            case SqlNodeType.Sub:
            case SqlNodeType.Mul:
            case SqlNodeType.Div:
            case SqlNodeType.Mod:
            case SqlNodeType.BitAnd:
            case SqlNodeType.BitOr:
            case SqlNodeType.BitXor:
            case SqlNodeType.Concat: {
                SqlBinary bop   = (SqlBinary)expr;
                bool?     left  = CanBeNull(bop.Left);
                bool?     right = CanBeNull(bop.Right);
                return((left != false) || (right != false));
            }

            case SqlNodeType.Negate:
            case SqlNodeType.BitNot: {
                SqlUnary uop = (SqlUnary)expr;
                return(CanBeNull(uop.Operand));
            }

            case SqlNodeType.Lift: {
                SqlLift lift = (SqlLift)expr;
                return(CanBeNull(lift.Expression));
            }

            case SqlNodeType.OuterJoinedValue:
                return(true);

            default:
                return(null);    // Don't know.
            }
        }
Ejemplo n.º 6
0
 internal virtual SqlExpression VisitLift(SqlLift lift) {
     lift.Expression = this.VisitExpression(lift.Expression);
     return lift;
 }
 private SqlExpression TranslateConvertStaticMethod(SqlMethodCall mc) {
     SqlExpression returnValue = null;
     if (mc.Arguments.Count == 1) {
         SqlExpression expr = mc.Arguments[0];
         Type targetType = null;
         ProviderType providerType = null;
         switch (mc.Method.Name) {
             case "ToBoolean":
                 targetType = typeof(bool);
                 break;
             case "ToDecimal":
                 targetType = typeof(decimal);
                 break;
             case "ToByte":
                 targetType = typeof(byte);
                 break;
             case "ToChar": {
                     targetType = typeof(char);
                     if (expr.SqlType.IsChar) {
                         providerType = sql.TypeProvider.From(targetType, 1);
                     }
                     break;
                 }
             case "ToDateTime":
                 Type nnType = TypeSystem.GetNonNullableType(expr.ClrType);
                 if (nnType == typeof(string) || nnType == typeof(DateTime)) {
                     targetType = typeof(DateTime);
                 }
                 else {
                     throw Error.ConvertToDateTimeOnlyForDateTimeOrString();
                 }
                 break;
             // not applicable: "ToDateTimeOffset"
             case "ToDouble":
                 targetType = typeof(double);
                 break;
             case "ToInt16":
                 targetType = typeof(Int16);
                 break;
             case "ToInt32":
                 targetType = typeof(Int32);
                 break;
             case "ToInt64":
                 targetType = typeof(Int64);
                 break;
             case "ToSingle":
                 targetType = typeof(float);
                 break;
             case "ToString":
                 targetType = typeof(string);
                 break;
             // Unsupported
             case "ToSByte":
             case "ToUInt16":
             case "ToUInt32":
             case "ToUInt64":
             default:
                 throw GetMethodSupportException(mc);
         }
         // Since boolean literals and Int32 both map to the same provider type, we must
         // special case boolean types so we don't miss conversions.  Below we catch
         // conversions from bool->int (Convert.ToInt32(bool)) and ensure the conversion
         // remains.
         if (sql.TypeProvider.From(targetType) != expr.SqlType ||
             (expr.ClrType == typeof(bool) && targetType == typeof(int))) {
             // do the conversions that would be done for a cast "(<targetType>) expression"
             returnValue = sql.ConvertTo(targetType, expr);
         }
         else if (targetType != null) {
             if (sql.TypeProvider.From(targetType) != expr.SqlType) {
                 // do the conversions that would be done for a cast "(<targetType>) expression"
                 returnValue = sql.ConvertTo(targetType, expr);
             }
             else if (targetType != expr.ClrType &&
                 (TypeSystem.GetNonNullableType(targetType) == TypeSystem.GetNonNullableType(expr.ClrType))) {
                 // types are same except for nullability, so lift the type
                 returnValue = new SqlLift(targetType, expr, expr.SourceExpression);
             }
             else {
                 returnValue = expr;
             }
         }
     }
     return returnValue;
 }
Ejemplo n.º 8
0
 internal override SqlExpression VisitLift(SqlLift lift)
 {
     lift.Expression = base.VisitExpression(lift.Expression);
     return(lift);
 }
Ejemplo n.º 9
0
 internal override SqlExpression VisitLift(SqlLift lift)
 {
     return(new SqlLift(lift.ClrType, this.VisitExpression(lift.Expression), lift.SourceExpression));
 }