internal override SqlExpression VisitMethodCall(SqlMethodCall mc)
{
mc.Object = this.VisitExpression(mc.Object);
int num = 0;
int count = mc.Arguments.Count;
while (num < count)
{
mc.Arguments[num] = this.VisitExpression(mc.Arguments[num]);
num++;
}
if (mc.Method.IsStatic)
{
if ((mc.Method.Name == "Equals") && (mc.Arguments.Count == 2))
{
return(this.sql.Binary(SqlNodeType.EQ2V, mc.Arguments[0], mc.Arguments[1], mc.Method));
}
if ((mc.Method.DeclaringType == typeof(string)) && (mc.Method.Name == "Concat"))
{
SqlExpression expression;
var array = mc.Arguments[0] as SqlClientArray;
var expressions = array != null ? array.Expressions : mc.Arguments;
if (expressions.Count == 0)
{
return(this.sql.ValueFromObject("", false, mc.SourceExpression));
}
if (expressions[0].SqlType.IsString || expressions[0].SqlType.IsChar)
{
expression = expressions[0];
}
else
{
expression = this.sql.ConvertTo(typeof(string), expressions[0]);
}
for (int i = 1; i < expressions.Count; i++)
{
if (expressions[i].SqlType.IsString || expressions[i].SqlType.IsChar)
{
expression = this.sql.Concat(new SqlExpression[] { expression, expressions[i] }, mc.SourceExpression);
}
else
{
expression =
this.sql.Concat(new SqlExpression[]
{
expression, this.sql.ConvertTo(typeof(string), expressions[i])
}, mc.SourceExpression);
}
}
return(expression);
}
if (PreBindDotNetConverter.IsVbIIF(mc))
{
return(this.TranslateVbIIF(mc));
}
switch (mc.Method.Name)
{
case "op_Equality":
return(this.sql.Binary(SqlNodeType.EQ, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_Inequality":
return(this.sql.Binary(SqlNodeType.NE, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_LessThan":
return(this.sql.Binary(SqlNodeType.LT, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_LessThanOrEqual":
return(this.sql.Binary(SqlNodeType.LE, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_GreaterThan":
return(this.sql.Binary(SqlNodeType.GT, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_GreaterThanOrEqual":
return(this.sql.Binary(SqlNodeType.GE, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_Multiply":
return(this.sql.Binary(SqlNodeType.Mul, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_Division":
return(this.sql.Binary(SqlNodeType.Div, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_Subtraction":
return(this.sql.Binary(SqlNodeType.Sub, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_Addition":
return(this.sql.Binary(SqlNodeType.Add, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_Modulus":
return(this.sql.Binary(SqlNodeType.Mod, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_BitwiseAnd":
return(this.sql.Binary(SqlNodeType.BitAnd, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_BitwiseOr":
return(this.sql.Binary(SqlNodeType.BitOr, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_ExclusiveOr":
return(this.sql.Binary(SqlNodeType.BitXor, mc.Arguments[0], mc.Arguments[1], mc.Method,
mc.ClrType));
case "op_UnaryNegation":
return(this.sql.Unary(SqlNodeType.Negate, mc.Arguments[0], mc.Method, mc.SourceExpression));
case "op_OnesComplement":
return(this.sql.Unary(SqlNodeType.BitNot, mc.Arguments[0], mc.Method, mc.SourceExpression));
case "op_False":
return(this.sql.Unary(SqlNodeType.Not, mc.Arguments[0], mc.Method, mc.SourceExpression));
}
return(mc);
}
if ((mc.Method.Name == "Equals") && (mc.Arguments.Count == 1))
{
return(this.sql.Binary(SqlNodeType.EQ, mc.Object, mc.Arguments[0]));
}
if (!(mc.Method.Name == "GetType") || (mc.Arguments.Count != 0))
{
return(mc);
}
MetaType sourceMetaType = TypeSource.GetSourceMetaType(mc.Object, this.model);
if (sourceMetaType.HasInheritance)
{
Type type = sourceMetaType.Discriminator.Type;
var discriminator = new SqlDiscriminatorOf(mc.Object, type,
this.sql.TypeProvider.From(type),
mc.SourceExpression);
return(this.VisitExpression(this.sql.DiscriminatedType(discriminator, sourceMetaType)));
}
return(this.VisitExpression(this.sql.StaticType(sourceMetaType, mc.SourceExpression)));
}
internal override SqlExpression VisitMethodCall(SqlMethodCall mc)
{
mc.Object = this.VisitExpression(mc.Object);
for (int i = 0, n = mc.Arguments.Count; i < n; i++)
{
mc.Arguments[i] = this.VisitExpression(mc.Arguments[i]);
}
if (mc.Method.IsStatic)
{
if (mc.Method.Name == "Equals" && mc.Arguments.Count == 2)
{
return(sql.Binary(SqlNodeType.EQ2V, mc.Arguments[0], mc.Arguments[1], mc.Method));
}
if (mc.Method.DeclaringType == typeof(string) && mc.Method.Name == "Concat")
{
SqlClientArray arr = mc.Arguments[0] as SqlClientArray;
List <SqlExpression> exprs = null;
if (arr != null)
{
exprs = arr.Expressions;
}
else
{
exprs = mc.Arguments;
}
if (exprs.Count == 0)
{
return(sql.ValueFromObject("", false, mc.SourceExpression));
}
SqlExpression sum;
if (exprs[0].SqlType.IsString || exprs[0].SqlType.IsChar)
{
sum = exprs[0];
}
else
{
sum = sql.ConvertTo(typeof(string), exprs[0]);
}
for (int i = 1; i < exprs.Count; i++)
{
if (exprs[i].SqlType.IsString || exprs[i].SqlType.IsChar)
{
sum = sql.Concat(sum, exprs[i]);
}
else
{
sum = sql.Concat(sum, sql.ConvertTo(typeof(string), exprs[i]));
}
}
return(sum);
}
if (IsVbIIF(mc))
{
return(TranslateVbIIF(mc));
}
switch (mc.Method.Name)
{
case "op_Equality":
return(sql.Binary(SqlNodeType.EQ, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_Inequality":
return(sql.Binary(SqlNodeType.NE, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_LessThan":
return(sql.Binary(SqlNodeType.LT, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_LessThanOrEqual":
return(sql.Binary(SqlNodeType.LE, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_GreaterThan":
return(sql.Binary(SqlNodeType.GT, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_GreaterThanOrEqual":
return(sql.Binary(SqlNodeType.GE, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_Multiply":
return(sql.Binary(SqlNodeType.Mul, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_Division":
return(sql.Binary(SqlNodeType.Div, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_Subtraction":
return(sql.Binary(SqlNodeType.Sub, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_Addition":
return(sql.Binary(SqlNodeType.Add, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_Modulus":
return(sql.Binary(SqlNodeType.Mod, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_BitwiseAnd":
return(sql.Binary(SqlNodeType.BitAnd, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_BitwiseOr":
return(sql.Binary(SqlNodeType.BitOr, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_ExclusiveOr":
return(sql.Binary(SqlNodeType.BitXor, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType));
case "op_UnaryNegation":
return(sql.Unary(SqlNodeType.Negate, mc.Arguments[0], mc.Method, mc.SourceExpression));
case "op_OnesComplement":
return(sql.Unary(SqlNodeType.BitNot, mc.Arguments[0], mc.Method, mc.SourceExpression));
case "op_False":
return(sql.Unary(SqlNodeType.Not, mc.Arguments[0], mc.Method, mc.SourceExpression));
}
}
else
{
if (mc.Method.Name == "Equals" && mc.Arguments.Count == 1)
{
return(sql.Binary(SqlNodeType.EQ, mc.Object, mc.Arguments[0]));
}
if (mc.Method.Name == "GetType" && mc.Arguments.Count == 0)
{
MetaType mt = TypeSource.GetSourceMetaType(mc.Object, this.model);
if (mt.HasInheritance)
{
Type discriminatorType = mt.Discriminator.Type;
SqlDiscriminatorOf discriminatorOf = new SqlDiscriminatorOf(mc.Object, discriminatorType, this.sql.TypeProvider.From(discriminatorType), mc.SourceExpression);
return(this.VisitExpression(sql.DiscriminatedType(discriminatorOf, mt)));
}
return(this.VisitExpression(sql.StaticType(mt, mc.SourceExpression)));
}
}
return(mc);
}
internal SqlExpression TranslateEquals(SqlBinary expr)
{
IList <SqlExpression> keyExpressions;
IList <SqlExpression> identityExpressions;
SqlExpression left = expr.Left;
SqlExpression right = expr.Right;
if (right.NodeType == SqlNodeType.Element)
{
var select = (SqlSubSelect)right;
var alias = new SqlAlias(select.Select);
var selection = new SqlAliasRef(alias);
var select2 = new SqlSelect(selection, alias, expr.SourceExpression)
{
Where = sql.Binary(expr.NodeType, sql.DoNotVisitExpression(left), selection)
};
return(sql.SubSelect(SqlNodeType.Exists, select2));
}
if (left.NodeType == SqlNodeType.Element)
{
var select3 = (SqlSubSelect)left;
var alias2 = new SqlAlias(select3.Select);
var ref3 = new SqlAliasRef(alias2);
var select4 = new SqlSelect(ref3, alias2, expr.SourceExpression)
{
Where = sql.Binary(expr.NodeType, sql.DoNotVisitExpression(right), ref3)
};
return(sql.SubSelect(SqlNodeType.Exists, select4));
}
var sourceMetaType = TypeSource.GetSourceMetaType(left, services.Model);
var type = TypeSource.GetSourceMetaType(right, services.Model);
if (left.NodeType == SqlNodeType.TypeCase)
{
left = BestIdentityNode((SqlTypeCase)left);
}
if (right.NodeType == SqlNodeType.TypeCase)
{
right = BestIdentityNode((SqlTypeCase)right);
}
if ((sourceMetaType.IsEntity && type.IsEntity) && (sourceMetaType.Table != type.Table))
{
throw Error.CannotCompareItemsAssociatedWithDifferentTable();
}
if (((!sourceMetaType.IsEntity && !type.IsEntity) && ((left.NodeType != SqlNodeType.New) || left.SqlType.CanBeColumn)) && ((right.NodeType != SqlNodeType.New) || right.SqlType.CanBeColumn))
{
if ((expr.NodeType == SqlNodeType.EQ2V) || (expr.NodeType == SqlNodeType.NE2V))
{
return(TranslateEqualsOp(expr.NodeType, sql.DoNotVisitExpression(expr.Left),
sql.DoNotVisitExpression(expr.Right), false));
}
return(expr);
}
if ((sourceMetaType != type) && (sourceMetaType.InheritanceRoot != type.InheritanceRoot))
{
return(this.sql.Binary(SqlNodeType.EQ, sql.ValueFromObject(0, expr.SourceExpression), this.sql.ValueFromObject(1, expr.SourceExpression)));
}
var link = left as SqlLink;
if (((link != null) && link.Member.IsAssociation) && link.Member.Association.IsForeignKey)
{
keyExpressions = link.KeyExpressions;
}
else
{
keyExpressions = this.GetIdentityExpressions(sourceMetaType, this.sql.DoNotVisitExpression(left));
}
var link2 = right as SqlLink;
if (((link2 != null) && link2.Member.IsAssociation) && link2.Member.Association.IsForeignKey)
{
identityExpressions = link2.KeyExpressions;
}
else
{
identityExpressions = this.GetIdentityExpressions(type, sql.DoNotVisitExpression(right));
}
SqlExpression expression3 = null;
SqlNodeType op = ((expr.NodeType == SqlNodeType.EQ2V) || (expr.NodeType == SqlNodeType.NE2V)) ? SqlNodeType.EQ2V : SqlNodeType.EQ;
int num = 0;
int count = keyExpressions.Count;
while (num < count)
{
SqlExpression expression4 = this.TranslateEqualsOp(op, keyExpressions[num], identityExpressions[num], !sourceMetaType.IsEntity);
if (expression3 == null)
{
expression3 = expression4;
}
else
{
expression3 = this.sql.Binary(SqlNodeType.And, expression3, expression4);
}
num++;
}
if ((expr.NodeType != SqlNodeType.NE) && (expr.NodeType != SqlNodeType.NE2V))
{
return(expression3);
}
return(this.sql.Unary(SqlNodeType.Not, expression3, expression3.SourceExpression));
}
