Пример #1
0
 internal virtual SqlExpression VisitLift(SqlLift lift) {
     lift.Expression = this.VisitExpression(lift.Expression);
     return lift;
 }
		private Type GenerateLift(SqlLift lift)
		{
			return this.GenerateExpressionForType(lift.Expression, lift.ClrType);
		}
Пример #3
0
		internal override SqlExpression VisitLift(SqlLift lift)
		{
			this.Visit(lift.Expression);
			return lift;
		}
Пример #4
0
		internal override SqlExpression VisitLift(SqlLift lift)
		{
			return new SqlLift(lift.ClrType, this.VisitExpression(lift.Expression), lift.SourceExpression);
		}
		internal override SqlExpression VisitLift(SqlLift lift)
		{
			lift.Expression = base.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;
			}