internal override SqlExpression VisitLift(SqlLift lift) { lift.Expression = base.VisitExpression(lift.Expression); return lift; }
internal override SqlExpression VisitLift(SqlLift lift) { this.Visit(lift.Expression); return lift; }
internal override SqlExpression VisitLift(SqlLift lift) { return new SqlLift(lift.ClrType, this.VisitExpression(lift.Expression), lift.SourceExpression); }
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. } }
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; }
internal override SqlExpression VisitLift(SqlLift lift) { lift.Expression = base.VisitExpression(lift.Expression); return(lift); }
internal override SqlExpression VisitLift(SqlLift lift) { return(new SqlLift(lift.ClrType, this.VisitExpression(lift.Expression), lift.SourceExpression)); }