95return Binary(SqlNodeType.And, left, right); 107return Binary(SqlNodeType.Or, left, right); 114result = Binary(SqlNodeType.Concat, expressions[i], result); 122sum = Binary(SqlNodeType.Add, expressions[i], sum); 128return Binary(SqlNodeType.Sub, first, second); 134result = Binary(SqlNodeType.Mul, expressions[i], result); 140return Binary(SqlNodeType.Div, first, second); 144return Binary(SqlNodeType.Add, expr, ValueFromObject(second, false, expr.SourceExpression)); 148return Binary(SqlNodeType.Sub, expr, ValueFromObject(second, false, expr.SourceExpression)); 152return Binary(SqlNodeType.Mul, expr, ValueFromObject(second, false, expr.SourceExpression)); 156return Binary(SqlNodeType.Div, expr, ValueFromObject(second, false, expr.SourceExpression)); 160return Binary(SqlNodeType.Mod, expr, ValueFromObject(second, false, expr.SourceExpression)); 184return Unary(SqlNodeType.ClrLength, expr); 320internal SqlUnary Unary(SqlNodeType nodeType, SqlExpression expression) { 328internal SqlUnary Unary(SqlNodeType nodeType, SqlExpression expression, Expression sourceExpression) { 332internal SqlUnary Unary(SqlNodeType nodeType, SqlExpression expression, MethodInfo method, Expression sourceExpression) { 336if (nodeType == SqlNodeType.Count) { 340else if (nodeType == SqlNodeType.LongCount) { 344else if (nodeType == SqlNodeType.ClrLength) { 365return new SqlUnary(SqlNodeType.Convert, targetClrType, targetSqlType, expression, null, sourceExpression); 371return new SqlUnary(SqlNodeType.ValueOf, valueType, expression.SqlType, expression, null, sourceExpression); 374internal SqlBinary Binary(SqlNodeType nodeType, SqlExpression left, SqlExpression right) { 378internal SqlBinary Binary(SqlNodeType nodeType, SqlExpression left, SqlExpression right, MethodInfo method) { 382internal SqlBinary Binary(SqlNodeType nodeType, SqlExpression left, SqlExpression right, Type clrType) { 386internal SqlBinary Binary(SqlNodeType nodeType, SqlExpression left, SqlExpression right, MethodInfo method, Type clrType) { 534internal SqlSubSelect SubSelect(SqlNodeType nt, SqlSelect select) { 537internal SqlSubSelect SubSelect(SqlNodeType nt, SqlSelect select, Type clrType) { 540case SqlNodeType.ScalarSubSelect: 541case SqlNodeType.Element: 545case SqlNodeType.Multiset: 551case SqlNodeType.Exists: 597if (sel != null && sel.Selection != null && sel.Selection.NodeType != SqlNodeType.OptionalValue) { 602this.Unary(SqlNodeType.OuterJoinedValue,

114private SqlNodeType nodeType; 117internal SqlNode(SqlNodeType nodeType, Expression sourceExpression) { 130internal SqlNodeType NodeType { 153internal SqlExpression(SqlNodeType nodeType, Type clrType, Expression sourceExpression) 174if (this.NodeType == SqlNodeType.Column) { 180else if (this.NodeType == SqlNodeType.ColumnRef) { 183else if (this.NodeType == SqlNodeType.OptionalValue) { 186else if (this.NodeType == SqlNodeType.Value || 187this.NodeType == SqlNodeType.Parameter) { 201internal SqlSimpleTypeExpression(SqlNodeType nodeType, Type clrType, ProviderType sqlType, Expression sourceExpression) 218: base(SqlNodeType.DiscriminatorOf, clrType, sqlType, sourceExpression) { 236: base(SqlNodeType.DiscriminatedType, 259internal SqlStatement(SqlNodeType nodeType, Expression sourceExpression) 265internal SqlSource(SqlNodeType nt, Expression sourceExpression) 285: base(SqlNodeType.Select, sourceExpression) { 385: base(SqlNodeType.Table, sourceExpression) { 428internal SqlUserQuery(SqlNodeType nt, SqlExpression projection, IEnumerable<SqlExpression> args, Expression source) 436: base(SqlNodeType.UserQuery, source) { 477: base(SqlNodeType.StoredProcedureCall, projection, args, source) { 493: base(SqlNodeType.UserRow, rowType.Type, sqlType, source) { 520: base(SqlNodeType.UserColumn, clrType, sqlType, source) { 551: base(SqlNodeType.Alias, node.SourceExpression) { 576: base(SqlNodeType.AliasRef, GetClrType(alias.Node), alias.SourceExpression) { 636: base(SqlNodeType.Join, sourceExpression) { 686: base(SqlNodeType.Union, right.SourceExpression) { 744: base(SqlNodeType.Nop, clrType, sqlType, sourceExpression) { 752: base(SqlNodeType.Lift, type, sourceExpression) { 876: base(SqlNodeType.RowNumber, clrType, sqlType, sourceExpression) { 890internal SqlUnary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression expr, Expression sourceExpression) 894internal SqlUnary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression expr, MethodInfo method, Expression sourceExpression) 897case SqlNodeType.Not: 898case SqlNodeType.Not2V: 899case SqlNodeType.Negate: 900case SqlNodeType.BitNot: 901case SqlNodeType.IsNull: 902case SqlNodeType.IsNotNull: 903case SqlNodeType.Count: 904case SqlNodeType.LongCount: 905case SqlNodeType.Max: 906case SqlNodeType.Min: 907case SqlNodeType.Sum: 908case SqlNodeType.Avg: 909case SqlNodeType.Stddev: 910case SqlNodeType.Convert: 911case SqlNodeType.ValueOf: 912case SqlNodeType.Treat: 913case SqlNodeType.OuterJoinedValue: 914case SqlNodeType.ClrLength: 926if (value == null && (this.NodeType != SqlNodeType.Count && this.NodeType != SqlNodeType.LongCount)) 943internal SqlBinary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression left, SqlExpression right) 947internal SqlBinary(SqlNodeType nt, Type clrType, ProviderType sqlType, SqlExpression left, SqlExpression right, MethodInfo method) 950case SqlNodeType.Add: 951case SqlNodeType.Sub: 952case SqlNodeType.Mul: 953case SqlNodeType.Div: 954case SqlNodeType.Mod: 955case SqlNodeType.BitAnd: 956case SqlNodeType.BitOr: 957case SqlNodeType.BitXor: 958case SqlNodeType.And: 959case SqlNodeType.Or: 960case SqlNodeType.GE: 961case SqlNodeType.GT: 962case SqlNodeType.LE: 963case SqlNodeType.LT: 964case SqlNodeType.EQ: 965case SqlNodeType.NE: 966case SqlNodeType.EQ2V: 967case SqlNodeType.NE2V: 968case SqlNodeType.Concat: 969case SqlNodeType.Coalesce: 1008: base(SqlNodeType.Between, clrType, sqlType, source) { 1035:base(SqlNodeType.In, clrType, sqlType, sourceExpression) { 1060: base(SqlNodeType.Like, clrType, sqlType, source) { 1153: base(SqlNodeType.SearchedCase, clrType, sourceExpression) { 1197: base(SqlNodeType.SimpleCase, clrType, sourceExpression) { 1241: base(SqlNodeType.ClientCase, clrType, sourceExpression) { 1321: base(SqlNodeType.TypeCase, clrType, sourceExpression) { 1388: base(SqlNodeType.Value, clrType, sqlType, sourceExpression) { 1407: base(SqlNodeType.Parameter, clrType, sqlType, sourceExpression) { 1430: base(SqlNodeType.Variable, clrType, sqlType, sourceExpression) { 1446: base(SqlNodeType.Member, clrType, sqlType, expr.SourceExpression) { 1479: base(SqlNodeType.Column, clrType, sourceExpression) { 1547: base(SqlNodeType.ColumnRef, col.ClrType, col.SourceExpression) { 1570while (c.Expression != null && c.Expression.NodeType == SqlNodeType.ColumnRef) { 1581: base(SqlNodeType.Row, sourceExpression) { 1603: base(SqlNodeType.MemberAssign, expr.SourceExpression) { 1629: base(SqlNodeType.Grouping, clrType, sqlType, sourceExpression) { 1668: base(SqlNodeType.New, metaType.Type, sqlType, sourceExpression) { 1733: base(SqlNodeType.MethodCall, clrType, sqlType, sourceExpression) { 1766: base(SqlNodeType.IncludeScope, sourceExpression) { 1779: base(SqlNodeType.ClientArray, clrType, sqlType, sourceExpression) { 1799: base(SqlNodeType.Link, clrType, sqlType, sourceExpression) { 1842: base(SqlNodeType.ExprSet, clrType, sourceExpression) { 1870internal SqlSubSelect(SqlNodeType nt , Type clrType, ProviderType sqlType , SqlSelect select) 1873case SqlNodeType.Multiset: 1874case SqlNodeType.ScalarSubSelect: 1875case SqlNodeType.Element: 1876case SqlNodeType.Exists: 1901: base(SqlNodeType.ClientQuery, subquery.ClrType, subquery.SqlType, subquery.SourceExpression) { 1935: base(SqlNodeType.JoinedCollection, clrType, sqlType, sourceExpression) { 1966: base(SqlNodeType.Update, sourceExpression) { 1993: base(SqlNodeType.Insert, sourceExpression) { 2039: base(SqlNodeType.Delete, sourceExpression) { 2057: base(SqlNodeType.Block, sourceExpression) { 2071: base(SqlNodeType.Assign, sourceExpression) { 2103: base(SqlNodeType.DoNotVisit, expr.ClrType, expr.SourceExpression) { 2123: base(SqlNodeType.OptionalValue, value.ClrType, value.SqlType, value.SourceExpression) { 2154: this(SqlNodeType.FunctionCall, clrType , sqlType, name, args, source) { 2157internal SqlFunctionCall(SqlNodeType nodeType, Type clrType, ProviderType sqlType, string name , IEnumerable <SqlExpression> args , Expression source) 2181: base(SqlNodeType.TableValuedFunctionCall, clrType , sqlType, name, args, source) { 2208: base(SqlNodeType.SharedExpression, expr.ClrType, expr.SourceExpression) { 2233: base(SqlNodeType.SharedExpressionRef, expr.ClrType, expr.SourceExpression) { 2250: base(SqlNodeType.SimpleExpression, expr.ClrType, expr.SourceExpression) { 2274base(SqlNodeType.ClientParameter, clrType, sqlType, sourceExpression) {

14internal static bool IsPredicateUnaryOperator(this SqlNodeType nodeType) { 16case SqlNodeType.Not: 17case SqlNodeType.Not2V: 18case SqlNodeType.IsNull: 19case SqlNodeType.IsNotNull: 21case SqlNodeType.Negate: 22case SqlNodeType.BitNot: 23case SqlNodeType.Count: 24case SqlNodeType.LongCount: 25case SqlNodeType.Max: 26case SqlNodeType.Min: 27case SqlNodeType.Sum: 28case SqlNodeType.Avg: 29case SqlNodeType.Stddev: 30case SqlNodeType.Convert: 31case SqlNodeType.ValueOf: 32case SqlNodeType.OuterJoinedValue: 33case SqlNodeType.ClrLength: 44internal static bool IsUnaryOperatorExpectingPredicateOperand(this SqlNodeType nodeType) { 46case SqlNodeType.Not: 47case SqlNodeType.Not2V: 49case SqlNodeType.IsNull: 50case SqlNodeType.IsNotNull: 51case SqlNodeType.Negate: 52case SqlNodeType.BitNot: 53case SqlNodeType.Count: 54case SqlNodeType.LongCount: 55case SqlNodeType.Max: 56case SqlNodeType.Min: 57case SqlNodeType.Sum: 58case SqlNodeType.Avg: 59case SqlNodeType.Stddev: 60case SqlNodeType.Convert: 61case SqlNodeType.ValueOf: 62case SqlNodeType.OuterJoinedValue: 63case SqlNodeType.ClrLength: 75internal static bool IsPredicateBinaryOperator(this SqlNodeType nodeType) { 77case SqlNodeType.GE: 78case SqlNodeType.GT: 79case SqlNodeType.LE: 80case SqlNodeType.LT: 81case SqlNodeType.EQ: 82case SqlNodeType.NE: 83case SqlNodeType.EQ2V: 84case SqlNodeType.NE2V: 85case SqlNodeType.And: 86case SqlNodeType.Or: 88case SqlNodeType.Add: 89case SqlNodeType.Sub: 90case SqlNodeType.Mul: 91case SqlNodeType.Div: 92case SqlNodeType.Mod: 93case SqlNodeType.BitAnd: 94case SqlNodeType.BitOr: 95case SqlNodeType.BitXor: 96case SqlNodeType.Concat: 97case SqlNodeType.Coalesce: 107internal static bool IsComparisonOperator(this SqlNodeType nodeType) 111case SqlNodeType.GE: 112case SqlNodeType.GT: 113case SqlNodeType.LE: 114case SqlNodeType.LT: 115case SqlNodeType.EQ: 116case SqlNodeType.NE: 117case SqlNodeType.EQ2V: 118case SqlNodeType.NE2V: 120case SqlNodeType.And: 121case SqlNodeType.Or: 122case SqlNodeType.Add: 123case SqlNodeType.Sub: 124case SqlNodeType.Mul: 125case SqlNodeType.Div: 126case SqlNodeType.Mod: 127case SqlNodeType.BitAnd: 128case SqlNodeType.BitOr: 129case SqlNodeType.BitXor: 130case SqlNodeType.Concat: 131case SqlNodeType.Coalesce: 143internal static bool IsBinaryOperatorExpectingPredicateOperands(this SqlNodeType nodeType) { 145case SqlNodeType.And: 146case SqlNodeType.Or: 148case SqlNodeType.EQ: 149case SqlNodeType.EQ2V: 150case SqlNodeType.GE: 151case SqlNodeType.GT: 152case SqlNodeType.LE: 153case SqlNodeType.LT: 154case SqlNodeType.NE: 155case SqlNodeType.NE2V: 156case SqlNodeType.Add: 157case SqlNodeType.Sub: 158case SqlNodeType.Mul: 159case SqlNodeType.Div: 160case SqlNodeType.Mod: 161case SqlNodeType.BitAnd: 162case SqlNodeType.BitOr: 163case SqlNodeType.BitXor: 164case SqlNodeType.Concat: 165case SqlNodeType.Coalesce: 178case SqlNodeType.Link: 179case SqlNodeType.Element: 180case SqlNodeType.Multiset: 181case SqlNodeType.ClientQuery: 182case SqlNodeType.TypeCase: 183case SqlNodeType.New:

26case SqlNodeType.Not: 27case SqlNodeType.Not2V: 28case SqlNodeType.Negate: 29case SqlNodeType.BitNot: 30case SqlNodeType.IsNull: 31case SqlNodeType.IsNotNull: 32case SqlNodeType.Count: 33case SqlNodeType.LongCount: 34case SqlNodeType.Max: 35case SqlNodeType.Min: 36case SqlNodeType.Sum: 37case SqlNodeType.Avg: 38case SqlNodeType.Stddev: 39case SqlNodeType.Convert: 40case SqlNodeType.ValueOf: 41case SqlNodeType.OuterJoinedValue: 42case SqlNodeType.ClrLength: 45case SqlNodeType.Lift: 48case SqlNodeType.Add: 49case SqlNodeType.Sub: 50case SqlNodeType.Mul: 51case SqlNodeType.Div: 52case SqlNodeType.Mod: 53case SqlNodeType.BitAnd: 54case SqlNodeType.BitOr: 55case SqlNodeType.BitXor: 56case SqlNodeType.And: 57case SqlNodeType.Or: 58case SqlNodeType.GE: 59case SqlNodeType.GT: 60case SqlNodeType.LE: 61case SqlNodeType.LT: 62case SqlNodeType.EQ: 63case SqlNodeType.NE: 64case SqlNodeType.EQ2V: 65case SqlNodeType.NE2V: 66case SqlNodeType.Concat: 67case SqlNodeType.Coalesce: 70case SqlNodeType.Between: 73case SqlNodeType.In: 76case SqlNodeType.Like: 79case SqlNodeType.Treat: 82case SqlNodeType.Alias: 85case SqlNodeType.AliasRef: 88case SqlNodeType.Member: 91case SqlNodeType.Row: 94case SqlNodeType.Column: 97case SqlNodeType.ColumnRef: 100case SqlNodeType.Table: 103case SqlNodeType.UserQuery: 106case SqlNodeType.StoredProcedureCall: 109case SqlNodeType.UserRow: 112case SqlNodeType.UserColumn: 115case SqlNodeType.Multiset: 116case SqlNodeType.ScalarSubSelect: 117case SqlNodeType.Element: 118case SqlNodeType.Exists: 121case SqlNodeType.Join: 124case SqlNodeType.Select: 127case SqlNodeType.Parameter: 130case SqlNodeType.New: 133case SqlNodeType.Link: 136case SqlNodeType.ClientQuery: 139case SqlNodeType.JoinedCollection: 142case SqlNodeType.Value: 145case SqlNodeType.ClientArray: 148case SqlNodeType.Insert: 151case SqlNodeType.Update: 154case SqlNodeType.Delete: 157case SqlNodeType.MemberAssign: 160case SqlNodeType.Assign: 163case SqlNodeType.Block: 166case SqlNodeType.SearchedCase: 169case SqlNodeType.ClientCase: 172case SqlNodeType.SimpleCase: 175case SqlNodeType.TypeCase: 178case SqlNodeType.Union: 181case SqlNodeType.ExprSet: 184case SqlNodeType.Variable: 187case SqlNodeType.DoNotVisit: 190case SqlNodeType.OptionalValue: 193case SqlNodeType.FunctionCall: 196case SqlNodeType.TableValuedFunctionCall: 199case SqlNodeType.MethodCall: 202case SqlNodeType.Nop: 205case SqlNodeType.SharedExpression: 208case SqlNodeType.SharedExpressionRef: 211case SqlNodeType.SimpleExpression: 214case SqlNodeType.Grouping: 217case SqlNodeType.DiscriminatedType: 220case SqlNodeType.DiscriminatorOf: 223case SqlNodeType.ClientParameter: 226case SqlNodeType.RowNumber: 229case SqlNodeType.IncludeScope: 262if (expr.NodeType == SqlNodeType.Value) { 405case SqlNodeType.ScalarSubSelect: return this.VisitScalarSubSelect(ss); 406case SqlNodeType.Multiset: return this.VisitMultiset(ss); 407case SqlNodeType.Element: return this.VisitElement(ss); 408case SqlNodeType.Exists: return this.VisitExists(ss); 621case SqlNodeType.Column: 623case SqlNodeType.ColumnRef: 626case SqlNodeType.ExprSet: 634case SqlNodeType.OuterJoinedValue:

17internal abstract ProviderType PredictTypeForUnary(SqlNodeType unaryOp, ProviderType operandType); 19internal abstract ProviderType PredictTypeForBinary(SqlNodeType binaryOp, ProviderType leftType, ProviderType rightType);

37&& bo.Left.NodeType == SqlNodeType.MethodCall 38&& bo.Right.NodeType == SqlNodeType.Value) { 54private static bool IsComparison(SqlNodeType nodeType) { 56case SqlNodeType.EQ: 57case SqlNodeType.NE: 58case SqlNodeType.LT: 59case SqlNodeType.LE: 60case SqlNodeType.GT: 61case SqlNodeType.GE: 62case SqlNodeType.EQ2V: 63case SqlNodeType.NE2V: 72&& bo.Left.NodeType == SqlNodeType.MethodCall 73&& bo.Right.NodeType == SqlNodeType.Value 175private SqlBinary MakeCompareTo(SqlExpression left, SqlExpression right, SqlNodeType op, int iValue) { 179else if (op == SqlNodeType.EQ || op == SqlNodeType.EQ2V) { 182return sql.Binary(SqlNodeType.LT, left, right); 184return sql.Binary(SqlNodeType.GT, left, right); 191SqlExpression lower = sql.Binary(SqlNodeType.LT, a, b); 192SqlExpression equal = sql.Binary(SqlNodeType.EQ2V, a, b); 208return sql.Unary(SqlNodeType.IsNotNull, m.Expression, m.SourceExpression); 220return sql.Binary(SqlNodeType.EQ2V, mc.Arguments[0], mc.Arguments[1], mc.Method); 259return sql.Binary(SqlNodeType.EQ, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 261return sql.Binary(SqlNodeType.NE, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 263return sql.Binary(SqlNodeType.LT, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 265return sql.Binary(SqlNodeType.LE, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 267return sql.Binary(SqlNodeType.GT, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 269return sql.Binary(SqlNodeType.GE, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 271return sql.Binary(SqlNodeType.Mul, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 273return sql.Binary(SqlNodeType.Div, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 275return sql.Binary(SqlNodeType.Sub, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 277return sql.Binary(SqlNodeType.Add, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 279return sql.Binary(SqlNodeType.Mod, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 281return sql.Binary(SqlNodeType.BitAnd, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 283return sql.Binary(SqlNodeType.BitOr, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 285return sql.Binary(SqlNodeType.BitXor, mc.Arguments[0], mc.Arguments[1], mc.Method, mc.ClrType); 287return sql.Unary(SqlNodeType.Negate, mc.Arguments[0], mc.Method, mc.SourceExpression); 289return sql.Unary(SqlNodeType.BitNot, mc.Arguments[0], mc.Method, mc.SourceExpression); 291return sql.Unary(SqlNodeType.Not, mc.Arguments[0], mc.Method, mc.SourceExpression); 297return sql.Binary(SqlNodeType.EQ, mc.Object, mc.Arguments[0]); 318while (@else.NodeType == SqlNodeType.SearchedCase) {

107if (retNode.NodeType == SqlNodeType.MethodCall) { 259if (sel.Selection.NodeType != SqlNodeType.AliasRef || 281if (node.NodeType == SqlNodeType.Value) { 301else if (node.NodeType == SqlNodeType.Multiset || node.NodeType == SqlNodeType.Element) { 304else if (node.NodeType == SqlNodeType.ClientArray) { 307else if (node.NodeType == SqlNodeType.ClientParameter) { 337if (expr.NodeType == SqlNodeType.Value) { 406SqlSubSelect ms = sql.SubSelect(SqlNodeType.Multiset, select, exp.Type); 422return new SqlSelect(sql.SubSelect(SqlNodeType.Multiset, pselect, selector.Body.Type), alias, this.dominatingExpression); 424else if ((project.NodeType == SqlNodeType.Element || project.NodeType == SqlNodeType.ScalarSubSelect) && 430if (project.NodeType == SqlNodeType.Element) { 435SqlNodeType.OuterJoinedValue, 439sql.Unary(SqlNodeType.OuterJoinedValue, inner.Selection) 443inner.Selection = sql.Unary(SqlNodeType.OuterJoinedValue, inner.Selection); 501SqlExpression condition = sql.Binary(SqlNodeType.EQ, outerKey, innerKey); 530SqlExpression pred = sql.Binary(SqlNodeType.EQ, outerKey, innerKey); 533SqlSubSelect subquery = sql.SubSelect(SqlNodeType.Multiset, select); 551sql.Unary(SqlNodeType.OuterJoinedValue, 555sql.Unary(SqlNodeType.OuterJoinedValue, aliasRef) 578select.Selection = new SqlUnary(SqlNodeType.Treat, ofType, typeProvider.From(ofType), aref, this.dominatingExpression); 585sql.Unary(SqlNodeType.IsNotNull, aref, this.dominatingExpression) 620result = sql.Unary(SqlNodeType.IsNotNull, new SqlUnary(SqlNodeType.Treat, ofType, typeProvider.From(ofType), expr, this.dominatingExpression), this.dominatingExpression); 640return new SqlUnary(SqlNodeType.Treat, a.Type, typeProvider.From(a.Type), expr, a); 644SqlSubSelect ms = sql.SubSelect(SqlNodeType.Multiset, select); 645return new SqlUnary(SqlNodeType.Treat, a.Type, typeProvider.From(a.Type), ms, a); 665if (array.NodeType == SqlNodeType.ClientParameter 666&& index.NodeType == SqlNodeType.Value) { 707else if (expr.NodeType == SqlNodeType.Value && ((SqlValue)expr).Value == null) { 710else if (expr.NodeType == SqlNodeType.ClientParameter) { 734return new SqlUnary(SqlNodeType.Treat, type, typeProvider.From(type), expr, expr.SourceExpression); 813while (@else.NodeType == SqlNodeType.SearchedCase) { 931if (takeExp.NodeType == SqlNodeType.Value) { 943if (skipExp.NodeType == SqlNodeType.Value) { 979case SqlNodeType.AliasRef: { 1005case SqlNodeType.New: 1045if (skipExp.NodeType == SqlNodeType.Value) { 1084sql.Binary(SqlNodeType.Add, (SqlExpression)SqlDuplicator.Copy(skipExp), takeExp), 1089final.Where = sql.Binary(SqlNodeType.GT, rowNumberRef, skipExp); 1131eqsel.Where = sql.Binary(SqlNodeType.EQ2V, aref, dupRef); 1132SqlSubSelect ss = sql.SubSelect(SqlNodeType.Exists, eqsel); 1135final.Where = sql.Unary(SqlNodeType.Not, ss, this.dominatingExpression); 1277result = sql.Unary(SqlNodeType.Negate, exp, this.dominatingExpression); 1281result = sql.Unary(SqlNodeType.Not, exp, this.dominatingExpression); 1284result = sql.Unary(SqlNodeType.BitNot, exp, this.dominatingExpression); 1288result = sql.Unary(SqlNodeType.Treat, exp, this.dominatingExpression); 1309result = sql.Binary(SqlNodeType.Add, left, right, b.Type); 1313result = sql.Binary(SqlNodeType.Sub, left, right, b.Type); 1317result = sql.Binary(SqlNodeType.Mul, left, right, b.Type); 1320result = sql.Binary(SqlNodeType.Div, left, right, b.Type); 1323result = sql.Binary(SqlNodeType.Mod, left, right, b.Type); 1327result = sql.Binary(SqlNodeType.And, left, right, b.Type); 1330result = sql.Binary(SqlNodeType.BitAnd, left, right, b.Type); 1334result = sql.Binary(SqlNodeType.And, left, right, b.Type); 1338result = sql.Binary(SqlNodeType.Or, left, right, b.Type); 1341result = sql.Binary(SqlNodeType.BitOr, left, right, b.Type); 1345result = sql.Binary(SqlNodeType.Or, left, right, b.Type); 1348result = sql.Binary(SqlNodeType.LT, left, right, b.Type); 1351result = sql.Binary(SqlNodeType.LE, left, right, b.Type); 1354result = sql.Binary(SqlNodeType.GT, left, right, b.Type); 1357result = sql.Binary(SqlNodeType.GE, left, right, b.Type); 1360result = sql.Binary(SqlNodeType.EQ, left, right, b.Type); 1363result = sql.Binary(SqlNodeType.NE, left, right, b.Type); 1366result = sql.Binary(SqlNodeType.BitXor, left, right, b.Type); 1380return sql.Binary(SqlNodeType.Coalesce, left, right, resultType); 1384whens.Add(new SqlWhen(sql.Unary(SqlNodeType.IsNull, left, left.SourceExpression), right)); 1440SqlExpression any = this.GenerateQuantifier(alias2, sql.Binary(SqlNodeType.EQ2V, aref1, aref2), true); 1464SqlExpression any = this.GenerateQuantifier(alias2, sql.Binary(SqlNodeType.EQ2V, aref1, aref2), true); 1467result.Where = sql.Unary(SqlNodeType.Not, any); 1494if (select.Selection.NodeType != SqlNodeType.AliasRef || select.OrderBy.Count > 0) { 1516System.Diagnostics.Debug.Assert(select.Selection.NodeType == SqlNodeType.AliasRef); 1577selElem.Where = sql.Binary(SqlNodeType.EQ2V, keyExpr, keyDup); 1580SqlSubSelect ss = sql.SubSelect(SqlNodeType.Multiset, selElem); 1626private SqlNode VisitAggregate(Expression sequence, LambdaExpression lambda, SqlNodeType aggType, Type returnType) { 1633bool isCount = aggType == SqlNodeType.Count || aggType == SqlNodeType.LongCount; 1737return sql.SubSelect(SqlNodeType.ScalarSubSelect, sel); 1759case SqlNodeType.AliasRef: 1761case SqlNodeType.Member: 1771private SqlExpression GetAggregate(SqlNodeType aggType, Type clrType, SqlExpression exp) { 1779if (seqNode.NodeType == SqlNodeType.ClientArray) { 1783else if (seqNode.NodeType == SqlNodeType.Value) { 1806SqlExpression pred = sql.Binary(SqlNodeType.EQ, expr, list[0]); 1808pred = sql.Binary(SqlNodeType.Or, pred, sql.Binary(SqlNodeType.EQ, (SqlExpression)SqlDuplicator.Copy(expr), list[i])); 1834SqlSubSelect exists = sql.SubSelect(SqlNodeType.Exists, sel); 1839SqlSubSelect ss = sql.SubSelect(SqlNodeType.Exists, sel); 1840sel.Where = sql.Unary(SqlNodeType.Not2V, cond, this.dominatingExpression); 1841return sql.Unary(SqlNodeType.Not, ss, this.dominatingExpression); 1868return this.VisitAggregate(ma.Expression, null, SqlNodeType.Count, typeof(int)); 1949if (exp.NodeType == SqlNodeType.Value) { 2172return this.VisitAggregate(mc.Arguments[0], null, SqlNodeType.Count, mc.Type); 2176return this.VisitAggregate(mc.Arguments[0], this.GetLambda(mc.Arguments[1]), SqlNodeType.Count, mc.Type); 2182return this.VisitAggregate(mc.Arguments[0], null, SqlNodeType.LongCount, mc.Type); 2186return this.VisitAggregate(mc.Arguments[0], this.GetLambda(mc.Arguments[1]), SqlNodeType.LongCount, mc.Type); 2192return this.VisitAggregate(mc.Arguments[0], null, SqlNodeType.Sum, mc.Type); 2196return this.VisitAggregate(mc.Arguments[0], this.GetLambda(mc.Arguments[1]), SqlNodeType.Sum, mc.Type); 2202return this.VisitAggregate(mc.Arguments[0], null, SqlNodeType.Min, mc.Type); 2206return this.VisitAggregate(mc.Arguments[0], this.GetLambda(mc.Arguments[1]), SqlNodeType.Min, mc.Type); 2212return this.VisitAggregate(mc.Arguments[0], null, SqlNodeType.Max, mc.Type); 2216return this.VisitAggregate(mc.Arguments[0], this.GetLambda(mc.Arguments[1]), SqlNodeType.Max, mc.Type); 2222return this.VisitAggregate(mc.Arguments[0], null, SqlNodeType.Avg, mc.Type); 2226return this.VisitAggregate(mc.Arguments[0], this.GetLambda(mc.Arguments[1]), SqlNodeType.Avg, mc.Type); 2383SqlNodeType subType = (this.typeProvider.From(select.Selection.ClrType).CanBeColumn) ? SqlNodeType.ScalarSubSelect : SqlNodeType.Element; 2453SqlNodeType.EQ, 2460pred = sql.Binary(SqlNodeType.EQ2V, tableAliasRef, itemExpression); 2620sql.Binary(SqlNodeType.GT, this.GetRowCountExpression(), sql.ValueFromObject(0, false, this.dominatingExpression)), 2672if (r.NodeType == SqlNodeType.Value) { 2773case SqlNodeType.Column: 2774case SqlNodeType.ColumnRef: 2775case SqlNodeType.Member: { 2788case SqlNodeType.New: 2789case SqlNodeType.AliasRef: { 2793case SqlNodeType.Treat: 2794case SqlNodeType.TypeCase: { 2870case SqlNodeType.Column: { 2874case SqlNodeType.ColumnRef: { 2878case SqlNodeType.Member: {

41case SqlNodeType.Not: 42case SqlNodeType.Not2V: 43case SqlNodeType.Negate: 44case SqlNodeType.BitNot: 45case SqlNodeType.IsNull: 46case SqlNodeType.IsNotNull: 47case SqlNodeType.ValueOf: 48case SqlNodeType.OuterJoinedValue: 49case SqlNodeType.ClrLength: 50case SqlNodeType.Add: 51case SqlNodeType.Sub: 52case SqlNodeType.Mul: 53case SqlNodeType.Div: 54case SqlNodeType.Mod: 55case SqlNodeType.BitAnd: 56case SqlNodeType.BitOr: 57case SqlNodeType.BitXor: 58case SqlNodeType.And: 59case SqlNodeType.Or: 60case SqlNodeType.GE: 61case SqlNodeType.GT: 62case SqlNodeType.LE: 63case SqlNodeType.LT: 64case SqlNodeType.EQ: 65case SqlNodeType.NE: 66case SqlNodeType.EQ2V: 67case SqlNodeType.NE2V: 68case SqlNodeType.Between: 69case SqlNodeType.Concat: 70case SqlNodeType.Convert: 71case SqlNodeType.Treat: 72case SqlNodeType.Member: 73case SqlNodeType.TypeCase: 74case SqlNodeType.SearchedCase: 75case SqlNodeType.SimpleCase: 76case SqlNodeType.Like: 77case SqlNodeType.FunctionCall: 78case SqlNodeType.ExprSet: 79case SqlNodeType.OptionalValue: 80case SqlNodeType.Parameter: 81case SqlNodeType.ColumnRef: 82case SqlNodeType.Value: 83case SqlNodeType.Variable: 85case SqlNodeType.Column: 86case SqlNodeType.ClientCase: 87case SqlNodeType.DiscriminatedType: 88case SqlNodeType.Link: 89case SqlNodeType.Row: 90case SqlNodeType.UserQuery: 91case SqlNodeType.StoredProcedureCall: 92case SqlNodeType.UserRow: 93case SqlNodeType.UserColumn: 94case SqlNodeType.Multiset: 95case SqlNodeType.ScalarSubSelect: 96case SqlNodeType.Element: 97case SqlNodeType.Exists: 98case SqlNodeType.Join: 99case SqlNodeType.Select: 100case SqlNodeType.New: 101case SqlNodeType.ClientQuery: 102case SqlNodeType.ClientArray: 103case SqlNodeType.Insert: 104case SqlNodeType.Update: 105case SqlNodeType.Delete: 106case SqlNodeType.MemberAssign: 107case SqlNodeType.Assign: 108case SqlNodeType.Block: 109case SqlNodeType.Union: 110case SqlNodeType.DoNotVisit: 111case SqlNodeType.MethodCall: 112case SqlNodeType.Nop:

35case SqlNodeType.Min: 36case SqlNodeType.Max: 37case SqlNodeType.Avg: 38case SqlNodeType.Sum: 39case SqlNodeType.Count: 40case SqlNodeType.LongCount:

176case SqlNodeType.EQ: 177case SqlNodeType.EQ2V: 179return this.VisitUnaryOperator(this.sql.Unary(SqlNodeType.IsNull, bo.Right, bo.SourceExpression)); 182return this.VisitUnaryOperator(this.sql.Unary(SqlNodeType.IsNull, bo.Left, bo.SourceExpression)); 185case SqlNodeType.NE: 186case SqlNodeType.NE2V: 188return this.VisitUnaryOperator(this.sql.Unary(SqlNodeType.IsNotNull, bo.Right, bo.SourceExpression)); 191return this.VisitUnaryOperator(this.sql.Unary(SqlNodeType.IsNotNull, bo.Left, bo.SourceExpression)); 200case SqlNodeType.EQ: 201case SqlNodeType.EQ2V: 202case SqlNodeType.NE: 203case SqlNodeType.NE2V: { 209bool equal = bo.NodeType != SqlNodeType.NE && bo.NodeType != SqlNodeType.NE2V; 210bool isTwoValue = bo.NodeType == SqlNodeType.EQ2V || bo.NodeType == SqlNodeType.NE2V; 211SqlNodeType negator = isTwoValue ? SqlNodeType.Not2V : SqlNodeType.Not; 246case SqlNodeType.And: { 267case SqlNodeType.Or: { 288case SqlNodeType.EQ: 289case SqlNodeType.NE: 290case SqlNodeType.EQ2V: 291case SqlNodeType.NE2V: { 304case SqlNodeType.EQ: 305case SqlNodeType.NE: 306case SqlNodeType.EQ2V: 307case SqlNodeType.NE2V: 335return this.VisitExpression(sql.ValueFromObject(bo.NodeType == SqlNodeType.NE, false, bo.SourceExpression)); 342(bo.NodeType == SqlNodeType.EQ) == (leftPossibleTypes[0] == rightPossibleTypes[0]), 374if (typeExpression.NodeType == SqlNodeType.DiscriminatedType) { 384else if (typeExpression.NodeType == SqlNodeType.Value) { 388} else if (typeExpression.NodeType == SqlNodeType.SearchedCase) { 406while (obj.NodeType == SqlNodeType.OptionalValue 407|| obj.NodeType == SqlNodeType.OuterJoinedValue) { 408if (obj.NodeType == SqlNodeType.OptionalValue) { 415if (obj.NodeType == SqlNodeType.TypeCase) { 455return this.VisitExpression(sql.Binary(SqlNodeType.And, c.Whens[0].Match, c.Whens[0].Value)); 458return this.VisitExpression(sql.Binary(SqlNodeType.Or, c.Whens[0].Match, c.Else)); 480case SqlNodeType.OptionalValue: 483case SqlNodeType.OuterJoinedValue: 486case SqlNodeType.New: 494case SqlNodeType.TypeCase: 539if (uo.NodeType == SqlNodeType.IsNull || uo.NodeType == SqlNodeType.IsNotNull) { 544if (uo.Operand.NodeType==SqlNodeType.OuterJoinedValue) { 546if (ojv.Operand.NodeType == SqlNodeType.OptionalValue) { 550new SqlUnary(SqlNodeType.OuterJoinedValue, ov.ClrType, ov.SqlType, ov.HasValue, ov.SourceExpression) 554else if (ojv.Operand.NodeType == SqlNodeType.TypeCase) { 557new SqlUnary(SqlNodeType.OuterJoinedValue, tc.Discriminator.ClrType, tc.Discriminator.SqlType, tc.Discriminator, tc.SourceExpression), 570if ((uo.NodeType == SqlNodeType.Not || uo.NodeType == SqlNodeType.Not2V) && uo.Operand.NodeType == SqlNodeType.Value) { 574else if (uo.NodeType == SqlNodeType.Not2V) { 582return sql.Binary(SqlNodeType.EQ, c, sql.ValueFromObject(0, false, uo.SourceExpression)); 585return sql.Unary(SqlNodeType.Not, uo.Operand); 589else if (uo.NodeType == SqlNodeType.Convert && uo.Operand.NodeType == SqlNodeType.Value) { 593else if (uo.NodeType == SqlNodeType.IsNull || uo.NodeType == SqlNodeType.IsNotNull) { 596return sql.ValueFromObject(uo.NodeType == SqlNodeType.IsNotNull, false, uo.SourceExpression); 600case SqlNodeType.Element: 601exp = sql.SubSelect(SqlNodeType.Exists, ((SqlSubSelect)exp).Select); 602if (uo.NodeType == SqlNodeType.IsNull) { 603exp = sql.Unary(SqlNodeType.Not, exp, exp.SourceExpression); 606case SqlNodeType.ClientQuery: { 608if (cq.Query.NodeType == SqlNodeType.Element) { 609exp = sql.SubSelect(SqlNodeType.Exists, cq.Query.Select); 610if (uo.NodeType == SqlNodeType.IsNull) { 611exp = sql.Unary(SqlNodeType.Not, exp, exp.SourceExpression); 615return sql.ValueFromObject(uo.NodeType == SqlNodeType.IsNotNull, false, uo.SourceExpression); 617case SqlNodeType.OptionalValue: 621case SqlNodeType.ClientCase: { 632case SqlNodeType.TypeCase: { 648case SqlNodeType.Value: { 650return sql.Value(typeof(bool), this.typeProvider.From(typeof(int)), (val.Value == null) == (uo.NodeType == SqlNodeType.IsNull), val.IsClientSpecified, uo.SourceExpression); 654else if (uo.NodeType == SqlNodeType.Treat) { 677if (mm.IsAssociation && ma.Expression != null && ma.Expression.NodeType != SqlNodeType.Link 707case SqlNodeType.ClientCase: { 728case SqlNodeType.SimpleCase: { 748case SqlNodeType.SearchedCase: { 759case SqlNodeType.TypeCase: { 767if (when.TypeBinding.NodeType == SqlNodeType.New) { 777case SqlNodeType.AliasRef: { 812case SqlNodeType.OptionalValue: 816case SqlNodeType.OuterJoinedValue: { 819if (e != null) return sql.Unary(SqlNodeType.OuterJoinedValue, e); 823case SqlNodeType.Lift: 826case SqlNodeType.UserRow: { 841case SqlNodeType.New: { 854case SqlNodeType.Element: 855case SqlNodeType.ScalarSubSelect: { 874if (rexp.NodeType == SqlNodeType.Member && !SqlColumnizer.CanBeColumn(rexp)) { 878if (this.canUseOuterApply && exp.NodeType == SqlNodeType.Element && this.currentSelect != null) { 894SqlNodeType subType = (rexp is SqlTypeCase || !rexp.SqlType.CanBeColumn) ? SqlNodeType.Element : SqlNodeType.ScalarSubSelect; 913case SqlNodeType.Value: { 927case SqlNodeType.Grouping: { 934case SqlNodeType.ClientParameter: { 960if (ss.NodeType == SqlNodeType.Element && ss.Select.Selection.NodeType == SqlNodeType.Multiset) { 967SqlSubSelect newss = sql.SubSelect(SqlNodeType.Multiset, sel, ss.ClrType); 970else if (ss.NodeType == SqlNodeType.Element && ss.Select.Selection.NodeType == SqlNodeType.Element) { 977SqlSubSelect newss = sql.SubSelect(SqlNodeType.Element, sel); 1024if (a.Node.NodeType == SqlNodeType.Table) { 1071if (shared.Expression.NodeType == SqlNodeType.ColumnRef) { 1095if (expr.NodeType == SqlNodeType.Value && expr.SqlType.CanBeColumn) { 1181if (select.Where != null && select.Where.NodeType == SqlNodeType.Value && (bool)((SqlValue)select.Where).Value) { 1217case SqlNodeType.Column: { 1224case SqlNodeType.OuterJoinedValue: { 1230if (e.NodeType != SqlNodeType.OuterJoinedValue) { 1231return sql.Unary(SqlNodeType.OuterJoinedValue, e); 1235case SqlNodeType.Link: 1237case SqlNodeType.ClientCase: { 1263SqlSubSelect ms = sql.SubSelect(SqlNodeType.Multiset, select); 1277case SqlNodeType.OuterJoinedValue: { 1285case SqlNodeType.ClientCase: { 1315case SqlNodeType.TypeCase: { 1329case SqlNodeType.SearchedCase: { 1338case SqlNodeType.Link: { 1366&& node.NodeType == SqlNodeType.Element 1408if (location.NodeType == SqlNodeType.Join) 1453while (node.NodeType == SqlNodeType.OuterJoinedValue) { 1466if (expr.NodeType == SqlNodeType.Value) { 1470if (expr.NodeType == SqlNodeType.Link) { 1487else if (expr.NodeType == SqlNodeType.Grouping) { 1490else if (expr.NodeType == SqlNodeType.ClientCase) { 1549if (aref != null && aref.Alias.Node.NodeType == SqlNodeType.Table) { 1585SqlExpression discriminatorPredicate = sql.Binary(SqlNodeType.EQ, clientCase.Expression, clientCase.Whens[i].Match); 1587elseFilter = sql.AndAccumulate(elseFilter, sql.Binary(SqlNodeType.NE, clientCase.Expression, clientCase.Whens[i].Match));

20if (select.Where != null && select.Where.NodeType == SqlNodeType.Coalesce) { 22if (bin.Right.NodeType == SqlNodeType.Value) { 40return new SqlBinary(SqlNodeType.EQ, 66new SqlWhen(new SqlUnary(SqlNodeType.Not, predicateExpression.ClrType, predicateExpression.SqlType, predicateExpression, predicateExpression.SourceExpression), valueFalse)

124case SqlNodeType.And: 125case SqlNodeType.Or: 126case SqlNodeType.Not: 127case SqlNodeType.Not2V: 128case SqlNodeType.EQ: 129case SqlNodeType.EQ2V: 130case SqlNodeType.NE: 131case SqlNodeType.NE2V: 132case SqlNodeType.GE: 133case SqlNodeType.GT: 134case SqlNodeType.LE: 135case SqlNodeType.LT: 136case SqlNodeType.Exists: 137case SqlNodeType.Between: 138case SqlNodeType.In: 139case SqlNodeType.Like: 140case SqlNodeType.IsNotNull: 141case SqlNodeType.IsNull: 143case SqlNodeType.Lift:

38case SqlNodeType.EQ: 39case SqlNodeType.NE: 40case SqlNodeType.EQ2V: 41case SqlNodeType.NE2V: 42if (bo.Left.NodeType == SqlNodeType.SimpleCase && 43bo.Right.NodeType == SqlNodeType.Value && 47else if (bo.Right.NodeType == SqlNodeType.SimpleCase && 48bo.Left.NodeType==SqlNodeType.Value && 63if (when.Value.NodeType != SqlNodeType.Value) { 72private SqlExpression DistributeOperatorIntoCase(SqlNodeType nt, SqlSimpleCase sc, SqlExpression expr) { 73if (nt!=SqlNodeType.EQ && nt!=SqlNodeType.NE && nt!=SqlNodeType.EQ2V && nt!=SqlNodeType.NE2V) 82values.Add(sql.ValueFromObject((nt==SqlNodeType.EQ || nt==SqlNodeType.EQ2V) == eq, false, sc.SourceExpression)); 113allValuesLiteral = allValuesLiteral && when.Value.NodeType == SqlNodeType.Value; 188rewrite = sql.OrAccumulate(rewrite, sql.Binary(SqlNodeType.EQ, discriminator, newWhens[i].Match)); 191rewrite = sql.AndAccumulate(rewrite, sql.Binary(SqlNodeType.NE, discriminator, newWhens[i].Match)); 201rewrite = sql.OrAccumulate(rewrite, sql.Unary(SqlNodeType.IsNull, discriminator, discriminator.SourceExpression)); 204rewrite = sql.AndAccumulate(rewrite, sql.Unary(SqlNodeType.IsNotNull, discriminator, discriminator.SourceExpression));

49if (expr.NodeType == SqlNodeType.Column || 50expr.NodeType == SqlNodeType.ColumnRef) { 123case SqlNodeType.AliasRef: 124case SqlNodeType.ColumnRef: 125case SqlNodeType.Column: 126case SqlNodeType.Multiset: 127case SqlNodeType.Element: 128case SqlNodeType.ScalarSubSelect: 129case SqlNodeType.Exists: 130case SqlNodeType.ClientQuery: 131case SqlNodeType.SharedExpressionRef: 132case SqlNodeType.Link: 133case SqlNodeType.Nop: 134case SqlNodeType.Value: 135case SqlNodeType.Select: 145case SqlNodeType.ClientCase: 146case SqlNodeType.TypeCase: 147case SqlNodeType.ClientArray: 148case SqlNodeType.Grouping: 149case SqlNodeType.DiscriminatedType: 150case SqlNodeType.SharedExpression: 151case SqlNodeType.SimpleExpression: 152case SqlNodeType.AliasRef: 153case SqlNodeType.Multiset: 154case SqlNodeType.Element: 155case SqlNodeType.ClientQuery: 156case SqlNodeType.SharedExpressionRef: 157case SqlNodeType.Link: 158case SqlNodeType.Nop: 160case SqlNodeType.OuterJoinedValue: 169&& expression.NodeType != SqlNodeType.Column 173case SqlNodeType.MethodCall: 174case SqlNodeType.Member: 175case SqlNodeType.New:

26if (node1.NodeType == SqlNodeType.SimpleCase) 29if (node2.NodeType == SqlNodeType.SimpleCase) 34if (node1.NodeType == SqlNodeType.ExprSet) { 41else if (node2.NodeType == SqlNodeType.ExprSet) { 54case SqlNodeType.Not: 55case SqlNodeType.Not2V: 56case SqlNodeType.Negate: 57case SqlNodeType.BitNot: 58case SqlNodeType.IsNull: 59case SqlNodeType.IsNotNull: 60case SqlNodeType.Count: 61case SqlNodeType.Max: 62case SqlNodeType.Min: 63case SqlNodeType.Sum: 64case SqlNodeType.Avg: 65case SqlNodeType.Stddev: 66case SqlNodeType.ValueOf: 67case SqlNodeType.OuterJoinedValue: 68case SqlNodeType.ClrLength: 70case SqlNodeType.Add: 71case SqlNodeType.Sub: 72case SqlNodeType.Mul: 73case SqlNodeType.Div: 74case SqlNodeType.Mod: 75case SqlNodeType.BitAnd: 76case SqlNodeType.BitOr: 77case SqlNodeType.BitXor: 78case SqlNodeType.And: 79case SqlNodeType.Or: 80case SqlNodeType.GE: 81case SqlNodeType.GT: 82case SqlNodeType.LE: 83case SqlNodeType.LT: 84case SqlNodeType.EQ: 85case SqlNodeType.NE: 86case SqlNodeType.EQ2V: 87case SqlNodeType.NE2V: 88case SqlNodeType.Concat: 93case SqlNodeType.Convert: 94case SqlNodeType.Treat: { 99case SqlNodeType.Between: { 106case SqlNodeType.Parameter: 108case SqlNodeType.Alias: 110case SqlNodeType.AliasRef: 112case SqlNodeType.Column: 116case SqlNodeType.Table: 118case SqlNodeType.Member: 121case SqlNodeType.ColumnRef: 125case SqlNodeType.Value: 127case SqlNodeType.TypeCase: { 147case SqlNodeType.SearchedCase: { 159case SqlNodeType.ClientCase: { 171case SqlNodeType.DiscriminatedType: { 176case SqlNodeType.SimpleCase: { 188case SqlNodeType.Like: { 195case SqlNodeType.Variable: { 200case SqlNodeType.FunctionCall: { 213case SqlNodeType.Link: { 232case SqlNodeType.ExprSet: 242case SqlNodeType.OptionalValue: 246case SqlNodeType.Row: 247case SqlNodeType.UserQuery: 248case SqlNodeType.StoredProcedureCall: 249case SqlNodeType.UserRow: 250case SqlNodeType.UserColumn: 251case SqlNodeType.Multiset: 252case SqlNodeType.ScalarSubSelect: 253case SqlNodeType.Element: 254case SqlNodeType.Exists: 255case SqlNodeType.Join: 256case SqlNodeType.Select: 257case SqlNodeType.New: 258case SqlNodeType.ClientQuery: 259case SqlNodeType.ClientArray: 260case SqlNodeType.Insert: 261case SqlNodeType.Update: 262case SqlNodeType.Delete: 263case SqlNodeType.MemberAssign: 264case SqlNodeType.Assign: 265case SqlNodeType.Block: 266case SqlNodeType.Union: 267case SqlNodeType.DoNotVisit: 268case SqlNodeType.MethodCall: 269case SqlNodeType.Nop: 297if (result.NodeType == SqlNodeType.SimpleCase) {

67while (expr != null && expr.NodeType == SqlNodeType.ColumnRef) { 242case SqlNodeType.And: { 248case SqlNodeType.EQ: 249case SqlNodeType.EQ2V: { 362if (c.Expression != null && c.Expression.NodeType != SqlNodeType.ColumnRef) { 481if (c.Expression != null && c.Expression.NodeType != SqlNodeType.ColumnRef) {

24case SqlNodeType.ColumnRef: 25case SqlNodeType.Value: 26case SqlNodeType.Parameter: 27case SqlNodeType.Variable: 203return new SqlSubSelect(SqlNodeType.ScalarSubSelect, ss.ClrType, ss.SqlType, this.VisitSequence(ss.Select)); 291return new SqlUnary(SqlNodeType.Treat, t.ClrType, t.SqlType, (SqlExpression)this.Visit(t.Operand), t.SourceExpression);

119case SqlNodeType.MethodCall: { 137case SqlNodeType.ClientCase: { 165case SqlNodeType.TypeCase: { 197case SqlNodeType.New: { 202if (exprs[i] == null || exprs[i].NodeType != SqlNodeType.New) 234case SqlNodeType.Link: { 238if (exprs[i] == null || exprs[i].NodeType != SqlNodeType.Link) 271case SqlNodeType.Value: { 283case SqlNodeType.OptionalValue: { 290if (exprs[i] == null || exprs[i].NodeType != SqlNodeType.OptionalValue) { 299case SqlNodeType.OuterJoinedValue: { 305if (exprs[i] == null || exprs[i].NodeType != SqlNodeType.OuterJoinedValue) { 311return factory.Unary(SqlNodeType.OuterJoinedValue, this.ExpandTogether(values)); 313case SqlNodeType.DiscriminatedType: { 326case SqlNodeType.ClientQuery: 327case SqlNodeType.Multiset: 328case SqlNodeType.Element: 329case SqlNodeType.Grouping:

25case SqlNodeType.ExprSet: 29case SqlNodeType.SimpleCase: 33case SqlNodeType.Column: 43case SqlNodeType.ColumnRef: 47case SqlNodeType.Value: 50case SqlNodeType.New: 51case SqlNodeType.Multiset: 52case SqlNodeType.Grouping: 53case SqlNodeType.DiscriminatedType: 54case SqlNodeType.IsNotNull: // IsNull\IsNotNull always return true or false and can never return NULL. 55case SqlNodeType.IsNull: 56case SqlNodeType.Exists: 59case SqlNodeType.Add: 60case SqlNodeType.Sub: 61case SqlNodeType.Mul: 62case SqlNodeType.Div: 63case SqlNodeType.Mod: 64case SqlNodeType.BitAnd: 65case SqlNodeType.BitOr: 66case SqlNodeType.BitXor: 67case SqlNodeType.Concat: { 74case SqlNodeType.Negate: 75case SqlNodeType.BitNot: { 80case SqlNodeType.Lift: { 85case SqlNodeType.OuterJoinedValue:

114if (col.Expression.NodeType == SqlNodeType.ExprSet && c.Expression.NodeType != SqlNodeType.ExprSet) { 195else if (expr.NodeType == SqlNodeType.TypeCase) { 202else if (expr.NodeType == SqlNodeType.Link) { 213else if (expr.NodeType == SqlNodeType.OptionalValue) { 218else if (expr.NodeType == SqlNodeType.OuterJoinedValue) { 221else if (expr.NodeType == SqlNodeType.DiscriminatedType) { 229if (expr.NodeType != SqlNodeType.ColumnRef && 230expr.NodeType != SqlNodeType.ExprSet) {

81case SqlNodeType.ColumnRef: 82case SqlNodeType.Value: 83case SqlNodeType.Member: 84case SqlNodeType.Parameter: 85case SqlNodeType.FunctionCall: 86case SqlNodeType.TableValuedFunctionCall: 87case SqlNodeType.OuterJoinedValue: 90case SqlNodeType.Add: 91case SqlNodeType.Mul: 92case SqlNodeType.And: 93case SqlNodeType.Or: 94case SqlNodeType.Not: 95case SqlNodeType.Not2V: 96case SqlNodeType.BitAnd: 97case SqlNodeType.BitOr: 98case SqlNodeType.BitXor: 99case SqlNodeType.BitNot: 124case SqlNodeType.Not: 125case SqlNodeType.Not2V: 130case SqlNodeType.Negate: 131case SqlNodeType.BitNot: 135case SqlNodeType.Count: 136case SqlNodeType.LongCount: 137case SqlNodeType.Max: 138case SqlNodeType.Min: 139case SqlNodeType.Sum: 140case SqlNodeType.Avg: 141case SqlNodeType.Stddev: 142case SqlNodeType.ClrLength:{ 153case SqlNodeType.IsNull: 154case SqlNodeType.IsNotNull: { 160case SqlNodeType.Convert: { 172case SqlNodeType.ValueOf: 173case SqlNodeType.OuterJoinedValue: 209case SqlNodeType.Coalesce: 869if (src.NodeType == SqlNodeType.Join) { 1217case SqlNodeType.Member: 1219case SqlNodeType.Column: 1221case SqlNodeType.ColumnRef: 1223case SqlNodeType.ExprSet: 1317internal virtual string GetOperator(SqlNodeType nt) { 1319case SqlNodeType.Add: return "+"; 1320case SqlNodeType.Sub: return "-"; 1321case SqlNodeType.Mul: return "*"; 1322case SqlNodeType.Div: return "/"; 1323case SqlNodeType.Mod: return "%"; 1324case SqlNodeType.Concat: return "+"; 1325case SqlNodeType.BitAnd: return "&"; 1326case SqlNodeType.BitOr: return "|"; 1327case SqlNodeType.BitXor: return "^"; 1328case SqlNodeType.And: return "AND"; 1329case SqlNodeType.Or: return "OR"; 1330case SqlNodeType.GE: return ">="; 1331case SqlNodeType.GT: return ">"; 1332case SqlNodeType.LE: return "<="; 1333case SqlNodeType.LT: return "<"; 1334case SqlNodeType.EQ: return "="; 1335case SqlNodeType.EQ2V: return "="; 1336case SqlNodeType.NE: return "<>"; 1337case SqlNodeType.NE2V: return "<>"; 1338case SqlNodeType.Not: return "NOT"; 1339case SqlNodeType.Not2V: return "NOT"; 1340case SqlNodeType.BitNot: return "~"; 1341case SqlNodeType.Negate: return "-"; 1342case SqlNodeType.IsNull: return "IS NULL"; 1343case SqlNodeType.IsNotNull: return "IS NOT NULL"; 1344case SqlNodeType.Count: return "COUNT"; 1345case SqlNodeType.LongCount: return "COUNT_BIG"; 1346case SqlNodeType.Min: return "MIN"; 1347case SqlNodeType.Max: return "MAX"; 1348case SqlNodeType.Sum: return "SUM"; 1349case SqlNodeType.Avg: return "AVG"; 1350case SqlNodeType.Stddev: return "STDEV"; 1351case SqlNodeType.ClrLength: return "CLRLENGTH";

48return uo.NodeType == SqlNodeType.Convert && 651if (uo.NodeType == SqlNodeType.Convert) { 767SqlExpression startIndex = sql.Binary(SqlNodeType.Sub, len, sql.ValueFromObject(2, false, source)); 950return sql.Binary(SqlNodeType.EQ, mc.Object, mc.Arguments[0]); 1002return sql.Binary(SqlNodeType.Coalesce, mc.Object, 1006return sql.Binary(SqlNodeType.Coalesce, mc.Object, mc.Arguments[0]); 1042SqlExpression lower = sql.Binary(SqlNodeType.LT, a, b); 1043SqlExpression equal = sql.Binary(SqlNodeType.EQ2V, a, b); 1193returnValue = sql.Unary(SqlNodeType.Negate, mc.Object, source); 1288case SqlNodeType.Sub: 1366sql.Unary(SqlNodeType.Negate, right, bo.SourceExpression), 1371sql.Unary(SqlNodeType.Negate, right, bo.SourceExpression), 1376case SqlNodeType.Add: 1397return sql.Binary(SqlNodeType.Mul, mc.Arguments[0], mc.Arguments[1]); 1399return sql.Binary(SqlNodeType.Div, mc.Arguments[0], mc.Arguments[1]); 1401return sql.Binary(SqlNodeType.Sub, mc.Arguments[0], mc.Arguments[1]); 1403return sql.Binary(SqlNodeType.Add, mc.Arguments[0], mc.Arguments[1]); 1405return sql.Binary(SqlNodeType.Mod, mc.Arguments[0], mc.Arguments[1]); 1414return sql.Unary(SqlNodeType.Negate, mc.Arguments[0], source); 1480returnValue = sql.Binary(SqlNodeType.EQ2V, mc.Arguments[0], mc.Arguments[1]); 1509if (pattern.NodeType == SqlNodeType.Value) { 1514else if (pattern.NodeType == SqlNodeType.ClientParameter) { 1543if (pattern.NodeType == SqlNodeType.Value) { 1548else if (pattern.NodeType == SqlNodeType.ClientParameter) { 1577if (pattern.NodeType == SqlNodeType.Value) { 1582else if (pattern.NodeType == SqlNodeType.ClientParameter) { 1611SqlExpression lenZeroExpr = sql.Binary(SqlNodeType.EQ, sql.CLRLENGTH(mc.Arguments[0]), sql.ValueFromObject(0, source)); 1630SqlExpression lenZeroExpr = sql.Binary(SqlNodeType.EQ, sql.CLRLENGTH(mc.Arguments[0]), sql.ValueFromObject(0, source)); 1631lenZeroExpr = sql.AndAccumulate(lenZeroExpr, sql.Binary(SqlNodeType.LE, sql.Add(mc.Arguments[1], 1), sql.CLRLENGTH(mc.Object))); 1653SqlExpression lenZeroExpr = sql.Binary(SqlNodeType.EQ, sql.CLRLENGTH(mc.Arguments[0]), sql.ValueFromObject(0, source)); 1654lenZeroExpr = sql.AndAccumulate(lenZeroExpr, sql.Binary(SqlNodeType.LE, sql.Add(mc.Arguments[1], 1), sql.CLRLENGTH(mc.Object))); 1689SqlExpression notContained = sql.Binary(SqlNodeType.EQ, charIndex, sql.ValueFromObject(0, false, source)); 1697SqlExpression lenZeroExpr = sql.Binary(SqlNodeType.EQ, sql.CLRLENGTH(mc.Arguments[0]), sql.ValueFromObject(0, source)); 1723SqlExpression notContained = sql.Binary(SqlNodeType.EQ, charIndex, sql.ValueFromObject(0, false, source)); 1732SqlExpression lenZeroExpr = sql.Binary(SqlNodeType.EQ, sql.CLRLENGTH(mc.Arguments[0]), sql.ValueFromObject(0, source)); 1733lenZeroExpr = sql.AndAccumulate(lenZeroExpr, sql.Binary(SqlNodeType.LE, sql.Add(mc.Arguments[1], 1), sql.CLRLENGTH(s))); 1763SqlExpression notContained = sql.Binary(SqlNodeType.EQ, charIndex, sql.ValueFromObject(0, false, source)); 1764notContained = sql.OrAccumulate(notContained, sql.Binary(SqlNodeType.LE, elseCase, sql.Subtract(i, count))); 1770SqlExpression lenZeroExpr = sql.Binary(SqlNodeType.EQ, sql.CLRLENGTH(mc.Arguments[0]), sql.ValueFromObject(0, source)); 1771lenZeroExpr = sql.AndAccumulate(lenZeroExpr, sql.Binary(SqlNodeType.LE, sql.Add(mc.Arguments[1], 1), sql.CLRLENGTH(s))); 1798SqlExpression insertingAtEnd = sql.Binary(SqlNodeType.EQ, sql.CLRLENGTH(mc.Object), mc.Arguments[0]); 1813SqlExpression dontChange = sql.Binary(SqlNodeType.GE, len2, exprI); 1828SqlExpression dontChange = sql.Binary(SqlNodeType.GE, sql.CLRLENGTH(exprS), exprI); 1845SqlExpression dontChange = sql.Binary(SqlNodeType.GE, sql.CLRLENGTH(exprS), exprI); 1861SqlExpression dontChange = sql.Binary(SqlNodeType.GE, sql.CLRLENGTH(exprS), exprI); 2021SqlExpression minusX = sql.Unary(SqlNodeType.Negate, x, source); 2059SqlExpression aLower = sql.Binary(SqlNodeType.LT, a, b); 2068SqlExpression aLower = sql.Binary(SqlNodeType.LT, a, b); 2092if (roundingMethod.NodeType != SqlNodeType.Value) { 2108SqlExpression condition = sql.AndAccumulate(sql.Binary(SqlNodeType.EQ, twiceX, round2X), sql.Binary(SqlNodeType.NE, x, roundX)); 2127SqlExpression minusX = sql.Unary(SqlNodeType.Negate, x, source); 2146SqlExpression minusX = sql.Unary(SqlNodeType.Negate, x, source); 2201result = sql.DATEADD("MILLISECOND", sql.Unary(SqlNodeType.Negate, ms), result); 2202result = sql.DATEADD("SECOND", sql.Unary(SqlNodeType.Negate, ss), result); 2203result = sql.DATEADD("MINUTE", sql.Unary(SqlNodeType.Negate, mi), result); 2204result = sql.DATEADD("HOUR", sql.Unary(SqlNodeType.Negate, hh), result); 2476if (pattern.NodeType == SqlNodeType.Value) { 2482else if (pattern.NodeType == SqlNodeType.ClientParameter) {

59case SqlNodeType.ClrLength:

63SqlSelect countSelect = new SqlSelect(sql.Unary(SqlNodeType.Count, null, sms.SourceExpression), copyAlias, sms.SourceExpression); 65SqlExpression count = sql.SubSelect(SqlNodeType.ScalarSubSelect, countSelect);

135case SqlNodeType.ColumnRef: 233case SqlNodeType.Column: 235case SqlNodeType.ColumnRef: 239case SqlNodeType.ExprSet:

370this.lifted = new SqlBinary(SqlNodeType.And, this.lifted.ClrType, this.lifted.SqlType, this.lifted, select.Where);

137case SqlNodeType.EQ: 138case SqlNodeType.EQ2V: 139case SqlNodeType.NE: 140case SqlNodeType.NE2V: { 186case SqlNodeType.Parameter: 188case SqlNodeType.Value:

27while (expr.NodeType == SqlNodeType.DiscriminatedType) { 31case SqlNodeType.Value: 32case SqlNodeType.Parameter:

32if (uo.NodeType != SqlNodeType.Convert && uo.Operand != null && uo.Operand.SqlType != null) { 64if (bo.Left.NodeType == SqlNodeType.Convert) { 71if (bo.Right.NodeType == SqlNodeType.Convert) { 79if (bo.Right != null && bo.NodeType != SqlNodeType.Concat) { 92(expr, val) => (val.NodeType == SqlNodeType.Value || val.NodeType == SqlNodeType.ClientParameter) && 93!(expr.NodeType == SqlNodeType.Value || expr.NodeType == SqlNodeType.ClientParameter) && 123: this.typeProvider.PredictTypeForBinary(SqlNodeType.EQ, value.SqlType, valueType); 132ProviderType providerType = this.typeProvider.PredictTypeForBinary(SqlNodeType.EQ, test.SqlType, valueType); 143(like.Pattern.NodeType == SqlNodeType.Value || like.Pattern.NodeType == SqlNodeType.ClientParameter)) { 227if (arg2.NodeType == SqlNodeType.Value) { 234} else if (arg2.NodeType == SqlNodeType.ClientParameter && arg2.SqlType != arg1.SqlType) { 289if (arg2.NodeType == SqlNodeType.Value) { 292else if (arg1.NodeType == SqlNodeType.Value) { 295else if (arg2.NodeType == SqlNodeType.ClientParameter && arg2.SqlType != arg1.SqlType) { 298else if (arg1.NodeType == SqlNodeType.ClientParameter && arg1.SqlType != arg2.SqlType) {

145if (bo.NodeType == SqlNodeType.EQ || bo.NodeType == SqlNodeType.NE || 146bo.NodeType == SqlNodeType.EQ2V || bo.NodeType == SqlNodeType.NE2V || 147bo.NodeType == SqlNodeType.GT || bo.NodeType == SqlNodeType.GE || 148bo.NodeType == SqlNodeType.LT || bo.NodeType == SqlNodeType.LE ) {

29if (select.Top.NodeType == SqlNodeType.Value) {

73if (uo.NodeType != SqlNodeType.Convert) {

268result = new SqlSubSelect(SqlNodeType.Multiset, link.ClrType, link.SqlType, sel); 271result = new SqlSubSelect(SqlNodeType.Element, link.ClrType, link.SqlType, sel); 287expr.NodeType == SqlNodeType.EQ || expr.NodeType == SqlNodeType.NE || 288expr.NodeType == SqlNodeType.EQ2V || expr.NodeType == SqlNodeType.NE2V); 292if (eRight.NodeType == SqlNodeType.Element) { 298return sql.SubSelect(SqlNodeType.Exists, select); 300else if (eLeft.NodeType == SqlNodeType.Element) { 306return sql.SubSelect(SqlNodeType.Exists, select); 312if (eLeft.NodeType == SqlNodeType.TypeCase) { 315if (eRight.NodeType == SqlNodeType.TypeCase) { 325(eLeft.NodeType != SqlNodeType.New || eLeft.SqlType.CanBeColumn) && 326(eRight.NodeType != SqlNodeType.New || eRight.SqlType.CanBeColumn)) { 327if (expr.NodeType == SqlNodeType.EQ2V || expr.NodeType == SqlNodeType.NE2V) { 335return sql.Binary(SqlNodeType.EQ, sql.ValueFromObject(0,expr.SourceExpression), sql.ValueFromObject(1,expr.SourceExpression)); 362SqlNodeType eqKind = (expr.NodeType == SqlNodeType.EQ2V || expr.NodeType == SqlNodeType.NE2V) ? SqlNodeType.EQ2V : SqlNodeType.EQ; 369exp = sql.Binary(SqlNodeType.And, exp, eq); 372if (expr.NodeType == SqlNodeType.NE || expr.NodeType == SqlNodeType.NE2V) { 373exp = sql.Unary(SqlNodeType.Not, exp, exp.SourceExpression); 378private SqlExpression TranslateEqualsOp(SqlNodeType op, SqlExpression left, SqlExpression right, bool allowExpand) { 380case SqlNodeType.EQ: 381case SqlNodeType.NE: 383case SqlNodeType.EQ2V: 386SqlNodeType eqOp = allowExpand ? SqlNodeType.EQ2V : SqlNodeType.EQ; 388sql.Binary(SqlNodeType.Or, 389sql.Binary(SqlNodeType.And, 390sql.Unary(SqlNodeType.IsNull, (SqlExpression)SqlDuplicator.Copy(left)), 391sql.Unary(SqlNodeType.IsNull, (SqlExpression)SqlDuplicator.Copy(right)) 393sql.Binary(SqlNodeType.And, 394sql.Binary(SqlNodeType.And, 395sql.Unary(SqlNodeType.IsNotNull, (SqlExpression)SqlDuplicator.Copy(left)), 396sql.Unary(SqlNodeType.IsNotNull, (SqlExpression)SqlDuplicator.Copy(right)) 403SqlNodeType eqOp = allowExpand ? SqlNodeType.EQ2V : SqlNodeType.EQ; 406case SqlNodeType.NE2V: 409SqlNodeType eqOp = allowExpand ? SqlNodeType.EQ2V : SqlNodeType.EQ; 411sql.Unary(SqlNodeType.Not, 412sql.Binary(SqlNodeType.Or, 413sql.Binary(SqlNodeType.And, 414sql.Unary(SqlNodeType.IsNull, (SqlExpression)SqlDuplicator.Copy(left)), 415sql.Unary(SqlNodeType.IsNull, (SqlExpression)SqlDuplicator.Copy(right)) 417sql.Binary(SqlNodeType.And, 418sql.Binary(SqlNodeType.And, 419sql.Unary(SqlNodeType.IsNotNull, (SqlExpression)SqlDuplicator.Copy(left)), 420sql.Unary(SqlNodeType.IsNotNull, (SqlExpression)SqlDuplicator.Copy(right)) 428SqlNodeType neOp = allowExpand ? SqlNodeType.NE2V : SqlNodeType.NE; 447System.Diagnostics.Debug.Assert(expr.NodeType == SqlNodeType.IsNull || expr.NodeType == SqlNodeType.IsNotNull); 458SqlNodeType combo = (expr.NodeType == SqlNodeType.IsNull) ? SqlNodeType.Or : SqlNodeType.And; 479if (when.TypeBinding.NodeType == SqlNodeType.New) {

58case SqlNodeType.ScalarSubSelect: 59case SqlNodeType.Multiset: 60case SqlNodeType.Element: 61case SqlNodeType.SearchedCase: 62case SqlNodeType.ClientCase: 63case SqlNodeType.SimpleCase: 64case SqlNodeType.Member: 65case SqlNodeType.DiscriminatedType: 66case SqlNodeType.New: 67case SqlNodeType.FunctionCall: 68case SqlNodeType.MethodCall: 69case SqlNodeType.Convert: // Object identity does not survive convert. It does survive Cast. 72case SqlNodeType.TypeCase: 75case SqlNodeType.Link: 78case SqlNodeType.Table: 81case SqlNodeType.Value:

349case SqlNodeType.New: { 363case SqlNodeType.ColumnRef: 364case SqlNodeType.Value: 365case SqlNodeType.UserColumn: 367case SqlNodeType.Link: { 376case SqlNodeType.OptionalValue: 378case SqlNodeType.ValueOf: 379case SqlNodeType.OuterJoinedValue: 381case SqlNodeType.Lift: 383case SqlNodeType.Grouping: { 387case SqlNodeType.ClientArray: { 400case SqlNodeType.ClientCase: { 410case SqlNodeType.SearchedCase: { 420case SqlNodeType.TypeCase: { 435case SqlNodeType.DiscriminatedType: 437case SqlNodeType.JoinedCollection: { 441case SqlNodeType.Member: 443case SqlNodeType.MethodCall: { 455case SqlNodeType.ClientQuery: 457case SqlNodeType.ClientParameter: 478case SqlNodeType.New: { 498case SqlNodeType.ColumnRef: { 503case SqlNodeType.Link: { 519case SqlNodeType.Value: 521case SqlNodeType.OptionalValue: { 526case SqlNodeType.ValueOf: 527case SqlNodeType.OuterJoinedValue: 529case SqlNodeType.Lift: 531case SqlNodeType.Grouping: { 536case SqlNodeType.ClientArray: { 549case SqlNodeType.UserColumn: 551case SqlNodeType.ClientCase: { 565case SqlNodeType.SearchedCase: { 578case SqlNodeType.TypeCase: { 597case SqlNodeType.DiscriminatedType: { 602case SqlNodeType.JoinedCollection: { 607case SqlNodeType.Member: { 612case SqlNodeType.ClientQuery: { 625case SqlNodeType.MethodCall: { 641case SqlNodeType.ClientParameter: 729case SqlNodeType.New: 731case SqlNodeType.ColumnRef: 733case SqlNodeType.ClientQuery: 735case SqlNodeType.JoinedCollection: 737case SqlNodeType.Link: 739case SqlNodeType.Value: 741case SqlNodeType.ClientParameter: 743case SqlNodeType.ValueOf: 745case SqlNodeType.OptionalValue: 747case SqlNodeType.OuterJoinedValue: 749case SqlNodeType.Lift: 751case SqlNodeType.Grouping: 753case SqlNodeType.ClientArray: 755case SqlNodeType.UserColumn: 757case SqlNodeType.ClientCase: 759case SqlNodeType.SearchedCase: 761case SqlNodeType.TypeCase: 763case SqlNodeType.DiscriminatedType: 765case SqlNodeType.Member: 767case SqlNodeType.MethodCall: 1330if (expr.NodeType == SqlNodeType.Link) { 1333else if (expr.NodeType == SqlNodeType.ClientCase) { 1409if (expr.NodeType == SqlNodeType.ClientCase) { 1412else if (expr.NodeType == SqlNodeType.Link) { 1421Type clientElementType = cq.Query.NodeType == SqlNodeType.Multiset ? TypeSystem.GetElementType(cq.ClrType) : cq.ClrType; 1435if (cq.Arguments[i].NodeType == SqlNodeType.ColumnRef) {

970Type clientElementType = cq.Query.NodeType == SqlNodeType.Multiset ? TypeSystem.GetElementType(cq.ClrType) : cq.ClrType; 1626case SqlNodeType.Select: 1628case SqlNodeType.Block: { 1639if (sel == null && node.NodeType == SqlNodeType.Block) {

1052internal override ProviderType PredictTypeForUnary(SqlNodeType unaryOp, ProviderType operandType) { 1054case SqlNodeType.Not: 1055case SqlNodeType.Not2V: 1056case SqlNodeType.IsNull: 1057case SqlNodeType.IsNotNull: 1059case SqlNodeType.Negate: 1060case SqlNodeType.BitNot: 1061case SqlNodeType.ValueOf: 1062case SqlNodeType.Treat: 1063case SqlNodeType.OuterJoinedValue: 1065case SqlNodeType.Count: 1067case SqlNodeType.LongCount: 1069case SqlNodeType.Min: 1070case SqlNodeType.Max: 1072case SqlNodeType.Sum: 1073case SqlNodeType.Avg: 1074case SqlNodeType.Stddev: 1076case SqlNodeType.ClrLength: 1089internal override ProviderType PredictTypeForBinary(SqlNodeType binaryOp, ProviderType leftType, ProviderType rightType) { 1100case SqlNodeType.Add: 1101case SqlNodeType.Sub: 1102case SqlNodeType.Mul: 1103case SqlNodeType.Div: 1104case SqlNodeType.BitAnd: 1105case SqlNodeType.BitOr: 1106case SqlNodeType.BitXor: 1107case SqlNodeType.Mod: 1108case SqlNodeType.Coalesce: 1110case SqlNodeType.Concat: 1134case SqlNodeType.And: 1135case SqlNodeType.Or: 1136case SqlNodeType.LT: 1137case SqlNodeType.LE: 1138case SqlNodeType.GT: 1139case SqlNodeType.GE: 1140case SqlNodeType.EQ: 1141case SqlNodeType.NE: 1142case SqlNodeType.EQ2V: 1143case SqlNodeType.NE2V: 1238if (functionCall.Arguments[2].NodeType == SqlNodeType.Value) { 1272return PredictTypeForBinary(SqlNodeType.Concat,