protected override MemberAssignment VisitMemberAssignment(MemberAssignment assignment)
{
Write(TableAlias + _leftBracket + AtkTypeHelper.GetColumnAlias <T>(assignment.Member.Name) + _rightBracket);
Write(" = ");
Visit(assignment.Expression);
return(assignment);
}
private Expression Evaluate(Expression e)
{
Type type = e.Type;
if (e.NodeType == ExpressionType.Convert && AtkTypeHelper.GetNonNullableType(((UnaryExpression)e).Operand.Type) == AtkTypeHelper.GetNonNullableType(type))
{
e = ((UnaryExpression)e).Operand;
}
if (e.NodeType == ExpressionType.Constant)
{
ConstantExpression constantExpression = (ConstantExpression)e;
if (e.Type != type && AtkTypeHelper.GetNonNullableType(e.Type) == AtkTypeHelper.GetNonNullableType(type))
{
e = Expression.Constant(constantExpression.Value, type);
}
return(e);
}
MemberExpression memberExpression = e as MemberExpression;
if (memberExpression != null)
{
ConstantExpression expression = memberExpression.Expression as ConstantExpression;
if (expression != null)
{
return(Expression.Constant(memberExpression.Member.GetValue(expression.Value), type));
}
}
if (type.IsValueType)
{
e = Expression.Convert(e, typeof(object));
}
return(Expression.Constant(Expression.Lambda <Func <object> >(e, Array.Empty <ParameterExpression>()).Compile()(), type));
}
public static Type GetNonNullableType(Type type)
{
if (AtkTypeHelper.IsNullableType(type))
{
return(type.GetGenericArguments()[0]);
}
return(type);
}
public static object GetDefault(Type type)
{
if (type.IsValueType && !AtkTypeHelper.IsNullableType(type))
{
return(Activator.CreateInstance(type));
}
return((object)null);
}
public static Type GetNullAssignableType(Type type)
{
if (AtkTypeHelper.IsNullAssignable(type))
{
return(type);
}
return(typeof(Nullable <>).MakeGenericType(type));
}
private Expression Evaluate(System.Linq.Expressions.Expression e)
{
Type type = e.Type;
// check for nullable converts & strip them
if (e.NodeType == ExpressionType.Convert)
{
var u = (UnaryExpression)e;
if (AtkTypeHelper.GetNonNullableType(u.Operand.Type) == AtkTypeHelper.GetNonNullableType(type))
{
e = ((UnaryExpression)e).Operand;
}
}
// if we now just have a constant, return it
if (e.NodeType == ExpressionType.Constant)
{
var ce = (ConstantExpression)e;
// if we've lost our nullable typeness add it back
if (e.Type != type && AtkTypeHelper.GetNonNullableType(e.Type) == AtkTypeHelper.GetNonNullableType(type))
{
e = ce = System.Linq.Expressions.Expression.Constant(ce.Value, type);
}
return(e);
}
var me = e as MemberExpression;
if (me != null)
{
// member accesses off of constant's are common, and yet since these partial evals
// are never re-used, using reflection to access the member is faster than compiling
// and invoking a lambda
var ce = me.Expression as ConstantExpression;
if (ce != null)
{
return(System.Linq.Expressions.Expression.Constant(Atk.AtkExpression.AtkReflectionExtensions.GetValue(me.Member, ce.Value), type));
}
}
if (type.IsValueType)
{
e = System.Linq.Expressions.Expression.Convert(e, typeof(object));
}
Expression <Func <object> > lambda = System.Linq.Expressions.Expression.Lambda <Func <object> >(e);
#if NOREFEMIT
Func <object> fn = ExpressionEvaluator.CreateDelegate(lambda);
#else
Func <object> fn = lambda.Compile();
#endif
return(System.Linq.Expressions.Expression.Constant(fn(), type));
}
public static Type GetElementType(Type seqType)
{
Type ienumerable = AtkTypeHelper.FindIEnumerable(seqType);
if (ienumerable == (Type)null)
{
return(seqType);
}
return(ienumerable.GetGenericArguments()[0]);
}
protected override MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding binding)
{
Write(TableAlias + _leftBracket + AtkTypeHelper.GetColumnAlias <T>(binding.Member.Name) + _rightBracket);
Write(" = {");
WriteLine(Indentation.Inner);
VisitBindingList(binding.Bindings);
WriteLine(Indentation.Outer);
Write("}");
return(binding);
}
protected override MemberListBinding VisitMemberListBinding(MemberListBinding binding)
{
Write(_tableAlias + _leftbracket + AtkTypeHelper.GetColumnAlias <T>(binding.Member.Name) + _rightbracket);
Write(" = {");
WriteLine(Indentation.Inner);
VisitElementInitializerList(binding.Initializers);
WriteLine(Indentation.Outer);
Write("}");
return(binding);
}
public static object GetDefault(Type type)
{
bool isNullable = !type.IsValueType || AtkTypeHelper.IsNullableType(type);
if (!isNullable)
{
return(Activator.CreateInstance(type));
}
return(null);
}
protected override Expression VisitNewArray(NewArrayExpression na)
{
Write("new ");
Write(GetTypeName(AtkTypeHelper.GetElementType(na.Type)));
Write("[] {");
if (na.Expressions.Count > 1)
{
WriteLine(Indentation.Inner);
}
VisitExpressionList(na.Expressions);
if (na.Expressions.Count > 1)
{
WriteLine(Indentation.Outer);
}
Write("}");
return(na);
}
public static Type FindIEnumerable(Type seqType)
{
if (seqType == (Type)null || seqType == typeof(string))
{
return((Type)null);
}
if (seqType.IsArray)
{
return(typeof(IEnumerable <>).MakeGenericType(seqType.GetElementType()));
}
if (seqType.IsGenericType)
{
foreach (Type genericArgument in seqType.GetGenericArguments())
{
Type type = typeof(IEnumerable <>).MakeGenericType(genericArgument);
if (type.IsAssignableFrom(seqType))
{
return(type);
}
}
}
Type[] interfaces = seqType.GetInterfaces();
if (interfaces != null && (uint)interfaces.Length > 0U)
{
foreach (Type seqType1 in interfaces)
{
Type ienumerable = AtkTypeHelper.FindIEnumerable(seqType1);
if (ienumerable != (Type)null)
{
return(ienumerable);
}
}
}
if (seqType.BaseType != (Type)null && seqType.BaseType != typeof(object))
{
return(AtkTypeHelper.FindIEnumerable(seqType.BaseType));
}
return((Type)null);
}
public static bool IsNullAssignable(Type type)
{
return(!type.IsValueType || AtkTypeHelper.IsNullableType(type));
}
public static bool IsInteger(Type type)
{
AtkTypeHelper.GetNonNullableType(type);
return((uint)(Type.GetTypeCode(type) - 5) <= 7U);
}
public static ConstantExpression GetNullConstant(Type type)
{
return(Expression.Constant((object)null, AtkTypeHelper.GetNullAssignableType(type)));
}
protected override Expression VisitMemberAccess(MemberExpression m)
{
if (m.Member.DeclaringType == typeof(string))
{
Write(TableAlias + _leftBracket + AtkTypeHelper.GetColumnAlias <T>(m.Member.Name) + _rightBracket);
if (m.Member.Name == "Length")
{
Write("LEN(");
Visit(m.Expression);
Write(")");
return(m);
}
}
else if (m.Member.DeclaringType != null && (m.Member.DeclaringType.IsGenericType &&
m.Member.DeclaringType.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
if (m.Member.Name == "HasValue")
{
Write("(");
Visit(m.Expression);
Write(" IS NOT NULL)");
return(m);
}
}
else if (m.Member.DeclaringType == typeof(DateTime) || m.Member.DeclaringType == typeof(DateTimeOffset))
{
Write(TableAlias + _leftBracket + AtkTypeHelper.GetColumnAlias <T>(m.Member.Name) + _rightBracket);
switch (m.Member.Name)
{
case "Day":
Write("DAY(");
Visit(m.Expression);
Write(")");
return(m);
case "DayOfWeek":
Write("(DATEPART(weekday, ");
Visit(m.Expression);
Write(") - 1)");
return(m);
case "DayOfYear":
Write("(DATEPART(dayofyear, ");
Visit(m.Expression);
Write(") - 1)");
return(m);
case "Hour":
Write("DATEPART(hour, ");
Visit(m.Expression);
Write(")");
return(m);
case "Millisecond":
Write("DATEPART(millisecond, ");
Visit(m.Expression);
Write(")");
return(m);
case "Minute":
Write("DATEPART(minute, ");
Visit(m.Expression);
Write(")");
return(m);
case "Month":
Write("MONTH(");
Visit(m.Expression);
Write(")");
return(m);
case "Second":
Write("DATEPART(second, ");
Visit(m.Expression);
Write(")");
return(m);
case "Year":
Write("YEAR(");
Visit(m.Expression);
Write(")");
return(m);
}
}
else if (IsRight)
{
Write("@" + m.Member.Name);
}
else
{
Write(TableAlias + _leftBracket + AtkTypeHelper.GetColumnAlias <T>(m.Member.Name) + _rightBracket);
}
return(base.VisitMemberAccess(m));
}
