internal override Expression VisitMemberAccess(MemberExpression m)
{
if (MetaPosition.AreSameMember(m.Member, this.association.ThisMember.Member))
{
Expression[] keyValues = GetKeyValues(this.Visit(m.Expression), this.association.ThisKey);
return(Translator.WhereClauseFromSourceAndKeys(this.otherSouce, this.association.OtherKey.ToArray(), keyValues));
}
Expression exp = this.Visit(m.Expression);
if (exp != m.Expression)
{
if (exp.Type != m.Expression.Type && m.Member.Name == "Count" && TypeSystem.IsSequenceType(exp.Type))
{
return(Expression.Call(typeof(Enumerable), "Count", new Type[] { TypeSystem.GetElementType(exp.Type) }, exp));
}
return(Expression.MakeMemberAccess(exp, m.Member));
}
return(m);
}
internal static bool AreEqual(SqlNode node1, SqlNode node2)
{
if (node1 == node2)
{
return(true);
}
if ((node1 != null) && (node2 != null))
{
if (node1.NodeType == SqlNodeType.SimpleCase)
{
node1 = UnwrapTrivialCaseExpression((SqlSimpleCase)node1);
}
if (node2.NodeType == SqlNodeType.SimpleCase)
{
node2 = UnwrapTrivialCaseExpression((SqlSimpleCase)node2);
}
if (node1.NodeType != node2.NodeType)
{
if (node1.NodeType == SqlNodeType.ExprSet)
{
SqlExprSet set = (SqlExprSet)node1;
int num = 0;
int count = set.Expressions.Count;
while (num < count)
{
if (AreEqual(set.Expressions[num], node2))
{
return(true);
}
num++;
}
}
else if (node2.NodeType == SqlNodeType.ExprSet)
{
SqlExprSet set2 = (SqlExprSet)node2;
int num3 = 0;
int num4 = set2.Expressions.Count;
while (num3 < num4)
{
if (AreEqual(node1, set2.Expressions[num3]))
{
return(true);
}
num3++;
}
}
return(false);
}
if (node1.Equals(node2))
{
return(true);
}
switch (node1.NodeType)
{
case SqlNodeType.Add:
case SqlNodeType.And:
case SqlNodeType.BitAnd:
case SqlNodeType.BitOr:
case SqlNodeType.BitXor:
case SqlNodeType.Concat:
case SqlNodeType.Div:
case SqlNodeType.EQ:
case SqlNodeType.EQ2V:
case SqlNodeType.LE:
case SqlNodeType.LT:
case SqlNodeType.GE:
case SqlNodeType.GT:
case SqlNodeType.Mod:
case SqlNodeType.Mul:
case SqlNodeType.NE:
case SqlNodeType.NE2V:
case SqlNodeType.Or:
case SqlNodeType.Sub:
{
SqlBinary binary = (SqlBinary)node1;
SqlBinary binary2 = (SqlBinary)node2;
if (!AreEqual(binary.Left, binary2.Left))
{
return(false);
}
return(AreEqual(binary.Right, binary2.Right));
}
case SqlNodeType.Alias:
return(AreEqual(((SqlAlias)node1).Node, ((SqlAlias)node2).Node));
case SqlNodeType.AliasRef:
return(AreEqual(((SqlAliasRef)node1).Alias, ((SqlAliasRef)node2).Alias));
case SqlNodeType.Avg:
case SqlNodeType.BitNot:
case SqlNodeType.ClrLength:
case SqlNodeType.Count:
case SqlNodeType.Covar:
case SqlNodeType.IsNotNull:
case SqlNodeType.IsNull:
case SqlNodeType.Max:
case SqlNodeType.Min:
case SqlNodeType.Negate:
case SqlNodeType.Not:
case SqlNodeType.Not2V:
case SqlNodeType.OuterJoinedValue:
case SqlNodeType.Stddev:
case SqlNodeType.Sum:
case SqlNodeType.ValueOf:
return(AreEqual(((SqlUnary)node1).Operand, ((SqlUnary)node2).Operand));
case SqlNodeType.Between:
{
SqlBetween between = (SqlBetween)node1;
SqlBetween between2 = (SqlBetween)node1;
if (!AreEqual(between.Expression, between2.Expression) ||
!AreEqual(between.Start, between2.Start))
{
return(false);
}
return(AreEqual(between.End, between2.End));
}
case SqlNodeType.Cast:
case SqlNodeType.Convert:
case SqlNodeType.Treat:
{
SqlUnary unary = (SqlUnary)node1;
SqlUnary unary2 = (SqlUnary)node2;
if ((unary.ClrType != unary2.ClrType) || !(unary.SqlType == unary2.SqlType))
{
return(false);
}
return(AreEqual(unary.Operand, unary2.Operand));
}
case SqlNodeType.ClientCase:
{
SqlClientCase case5 = (SqlClientCase)node1;
SqlClientCase case6 = (SqlClientCase)node2;
if (case5.Whens.Count == case6.Whens.Count)
{
int num9 = 0;
int num10 = case5.Whens.Count;
while (num9 < num10)
{
if (!AreEqual(case5.Whens[num9].Match, case6.Whens[num9].Match) ||
!AreEqual(case5.Whens[num9].Value, case6.Whens[num9].Value))
{
return(false);
}
num9++;
}
return(true);
}
return(false);
}
case SqlNodeType.Column:
{
SqlColumn column = (SqlColumn)node1;
SqlColumn column2 = (SqlColumn)node2;
return((column == column2) ||
(((column.Expression != null) && (column2.Expression != null)) &&
AreEqual(column.Expression, column2.Expression)));
}
case SqlNodeType.ColumnRef:
{
SqlColumnRef cref = (SqlColumnRef)node1;
SqlColumnRef ref3 = (SqlColumnRef)node2;
return(GetBaseColumn(cref) == GetBaseColumn(ref3));
}
case SqlNodeType.DiscriminatedType:
{
SqlDiscriminatedType type = (SqlDiscriminatedType)node1;
SqlDiscriminatedType type2 = (SqlDiscriminatedType)node2;
return(AreEqual(type.Discriminator, type2.Discriminator));
}
case SqlNodeType.ExprSet:
{
SqlExprSet set3 = (SqlExprSet)node1;
SqlExprSet set4 = (SqlExprSet)node2;
if (set3.Expressions.Count == set4.Expressions.Count)
{
int num17 = 0;
int num18 = set3.Expressions.Count;
while (num17 < num18)
{
if (!AreEqual(set3.Expressions[num17], set4.Expressions[num17]))
{
return(false);
}
num17++;
}
return(true);
}
return(false);
}
case SqlNodeType.FunctionCall:
{
SqlFunctionCall call = (SqlFunctionCall)node1;
SqlFunctionCall call2 = (SqlFunctionCall)node2;
if (!(call.Name != call2.Name))
{
if (call.Arguments.Count != call2.Arguments.Count)
{
return(false);
}
int num13 = 0;
int num14 = call.Arguments.Count;
while (num13 < num14)
{
if (!AreEqual(call.Arguments[num13], call2.Arguments[num13]))
{
return(false);
}
num13++;
}
return(true);
}
return(false);
}
case SqlNodeType.Link:
{
SqlLink link = (SqlLink)node1;
SqlLink link2 = (SqlLink)node2;
if (MetaPosition.AreSameMember(link.Member.Member, link2.Member.Member))
{
if (!AreEqual(link.Expansion, link2.Expansion))
{
return(false);
}
if (link.KeyExpressions.Count != link2.KeyExpressions.Count)
{
return(false);
}
int num15 = 0;
int num16 = link.KeyExpressions.Count;
while (num15 < num16)
{
if (!AreEqual(link.KeyExpressions[num15], link2.KeyExpressions[num15]))
{
return(false);
}
num15++;
}
return(true);
}
return(false);
}
case SqlNodeType.Like:
{
SqlLike like = (SqlLike)node1;
SqlLike like2 = (SqlLike)node2;
if (!AreEqual(like.Expression, like2.Expression) || !AreEqual(like.Pattern, like2.Pattern))
{
return(false);
}
return(AreEqual(like.Escape, like2.Escape));
}
case SqlNodeType.Member:
if (((SqlMember)node1).Member != ((SqlMember)node2).Member)
{
return(false);
}
return(AreEqual(((SqlMember)node1).Expression, ((SqlMember)node2).Expression));
case SqlNodeType.OptionalValue:
{
SqlOptionalValue value2 = (SqlOptionalValue)node1;
SqlOptionalValue value3 = (SqlOptionalValue)node2;
return(AreEqual(value2.Value, value3.Value));
}
case SqlNodeType.Parameter:
return(node1 == node2);
case SqlNodeType.SearchedCase:
{
SqlSearchedCase case3 = (SqlSearchedCase)node1;
SqlSearchedCase case4 = (SqlSearchedCase)node2;
if (case3.Whens.Count == case4.Whens.Count)
{
int num7 = 0;
int num8 = case3.Whens.Count;
while (num7 < num8)
{
if (!AreEqual(case3.Whens[num7].Match, case4.Whens[num7].Match) ||
!AreEqual(case3.Whens[num7].Value, case4.Whens[num7].Value))
{
return(false);
}
num7++;
}
return(AreEqual(case3.Else, case4.Else));
}
return(false);
}
case SqlNodeType.SimpleCase:
{
SqlSimpleCase case7 = (SqlSimpleCase)node1;
SqlSimpleCase case8 = (SqlSimpleCase)node2;
if (case7.Whens.Count == case8.Whens.Count)
{
int num11 = 0;
int num12 = case7.Whens.Count;
while (num11 < num12)
{
if (!AreEqual(case7.Whens[num11].Match, case8.Whens[num11].Match) ||
!AreEqual(case7.Whens[num11].Value, case8.Whens[num11].Value))
{
return(false);
}
num11++;
}
return(true);
}
return(false);
}
case SqlNodeType.Table:
return(((SqlTable)node1).MetaTable == ((SqlTable)node2).MetaTable);
case SqlNodeType.TypeCase:
{
SqlTypeCase @case = (SqlTypeCase)node1;
SqlTypeCase case2 = (SqlTypeCase)node2;
if (AreEqual(@case.Discriminator, case2.Discriminator))
{
if (@case.Whens.Count != case2.Whens.Count)
{
return(false);
}
int num5 = 0;
int num6 = @case.Whens.Count;
while (num5 < num6)
{
if (!AreEqual(@case.Whens[num5].Match, case2.Whens[num5].Match))
{
return(false);
}
if (!AreEqual(@case.Whens[num5].TypeBinding, case2.Whens[num5].TypeBinding))
{
return(false);
}
num5++;
}
return(true);
}
return(false);
}
case SqlNodeType.Variable:
{
SqlVariable variable = (SqlVariable)node1;
SqlVariable variable2 = (SqlVariable)node2;
return(variable.Name == variable2.Name);
}
case SqlNodeType.Value:
return(object.Equals(((SqlValue)node1).Value, ((SqlValue)node2).Value));
}
}
return(false);
}