internal override SqlExpression VisitSearchedCase(SqlSearchedCase c) { for (int i = 0, n = c.Whens.Count; i < n; i++) { SqlWhen when = c.Whens[i]; when.Match = this.VisitPredicate(when.Match); when.Value = this.VisitExpression(when.Value); } c.Else = this.VisitExpression(c.Else); return c; }
internal override SqlExpression VisitSearchedCase(SqlSearchedCase c) { int num = 0; int count = c.Whens.Count; while (num < count) { SqlWhen when = c.Whens[num]; when.Match = this.VisitPredicate(when.Match); when.Value = this.VisitExpression(when.Value); num++; } c.Else = this.VisitExpression(c.Else); return(c); }
private SqlExpression TranslateVbIIF(SqlMethodCall mc) { //Check to see if the types can be implicitly converted from one to another. if (mc.Arguments[1].ClrType == mc.Arguments[2].ClrType) { List <SqlWhen> whens = new List <SqlWhen>(1); whens.Add(new SqlWhen(mc.Arguments[0], mc.Arguments[1])); SqlExpression @else = mc.Arguments[2]; while (@else.NodeType == SqlNodeType.SearchedCase) { SqlSearchedCase sc = (SqlSearchedCase)@else; whens.AddRange(sc.Whens); @else = sc.Else; } return(sql.SearchedCase(whens.ToArray(), @else, mc.SourceExpression)); } throw Error.IifReturnTypesMustBeEqual(mc.Arguments[1].ClrType.Name, mc.Arguments[2].ClrType.Name); }
internal override SqlExpression VisitSearchedCase(SqlSearchedCase c) { this.depth++; int num = 0; int count; SqlNode elseNode; if (c.Else != null) { elseNode = c.Else; count = c.Whens.Count; } else { elseNode = c.Whens[c.Whens.Count - 1].Match; count = c.Whens.Count - 1; } this.NewLine(); while (num < count) { SqlWhen when = c.Whens[num]; this.sb.Append("IIF("); this.Visit(when.Match); this.sb.Append(" , "); this.Visit(when.Value); this.sb.Append(" , "); num++; } if (c.Else != null) { this.Visit(elseNode); } for (int i = 0; i < count; i++) { sb.Append(")"); } this.NewLine(); this.depth--; return(c); }
internal override SqlExpression VisitSearchedCase(SqlSearchedCase c) { base.VisitSearchedCase(c); // determine the best common type for all the when and else values ProviderType type = c.Whens[0].Value.SqlType; for (int i = 1; i < c.Whens.Count; i++) { ProviderType whenType = c.Whens[i].Value.SqlType; type = typeProvider.GetBestType(type, whenType); } if (c.Else != null) { ProviderType elseType = c.Else.SqlType; type = typeProvider.GetBestType(type, elseType); } // coerce each one foreach (SqlWhen when in c.Whens.Where(w => w.Value.SqlType != type && !w.Value.SqlType.IsRuntimeOnlyType)) { when.Value = sql.UnaryConvert(when.Value.ClrType, type, when.Value, when.Value.SourceExpression); } if (c.Else != null && c.Else.SqlType != type && !c.Else.SqlType.IsRuntimeOnlyType) { c.Else = sql.UnaryConvert(c.Else.ClrType, type, c.Else, c.Else.SourceExpression); } return c; }
internal override SqlExpression VisitSearchedCase(SqlSearchedCase c) { this.depth++; this.NewLine(); sb.Append("(CASE "); this.depth++; for (int i = 0, n = c.Whens.Count; i < n; i++) { SqlWhen when = c.Whens[i]; this.NewLine(); sb.Append("WHEN "); this.Visit(when.Match); sb.Append(" THEN "); this.Visit(when.Value); } if (c.Else != null) { this.NewLine(); sb.Append("ELSE "); this.Visit(c.Else); } this.depth--; this.NewLine(); sb.Append(" END)"); this.depth--; return c; }
internal override SqlExpression VisitSearchedCase(SqlSearchedCase c) { bool saveCanJoin = this.canJoin; this.canJoin = false; try { return base.VisitSearchedCase(c); } finally { this.canJoin = saveCanJoin; } }
internal static bool AreEqual(SqlNode node1, SqlNode node2) { if (node1 == node2) { return(true); } if (node1 == null || node2 == null) { return(false); } if (node1.NodeType == SqlNodeType.SimpleCase) { node1 = UnwrapTrivialCaseExpression((SqlSimpleCase)node1); } if (node2.NodeType == SqlNodeType.SimpleCase) { node2 = UnwrapTrivialCaseExpression((SqlSimpleCase)node2); } if (node1.NodeType != node2.NodeType) { // allow expression sets to compare against single expressions if (node1.NodeType == SqlNodeType.ExprSet) { SqlExprSet eset = (SqlExprSet)node1; for (int i = 0, n = eset.Expressions.Count; i < n; i++) { if (AreEqual(eset.Expressions[i], node2)) { return(true); } } } else if (node2.NodeType == SqlNodeType.ExprSet) { SqlExprSet eset = (SqlExprSet)node2; for (int i = 0, n = eset.Expressions.Count; i < n; i++) { if (AreEqual(node1, eset.Expressions[i])) { return(true); } } } return(false); } if (node1.Equals(node2)) { return(true); } switch (node1.NodeType) { case SqlNodeType.Not: case SqlNodeType.Not2V: case SqlNodeType.Negate: case SqlNodeType.BitNot: case SqlNodeType.IsNull: case SqlNodeType.IsNotNull: case SqlNodeType.Count: case SqlNodeType.Max: case SqlNodeType.Min: case SqlNodeType.Sum: case SqlNodeType.Avg: case SqlNodeType.Stddev: case SqlNodeType.ValueOf: case SqlNodeType.OuterJoinedValue: case SqlNodeType.ClrLength: return(AreEqual(((SqlUnary)node1).Operand, ((SqlUnary)node2).Operand)); 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.And: case SqlNodeType.Or: case SqlNodeType.GE: case SqlNodeType.GT: case SqlNodeType.LE: case SqlNodeType.LT: case SqlNodeType.EQ: case SqlNodeType.NE: case SqlNodeType.EQ2V: case SqlNodeType.NE2V: case SqlNodeType.Concat: SqlBinary firstNode = (SqlBinary)node1; SqlBinary secondNode = (SqlBinary)node2; return(AreEqual(firstNode.Left, secondNode.Left) && AreEqual(firstNode.Right, secondNode.Right)); case SqlNodeType.Convert: case SqlNodeType.Treat: { SqlUnary sun1 = (SqlUnary)node1; SqlUnary sun2 = (SqlUnary)node2; return(sun1.ClrType == sun2.ClrType && sun1.SqlType == sun2.SqlType && AreEqual(sun1.Operand, sun2.Operand)); } case SqlNodeType.Between: { SqlBetween b1 = (SqlBetween)node1; SqlBetween b2 = (SqlBetween)node1; return(AreEqual(b1.Expression, b2.Expression) && AreEqual(b1.Start, b2.Start) && AreEqual(b1.End, b2.End)); } case SqlNodeType.Parameter: return(node1 == node2); case SqlNodeType.Alias: return(AreEqual(((SqlAlias)node1).Node, ((SqlAlias)node2).Node)); case SqlNodeType.AliasRef: return(AreEqual(((SqlAliasRef)node1).Alias, ((SqlAliasRef)node2).Alias)); case SqlNodeType.Column: SqlColumn col1 = (SqlColumn)node1; SqlColumn col2 = (SqlColumn)node2; return(col1 == col2 || (col1.Expression != null && col2.Expression != null && AreEqual(col1.Expression, col2.Expression))); case SqlNodeType.Table: return(((SqlTable)node1).MetaTable == ((SqlTable)node2).MetaTable); case SqlNodeType.Member: return((((SqlMember)node1).Member == ((SqlMember)node2).Member) && AreEqual(((SqlMember)node1).Expression, ((SqlMember)node2).Expression)); case SqlNodeType.ColumnRef: SqlColumnRef cref1 = (SqlColumnRef)node1; SqlColumnRef cref2 = (SqlColumnRef)node2; return(GetBaseColumn(cref1) == GetBaseColumn(cref2)); case SqlNodeType.Value: return(Object.Equals(((SqlValue)node1).Value, ((SqlValue)node2).Value)); case SqlNodeType.TypeCase: { SqlTypeCase c1 = (SqlTypeCase)node1; SqlTypeCase c2 = (SqlTypeCase)node2; if (!AreEqual(c1.Discriminator, c2.Discriminator)) { return(false); } if (c1.Whens.Count != c2.Whens.Count) { return(false); } for (int i = 0, c = c1.Whens.Count; i < c; ++i) { if (!AreEqual(c1.Whens[i].Match, c2.Whens[i].Match)) { return(false); } if (!AreEqual(c1.Whens[i].TypeBinding, c2.Whens[i].TypeBinding)) { return(false); } } return(true); } case SqlNodeType.SearchedCase: { SqlSearchedCase c1 = (SqlSearchedCase)node1; SqlSearchedCase c2 = (SqlSearchedCase)node2; if (c1.Whens.Count != c2.Whens.Count) { return(false); } for (int i = 0, n = c1.Whens.Count; i < n; i++) { if (!AreEqual(c1.Whens[i].Match, c2.Whens[i].Match) || !AreEqual(c1.Whens[i].Value, c2.Whens[i].Value)) { return(false); } } return(AreEqual(c1.Else, c2.Else)); } case SqlNodeType.ClientCase: { SqlClientCase c1 = (SqlClientCase)node1; SqlClientCase c2 = (SqlClientCase)node2; if (c1.Whens.Count != c2.Whens.Count) { return(false); } for (int i = 0, n = c1.Whens.Count; i < n; i++) { if (!AreEqual(c1.Whens[i].Match, c2.Whens[i].Match) || !AreEqual(c1.Whens[i].Value, c2.Whens[i].Value)) { return(false); } } return(true); } case SqlNodeType.DiscriminatedType: { SqlDiscriminatedType dt1 = (SqlDiscriminatedType)node1; SqlDiscriminatedType dt2 = (SqlDiscriminatedType)node2; return(AreEqual(dt1.Discriminator, dt2.Discriminator)); } case SqlNodeType.SimpleCase: { SqlSimpleCase c1 = (SqlSimpleCase)node1; SqlSimpleCase c2 = (SqlSimpleCase)node2; if (c1.Whens.Count != c2.Whens.Count) { return(false); } for (int i = 0, n = c1.Whens.Count; i < n; i++) { if (!AreEqual(c1.Whens[i].Match, c2.Whens[i].Match) || !AreEqual(c1.Whens[i].Value, c2.Whens[i].Value)) { return(false); } } return(true); } case SqlNodeType.Like: { SqlLike like1 = (SqlLike)node1; SqlLike like2 = (SqlLike)node2; return(AreEqual(like1.Expression, like2.Expression) && AreEqual(like1.Pattern, like2.Pattern) && AreEqual(like1.Escape, like2.Escape)); } case SqlNodeType.Variable: { SqlVariable v1 = (SqlVariable)node1; SqlVariable v2 = (SqlVariable)node2; return(v1.Name == v2.Name); } case SqlNodeType.FunctionCall: { SqlFunctionCall f1 = (SqlFunctionCall)node1; SqlFunctionCall f2 = (SqlFunctionCall)node2; if (f1.Name != f2.Name) { return(false); } if (f1.Arguments.Count != f2.Arguments.Count) { return(false); } for (int i = 0, n = f1.Arguments.Count; i < n; i++) { if (!AreEqual(f1.Arguments[i], f2.Arguments[i])) { return(false); } } return(true); } case SqlNodeType.Link: { SqlLink l1 = (SqlLink)node1; SqlLink l2 = (SqlLink)node2; if (!MetaPosition.AreSameMember(l1.Member.Member, l2.Member.Member)) { return(false); } if (!AreEqual(l1.Expansion, l2.Expansion)) { return(false); } if (l1.KeyExpressions.Count != l2.KeyExpressions.Count) { return(false); } for (int i = 0, c = l1.KeyExpressions.Count; i < c; ++i) { if (!AreEqual(l1.KeyExpressions[i], l2.KeyExpressions[i])) { return(false); } } return(true); } case SqlNodeType.ExprSet: SqlExprSet es1 = (SqlExprSet)node1; SqlExprSet es2 = (SqlExprSet)node2; if (es1.Expressions.Count != es2.Expressions.Count) { return(false); } for (int i = 0, n = es1.Expressions.Count; i < n; i++) { if (!AreEqual(es1.Expressions[i], es2.Expressions[i])) { return(false); } } return(true); case SqlNodeType.OptionalValue: SqlOptionalValue ov1 = (SqlOptionalValue)node1; SqlOptionalValue ov2 = (SqlOptionalValue)node2; return(AreEqual(ov1.Value, ov2.Value)); case SqlNodeType.Row: case SqlNodeType.UserQuery: case SqlNodeType.StoredProcedureCall: case SqlNodeType.UserRow: case SqlNodeType.UserColumn: case SqlNodeType.Multiset: case SqlNodeType.ScalarSubSelect: case SqlNodeType.Element: case SqlNodeType.Exists: case SqlNodeType.Join: case SqlNodeType.Select: case SqlNodeType.New: case SqlNodeType.ClientQuery: case SqlNodeType.ClientArray: case SqlNodeType.Insert: case SqlNodeType.Update: case SqlNodeType.Delete: case SqlNodeType.MemberAssign: case SqlNodeType.Assign: case SqlNodeType.Block: case SqlNodeType.Union: case SqlNodeType.DoNotVisit: case SqlNodeType.MethodCall: case SqlNodeType.Nop: default: return(false); } }
internal override SqlExpression VisitSearchedCase(SqlSearchedCase c) { SqlExpression @else = this.VisitExpression(c.Else); SqlWhen[] whens = new SqlWhen[c.Whens.Count]; for (int i = 0, n = whens.Length; i < n; i++) { SqlWhen when = c.Whens[i]; whens[i] = new SqlWhen(this.VisitExpression(when.Match), this.VisitExpression(when.Value)); } return new SqlSearchedCase(c.ClrType, whens, @else, c.SourceExpression); }
internal override SqlExpression VisitUnaryOperator(SqlUnary uo) { uo.Operand = this.VisitExpression(uo.Operand); // ------------------------------------------------------------ // PHASE 1: If possible, evaluate without fetching the operand. // This is preferred because fetching LINKs causes them to not // be deferred. // ------------------------------------------------------------ if (uo.NodeType == SqlNodeType.IsNull || uo.NodeType == SqlNodeType.IsNotNull) { SqlExpression translated = this.translator.TranslateLinkIsNull(uo); if (translated != uo) { return this.VisitExpression(translated); } if (uo.Operand.NodeType==SqlNodeType.OuterJoinedValue) { SqlUnary ojv = uo.Operand as SqlUnary; if (ojv.Operand.NodeType == SqlNodeType.OptionalValue) { SqlOptionalValue ov = (SqlOptionalValue)ojv.Operand; return this.VisitUnaryOperator( new SqlUnary(uo.NodeType, uo.ClrType, uo.SqlType, new SqlUnary(SqlNodeType.OuterJoinedValue, ov.ClrType, ov.SqlType, ov.HasValue, ov.SourceExpression) , uo.SourceExpression) ); } else if (ojv.Operand.NodeType == SqlNodeType.TypeCase) { SqlTypeCase tc = (SqlTypeCase)ojv.Operand; return new SqlUnary(uo.NodeType, uo.ClrType, uo.SqlType, new SqlUnary(SqlNodeType.OuterJoinedValue, tc.Discriminator.ClrType, tc.Discriminator.SqlType, tc.Discriminator, tc.SourceExpression), uo.SourceExpression ); } } } // Fetch the expression. uo.Operand = this.ConvertToFetchedExpression(uo.Operand); // ------------------------------------------------------------ // PHASE 2: Evaluate operator on fetched expression. // ------------------------------------------------------------ if ((uo.NodeType == SqlNodeType.Not || uo.NodeType == SqlNodeType.Not2V) && uo.Operand.NodeType == SqlNodeType.Value) { SqlValue val = (SqlValue)uo.Operand; return sql.Value(typeof(bool), val.SqlType, !(bool)val.Value, val.IsClientSpecified, val.SourceExpression); } else if (uo.NodeType == SqlNodeType.Not2V) { if (SqlExpressionNullability.CanBeNull(uo.Operand) != false) { SqlSearchedCase c = new SqlSearchedCase( typeof(int), new [] { new SqlWhen(uo.Operand, sql.ValueFromObject(1, false, uo.SourceExpression)) }, sql.ValueFromObject(0, false, uo.SourceExpression), uo.SourceExpression ); return sql.Binary(SqlNodeType.EQ, c, sql.ValueFromObject(0, false, uo.SourceExpression)); } else { return sql.Unary(SqlNodeType.Not, uo.Operand); } } // push converts of client-expressions inside the client-expression (to be evaluated client side) else if (uo.NodeType == SqlNodeType.Convert && uo.Operand.NodeType == SqlNodeType.Value) { SqlValue val = (SqlValue)uo.Operand; return sql.Value(uo.ClrType, uo.SqlType, DBConvert.ChangeType(val.Value, uo.ClrType), val.IsClientSpecified, val.SourceExpression); } else if (uo.NodeType == SqlNodeType.IsNull || uo.NodeType == SqlNodeType.IsNotNull) { bool? canBeNull = SqlExpressionNullability.CanBeNull(uo.Operand); if (canBeNull == false) { return sql.ValueFromObject(uo.NodeType == SqlNodeType.IsNotNull, false, uo.SourceExpression); } SqlExpression exp = uo.Operand; switch (exp.NodeType) { case SqlNodeType.Element: exp = sql.SubSelect(SqlNodeType.Exists, ((SqlSubSelect)exp).Select); if (uo.NodeType == SqlNodeType.IsNull) { exp = sql.Unary(SqlNodeType.Not, exp, exp.SourceExpression); } return exp; case SqlNodeType.ClientQuery: { SqlClientQuery cq = (SqlClientQuery)exp; if (cq.Query.NodeType == SqlNodeType.Element) { exp = sql.SubSelect(SqlNodeType.Exists, cq.Query.Select); if (uo.NodeType == SqlNodeType.IsNull) { exp = sql.Unary(SqlNodeType.Not, exp, exp.SourceExpression); } return exp; } return sql.ValueFromObject(uo.NodeType == SqlNodeType.IsNotNull, false, uo.SourceExpression); } case SqlNodeType.OptionalValue: uo.Operand = ((SqlOptionalValue)exp).HasValue; return uo; case SqlNodeType.ClientCase: { // Distribute unary into simple case. SqlClientCase sc = (SqlClientCase)uo.Operand; List<SqlExpression> matches = new List<SqlExpression>(); List<SqlExpression> values = new List<SqlExpression>(); foreach (SqlClientWhen when in sc.Whens) { matches.Add(when.Match); values.Add(VisitUnaryOperator(sql.Unary(uo.NodeType, when.Value, when.Value.SourceExpression))); } return sql.Case(sc.ClrType, sc.Expression, matches, values, sc.SourceExpression); } case SqlNodeType.TypeCase: { // Distribute unary into type case. In the process, convert to simple case. SqlTypeCase tc = (SqlTypeCase)uo.Operand; List<SqlExpression> newMatches = new List<SqlExpression>(); List<SqlExpression> newValues = new List<SqlExpression>(); foreach (SqlTypeCaseWhen when in tc.Whens) { SqlUnary un = new SqlUnary(uo.NodeType, uo.ClrType, uo.SqlType, when.TypeBinding, when.TypeBinding.SourceExpression); SqlExpression expr = VisitUnaryOperator(un); if (expr is SqlNew) { throw Error.DidNotExpectTypeBinding(); } newMatches.Add(when.Match); newValues.Add(expr); } return sql.Case(uo.ClrType, tc.Discriminator, newMatches, newValues, tc.SourceExpression); } case SqlNodeType.Value: { SqlValue val = (SqlValue)uo.Operand; return sql.Value(typeof(bool), this.typeProvider.From(typeof(int)), (val.Value == null) == (uo.NodeType == SqlNodeType.IsNull), val.IsClientSpecified, uo.SourceExpression); } } } else if (uo.NodeType == SqlNodeType.Treat) { return ApplyTreat(VisitExpression(uo.Operand), uo.ClrType); } return uo; }
internal override SqlExpression VisitSearchedCase(SqlSearchedCase c) { if ((c.ClrType == typeof(bool) || c.ClrType == typeof(bool?)) && c.Whens.Count == 1 && c.Else != null) { SqlValue litElse = c.Else as SqlValue; SqlValue litWhen = c.Whens[0].Value as SqlValue; if (litElse != null && litElse.Value != null && !(bool)litElse.Value) { return this.VisitExpression(sql.Binary(SqlNodeType.And, c.Whens[0].Match, c.Whens[0].Value)); } else if (litWhen != null && litWhen.Value != null && (bool)litWhen.Value) { return this.VisitExpression(sql.Binary(SqlNodeType.Or, c.Whens[0].Match, c.Else)); } } return base.VisitSearchedCase(c); }
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); }
internal static bool CanBeCompared(SqlExpression node) { if (node == null) { return(true); } switch (node.NodeType) { case SqlNodeType.New: { SqlNew new1 = (SqlNew)node; for (int i = 0, n = new1.Args.Count; i < n; i++) { if (!CanBeCompared(new1.Args[i])) { return(false); } } for (int i = 0, n = new1.Members.Count; i < n; i++) { if (!CanBeCompared(new1.Members[i].Expression)) { return(false); } } return(true); } case SqlNodeType.ColumnRef: case SqlNodeType.Value: case SqlNodeType.UserColumn: return(true); case SqlNodeType.Link: { SqlLink l1 = (SqlLink)node; for (int i = 0, c = l1.KeyExpressions.Count; i < c; ++i) { if (!CanBeCompared(l1.KeyExpressions[i])) { return(false); } } return(true); } case SqlNodeType.OptionalValue: return(CanBeCompared(((SqlOptionalValue)node).Value)); case SqlNodeType.ValueOf: case SqlNodeType.OuterJoinedValue: return(CanBeCompared(((SqlUnary)node).Operand)); case SqlNodeType.Lift: return(CanBeCompared(((SqlLift)node).Expression)); case SqlNodeType.Grouping: { SqlGrouping g1 = (SqlGrouping)node; return(CanBeCompared(g1.Key) && CanBeCompared(g1.Group)); } case SqlNodeType.ClientArray: { if (node.SourceExpression.NodeType != ExpressionType.NewArrayInit && node.SourceExpression.NodeType != ExpressionType.NewArrayBounds) { return(false); } SqlClientArray a1 = (SqlClientArray)node; for (int i = 0, n = a1.Expressions.Count; i < n; i++) { if (!CanBeCompared(a1.Expressions[i])) { return(false); } } return(true); } case SqlNodeType.ClientCase: { SqlClientCase c1 = (SqlClientCase)node; for (int i = 0, n = c1.Whens.Count; i < n; i++) { if (!CanBeCompared(c1.Whens[i].Match) || !CanBeCompared(c1.Whens[i].Value)) { return(false); } } return(true); } case SqlNodeType.SearchedCase: { SqlSearchedCase c1 = (SqlSearchedCase)node; for (int i = 0, n = c1.Whens.Count; i < n; i++) { if (!CanBeCompared(c1.Whens[i].Match) || !CanBeCompared(c1.Whens[i].Value)) { return(false); } } return(CanBeCompared(c1.Else)); } case SqlNodeType.TypeCase: { SqlTypeCase c1 = (SqlTypeCase)node; if (!CanBeCompared(c1.Discriminator)) { return(false); } for (int i = 0, c = c1.Whens.Count; i < c; ++i) { if (!CanBeCompared(c1.Whens[i].Match)) { return(false); } if (!CanBeCompared(c1.Whens[i].TypeBinding)) { return(false); } } return(true); } case SqlNodeType.DiscriminatedType: return(CanBeCompared(((SqlDiscriminatedType)node).Discriminator)); case SqlNodeType.JoinedCollection: { SqlJoinedCollection j1 = (SqlJoinedCollection)node; return(CanBeCompared(j1.Count) && CanBeCompared(j1.Expression)); } case SqlNodeType.Member: return(CanBeCompared(((SqlMember)node).Expression)); case SqlNodeType.MethodCall: { SqlMethodCall mc = (SqlMethodCall)node; if (mc.Object != null && !CanBeCompared(mc.Object)) { return(false); } for (int i = 0, n = mc.Arguments.Count; i < n; i++) { if (!CanBeCompared(mc.Arguments[0])) { return(false); } } return(true); } case SqlNodeType.ClientQuery: return(true); case SqlNodeType.ClientParameter: default: return(false); } }
internal static bool AreSimilar(SqlExpression node1, SqlExpression node2) { if (node1 == node2) { return(true); } if (node1 == null || node2 == null) { return(false); } if (node1.NodeType != node2.NodeType || node1.ClrType != node2.ClrType || node1.SqlType != node2.SqlType) { return(false); } switch (node1.NodeType) { case SqlNodeType.New: { SqlNew new1 = (SqlNew)node1; SqlNew new2 = (SqlNew)node2; if (new1.Args.Count != new2.Args.Count || new1.Members.Count != new2.Members.Count) { return(false); } for (int i = 0, n = new1.Args.Count; i < n; i++) { if (!AreSimilar(new1.Args[i], new2.Args[i])) { return(false); } } for (int i = 0, n = new1.Members.Count; i < n; i++) { if (!MetaPosition.AreSameMember(new1.Members[i].Member, new2.Members[i].Member) || !AreSimilar(new1.Members[i].Expression, new2.Members[i].Expression)) { return(false); } } return(true); } case SqlNodeType.ColumnRef: { SqlColumnRef cref1 = (SqlColumnRef)node1; SqlColumnRef cref2 = (SqlColumnRef)node2; return(cref1.Column.Ordinal == cref2.Column.Ordinal); } case SqlNodeType.Link: { SqlLink l1 = (SqlLink)node1; SqlLink l2 = (SqlLink)node2; if (!MetaPosition.AreSameMember(l1.Member.Member, l2.Member.Member)) { return(false); } if (l1.KeyExpressions.Count != l2.KeyExpressions.Count) { return(false); } for (int i = 0, c = l1.KeyExpressions.Count; i < c; ++i) { if (!AreSimilar(l1.KeyExpressions[i], l2.KeyExpressions[i])) { return(false); } } return(true); } case SqlNodeType.Value: return(Object.Equals(((SqlValue)node1).Value, ((SqlValue)node2).Value)); case SqlNodeType.OptionalValue: { SqlOptionalValue ov1 = (SqlOptionalValue)node1; SqlOptionalValue ov2 = (SqlOptionalValue)node2; return(AreSimilar(ov1.Value, ov2.Value)); } case SqlNodeType.ValueOf: case SqlNodeType.OuterJoinedValue: return(AreSimilar(((SqlUnary)node1).Operand, ((SqlUnary)node2).Operand)); case SqlNodeType.Lift: return(AreSimilar(((SqlLift)node1).Expression, ((SqlLift)node2).Expression)); case SqlNodeType.Grouping: { SqlGrouping g1 = (SqlGrouping)node1; SqlGrouping g2 = (SqlGrouping)node2; return(AreSimilar(g1.Key, g2.Key) && AreSimilar(g1.Group, g2.Group)); } case SqlNodeType.ClientArray: { SqlClientArray a1 = (SqlClientArray)node1; SqlClientArray a2 = (SqlClientArray)node2; if (a1.Expressions.Count != a2.Expressions.Count) { return(false); } for (int i = 0, n = a1.Expressions.Count; i < n; i++) { if (!AreSimilar(a1.Expressions[i], a2.Expressions[i])) { return(false); } } return(true); } case SqlNodeType.UserColumn: return(((SqlUserColumn)node1).Name == ((SqlUserColumn)node2).Name); case SqlNodeType.ClientCase: { SqlClientCase c1 = (SqlClientCase)node1; SqlClientCase c2 = (SqlClientCase)node2; if (c1.Whens.Count != c2.Whens.Count) { return(false); } for (int i = 0, n = c1.Whens.Count; i < n; i++) { if (!AreSimilar(c1.Whens[i].Match, c2.Whens[i].Match) || !AreSimilar(c1.Whens[i].Value, c2.Whens[i].Value)) { return(false); } } return(true); } case SqlNodeType.SearchedCase: { SqlSearchedCase c1 = (SqlSearchedCase)node1; SqlSearchedCase c2 = (SqlSearchedCase)node2; if (c1.Whens.Count != c2.Whens.Count) { return(false); } for (int i = 0, n = c1.Whens.Count; i < n; i++) { if (!AreSimilar(c1.Whens[i].Match, c2.Whens[i].Match) || !AreSimilar(c1.Whens[i].Value, c2.Whens[i].Value)) { return(false); } } return(AreSimilar(c1.Else, c2.Else)); } case SqlNodeType.TypeCase: { SqlTypeCase c1 = (SqlTypeCase)node1; SqlTypeCase c2 = (SqlTypeCase)node2; if (!AreSimilar(c1.Discriminator, c2.Discriminator)) { return(false); } if (c1.Whens.Count != c2.Whens.Count) { return(false); } for (int i = 0, c = c1.Whens.Count; i < c; ++i) { if (!AreSimilar(c1.Whens[i].Match, c2.Whens[i].Match)) { return(false); } if (!AreSimilar(c1.Whens[i].TypeBinding, c2.Whens[i].TypeBinding)) { return(false); } } return(true); } case SqlNodeType.DiscriminatedType: { SqlDiscriminatedType dt1 = (SqlDiscriminatedType)node1; SqlDiscriminatedType dt2 = (SqlDiscriminatedType)node2; return(AreSimilar(dt1.Discriminator, dt2.Discriminator)); } case SqlNodeType.JoinedCollection: { SqlJoinedCollection j1 = (SqlJoinedCollection)node1; SqlJoinedCollection j2 = (SqlJoinedCollection)node2; return(AreSimilar(j1.Count, j2.Count) && AreSimilar(j1.Expression, j2.Expression)); } case SqlNodeType.Member: { SqlMember m1 = (SqlMember)node1; SqlMember m2 = (SqlMember)node2; return(m1.Member == m2.Member && AreSimilar(m1.Expression, m2.Expression)); } case SqlNodeType.ClientQuery: { SqlClientQuery cq1 = (SqlClientQuery)node1; SqlClientQuery cq2 = (SqlClientQuery)node2; if (cq1.Arguments.Count != cq2.Arguments.Count) { return(false); } for (int i = 0, n = cq1.Arguments.Count; i < n; i++) { if (!AreSimilar(cq1.Arguments[i], cq2.Arguments[i])) { return(false); } } return(true); } case SqlNodeType.MethodCall: { SqlMethodCall mc1 = (SqlMethodCall)node1; SqlMethodCall mc2 = (SqlMethodCall)node2; if (mc1.Method != mc2.Method || !AreSimilar(mc1.Object, mc2.Object)) { return(false); } if (mc1.Arguments.Count != mc2.Arguments.Count) { return(false); } for (int i = 0, n = mc1.Arguments.Count; i < n; i++) { if (!AreSimilar(mc1.Arguments[i], mc2.Arguments[i])) { return(false); } } return(true); } case SqlNodeType.ClientParameter: default: return(false); } }