333private readonly DbExpressionKind _kind; 335internal DbExpression(DbExpressionKind kind, TypeUsage type) 357public DbExpressionKind ExpressionKind { get { return _kind; } } 714internal static void CheckExpressionKind(DbExpressionKind kind) 718if ((kind < DbExpressionKind.All) || (DbExpressionKind.Lambda < kind)) 720throw EntityUtil.InvalidEnumerationValue(typeof(DbExpressionKind), (int)kind); 736internal DbBinaryExpression(DbExpressionKind kind, TypeUsage type, DbExpression left, DbExpression right) 765internal DbUnaryExpression(DbExpressionKind kind, TypeUsage resultType, DbExpression argument)

475case DbExpressionKind.Equals: 478case DbExpressionKind.NotEquals: 481case DbExpressionKind.GreaterThan: 484case DbExpressionKind.GreaterThanOrEquals: 487case DbExpressionKind.LessThan: 490case DbExpressionKind.LessThanOrEquals: 566case DbExpressionKind.Divide: 570case DbExpressionKind.Minus: 574case DbExpressionKind.Modulo: 578case DbExpressionKind.Multiply: 582case DbExpressionKind.Plus: 586case DbExpressionKind.UnaryMinus: 683if (expression.ExpressionKind == DbExpressionKind.IsOfOnly) 724if (expression.ExpressionKind == DbExpressionKind.OfTypeOnly) 908if (DbExpressionKind.InnerJoin == expression.ExpressionKind) 912else if (DbExpressionKind.LeftOuterJoin == expression.ExpressionKind) 918Debug.Assert(expression.ExpressionKind == DbExpressionKind.FullOuterJoin, "DbJoinExpression had ExpressionKind other than InnerJoin, LeftOuterJoin or FullOuterJoin?"); 939if (DbExpressionKind.CrossApply == expression.ExpressionKind) 945Debug.Assert(expression.ExpressionKind == DbExpressionKind.OuterApply, "DbApplyExpression had ExpressionKind other than CrossApply or OuterApply?"); 1036if (DbExpressionKind.All == expression.ExpressionKind) 1042Debug.Assert(expression.ExpressionKind == DbExpressionKind.Any, "DbQuantifierExpression had ExpressionKind other than All or Any?");

310return new DbQuantifierExpression(DbExpressionKind.All, booleanResultType, input, predicate); 326return new DbQuantifierExpression(DbExpressionKind.Any, booleanResultType, input, predicate); 335/// <returns>An new DbApplyExpression with the specified input and apply bindings and an <see cref="DbExpressionKind"/> of CrossApply.</returns> 340return new DbApplyExpression(DbExpressionKind.CrossApply, resultType, input, apply); 349/// <returns>An new DbApplyExpression with the specified input and apply bindings and an <see cref="DbExpressionKind"/> of OuterApply.</returns> 354return new DbApplyExpression(DbExpressionKind.OuterApply, resultType, input, apply); 361/// <returns>A new DbCrossJoinExpression, with an <see cref="DbExpressionKind"/> of CrossJoin, that represents the unconditional join of the input sets.</returns> 375/// expression bindings, on the specified join condition, using InnerJoin as the <see cref="DbExpressionKind"/>. 381/// A new DbJoinExpression, with an <see cref="DbExpressionKind"/> of InnerJoin, that represents the inner join operation applied to the left and right 393return new DbJoinExpression(DbExpressionKind.InnerJoin, resultType, left, right, joinCondition); 398/// expression bindings, on the specified join condition, using LeftOuterJoin as the <see cref="DbExpressionKind"/>. 404/// A new DbJoinExpression, with an <see cref="DbExpressionKind"/> of LeftOuterJoin, that represents the left outer join operation applied to the left and right 416return new DbJoinExpression(DbExpressionKind.LeftOuterJoin, resultType, left, right, joinCondition); 421/// expression bindings, on the specified join condition, using FullOuterJoin as the <see cref="DbExpressionKind"/>. 427/// A new DbJoinExpression, with an <see cref="DbExpressionKind"/> of FullOuterJoin, that represents the full outer join operation applied to the left and right 439return new DbJoinExpression(DbExpressionKind.FullOuterJoin, resultType, left, right, joinCondition); 728private static DbArithmeticExpression CreateArithmetic(DbExpressionKind kind, DbExpression left, DbExpression right) 747return CreateArithmetic(DbExpressionKind.Divide, left, right); 762return CreateArithmetic(DbExpressionKind.Minus, left, right); 777return CreateArithmetic(DbExpressionKind.Modulo, left, right); 792return CreateArithmetic(DbExpressionKind.Multiply, left, right); 807return CreateArithmetic(DbExpressionKind.Plus, left, right); 823return new DbArithmeticExpression(DbExpressionKind.UnaryMinus, resultType, args); 844private static DbComparisonExpression CreateComparison(DbExpressionKind kind, DbExpression left, DbExpression right) 862return DbExpressionBuilder.CreateComparison(DbExpressionKind.Equals, left, right); 877return DbExpressionBuilder.CreateComparison(DbExpressionKind.NotEquals, left, right); 892return DbExpressionBuilder.CreateComparison(DbExpressionKind.GreaterThan, left, right); 907return DbExpressionBuilder.CreateComparison(DbExpressionKind.LessThan, left, right); 922return DbExpressionBuilder.CreateComparison(DbExpressionKind.GreaterThanOrEquals, left, right); 937return DbExpressionBuilder.CreateComparison(DbExpressionKind.LessThanOrEquals, left, right); 1025/// <returns>A new DbOfTypeExpression with the specified set argument and type, and an ExpressionKind of <see cref="DbExpressionKind.OfType"/>.</returns> 1039return new DbOfTypeExpression(DbExpressionKind.OfType, collectionOfTypeResultType, argument, type); 1047/// <returns>A new DbOfTypeExpression with the specified set argument and type, and an ExpressionKind of <see cref="DbExpressionKind.OfTypeOnly"/>.</returns> 1061return new DbOfTypeExpression(DbExpressionKind.OfTypeOnly, collectionOfTypeResultType, argument, type); 1081return new DbIsOfExpression(DbExpressionKind.IsOf, booleanResultType, argument, type); 1101return new DbIsOfExpression(DbExpressionKind.IsOfOnly, booleanResultType, argument, type); 1999/// <returns>An new DbApplyExpression with the specified input and apply bindings and an <see cref="DbExpressionKind"/> of CrossApply.</returns> 2022/// <returns>An new DbApplyExpression with the specified input and apply bindings and an <see cref="DbExpressionKind"/> of OuterApply.</returns> 2039/// on the specified join condition, using FullOuterJoin as the <see cref="DbExpressionKind"/>. 2049/// A new DbJoinExpression, with an <see cref="DbExpressionKind"/> of FullOuterJoin, that represents the full outer join operation 2073/// on the specified join condition, using InnerJoin as the <see cref="DbExpressionKind"/>. 2083/// A new DbJoinExpression, with an <see cref="DbExpressionKind"/> of InnerJoin, that represents the inner join operation 2107/// on the specified join condition, using LeftOuterJoin as the <see cref="DbExpressionKind"/>. 2117/// A new DbJoinExpression, with an <see cref="DbExpressionKind"/> of LeftOuterJoin, that represents the left outer join operation 2141/// on an equality condition between the specified outer and inner keys, using InnerJoin as the <see cref="DbExpressionKind"/>. 2148/// A new DbJoinExpression, with an <see cref="DbExpressionKind"/> of InnerJoin, that represents the inner join operation 2178/// expressions, joined on an equality condition between the specified outer and inner keys, using InnerJoin as the <see cref="DbExpressionKind"/>. 2192/// The input DbJoinExpression is created with an <see cref="DbExpressionKind"/> of InnerJoin, that represents the inner join operation 2388/// <returns>An new DbProjectExpression that selects the apply column from a new DbApplyExpression with the specified input and apply bindings and an <see cref="DbExpressionKind"/> of CrossApply.</returns> 2422/// <returns>An new DbProjectExpression that selects the result of the given selector from a new DbApplyExpression with the specified input and apply bindings and an <see cref="DbExpressionKind"/> of CrossApply.</returns> 2702internal static DbApplyExpression CreateApplyExpressionByKind(DbExpressionKind applyKind, DbExpressionBinding input, DbExpressionBinding apply) 2704Debug.Assert(DbExpressionKind.CrossApply == applyKind || DbExpressionKind.OuterApply == applyKind, "Invalid ApplyType"); 2708case DbExpressionKind.CrossApply: 2711case DbExpressionKind.OuterApply: 2715throw EntityUtil.InvalidEnumerationValue(typeof(DbExpressionKind), (int)applyKind); 2719internal static DbExpression CreateJoinExpressionByKind(DbExpressionKind joinKind, DbExpression joinCondition, DbExpressionBinding input1, DbExpressionBinding input2) 2721Debug.Assert(DbExpressionKind.CrossJoin == joinKind || 2722DbExpressionKind.FullOuterJoin == joinKind || 2723DbExpressionKind.InnerJoin == joinKind || 2724DbExpressionKind.LeftOuterJoin == joinKind, 2727if (DbExpressionKind.CrossJoin == joinKind) 2738case DbExpressionKind.InnerJoin: 2741case DbExpressionKind.LeftOuterJoin: 2744case DbExpressionKind.FullOuterJoin: 2748throw EntityUtil.InvalidEnumerationValue(typeof(DbExpressionKind), (int)joinKind);

696if (count.ExpressionKind != DbExpressionKind.Constant && 697count.ExpressionKind != DbExpressionKind.ParameterReference) 911internal static TypeUsage ValidateComparison(DbExpressionKind kind, DbExpression left, DbExpression right) 921if (DbExpressionKind.GreaterThanOrEquals == kind || 922DbExpressionKind.LessThanOrEquals == kind) 927else if (DbExpressionKind.Equals == kind || 928DbExpressionKind.NotEquals == kind) 1387if (limit.ExpressionKind != DbExpressionKind.Constant && 1388limit.ExpressionKind != DbExpressionKind.ParameterReference) 2056return (expression.ExpressionKind == DbExpressionKind.Constant &&

359attrs.Add("DbExpressionKind", Enum.GetName(typeof(DbExpressionKind), expr.ExpressionKind));

62var names = Enum.GetNames(typeof(DbExpressionKind)); 65names[(int)DbExpressionKind.Divide] = "/"; 66names[(int)DbExpressionKind.Modulo] = "%"; 67names[(int)DbExpressionKind.Multiply] = "*"; 68names[(int)DbExpressionKind.Plus] = "+"; 69names[(int)DbExpressionKind.Minus] = "-"; 70names[(int)DbExpressionKind.UnaryMinus] = "-"; 73names[(int)DbExpressionKind.Equals] = "="; 74names[(int)DbExpressionKind.LessThan] = "<"; 75names[(int)DbExpressionKind.LessThanOrEquals] = "<="; 76names[(int)DbExpressionKind.GreaterThan] = ">"; 77names[(int)DbExpressionKind.GreaterThanOrEquals] = ">="; 78names[(int)DbExpressionKind.NotEquals] = "<>"; 80names[(int)DbExpressionKind.Property] = "."; 83names[(int)DbExpressionKind.InnerJoin] = "IJ"; 84names[(int)DbExpressionKind.FullOuterJoin] = "FOJ"; 85names[(int)DbExpressionKind.LeftOuterJoin] = "LOJ"; 86names[(int)DbExpressionKind.CrossApply] = "CA"; 87names[(int)DbExpressionKind.OuterApply] = "OA"; 147private void VisitExprKind(DbExpressionKind kind)

214private static Dictionary<DbExpressionKind, string> _opMap = InitializeOpMap(); 216private static Dictionary<DbExpressionKind, string> InitializeOpMap() 218Dictionary<DbExpressionKind, string> opMap = new Dictionary<DbExpressionKind, string>(12); 221opMap[DbExpressionKind.Divide] = "/"; 222opMap[DbExpressionKind.Modulo] = "%"; 223opMap[DbExpressionKind.Multiply] = "*"; 224opMap[DbExpressionKind.Plus] = "+"; 225opMap[DbExpressionKind.Minus] = "-"; 226opMap[DbExpressionKind.UnaryMinus] = "-"; 229opMap[DbExpressionKind.Equals] = "="; 230opMap[DbExpressionKind.LessThan] = "<"; 231opMap[DbExpressionKind.LessThanOrEquals] = "<="; 232opMap[DbExpressionKind.GreaterThan] = ">"; 233opMap[DbExpressionKind.GreaterThanOrEquals] = ">="; 234opMap[DbExpressionKind.NotEquals] = "<>"; 273return new TreeNode(Enum.GetName(typeof(DbExpressionKind), expr.ExpressionKind)); 572if (e.Instance.ExpressionKind == DbExpressionKind.VariableReference || 573(e.Instance.ExpressionKind == DbExpressionKind.Property && 0 == inst.Children.Count)) 621if (DbExpressionKind.UnaryMinus == e.ExpressionKind) 713if (DbExpressionKind.IsOfOnly == e.ExpressionKind) 730TreeNode retInfo = new TreeNode(e.ExpressionKind == DbExpressionKind.OfTypeOnly ? "OfTypeOnly" : "OfType");

121/// Constructs a new pattern that is matched iff both <paramref name="pattern1"/> and <paramref name="pattern2"/> are matched. Does NOT return a pattern that matches <see cref="DbAndExpression"/>. Use <see cref="MatchKind"/> with an argument of <see cref="DbExpressionKind.And"/> to match an AND expression 129/// Constructs a new pattern that is matched iff all of <paramref name="pattern1"/>, <paramref name="pattern2"/> and <paramref name="pattern3"/> are matched. Does NOT return a pattern that matches <see cref="DbAndExpression"/>. Use <see cref="MatchKind"/> with an argument of <see cref="DbExpressionKind.And"/> to match an AND expression 137/// Constructs a new pattern that is matched if either <paramref name="pattern1"/> or <paramref name="pattern2"/> are matched. Does NOT return a pattern that matches <see cref="DbOrExpression"/>. Use <see cref="MatchKind"/> with an argument of <see cref="DbExpressionKind.Or"/> to match an OR expression 145/// Constructs a new pattern that is matched if either <paramref name="pattern1"/>, <paramref name="pattern2"/> or <paramref name="pattern3"/> are matched. Does NOT return a pattern that matches <see cref="DbOrExpression"/>. Use <see cref="MatchKind"/> with an argument of <see cref="DbExpressionKind.Or"/> to match an OR expression 205/// Constructs a new pattern that will match an expression with the specified <see cref="DbExpressionKind"/>. 207internal static Func<DbExpression, bool> MatchKind(DbExpressionKind kindToMatch) 271return (e => { if (e.ExpressionKind != DbExpressionKind.Filter) { return false; } else { DbFilterExpression filterEx = (DbFilterExpression)e; return inputPattern(filterEx.Input.Expression) && predicatePattern(filterEx.Predicate); } }); 279return (e => { if (e.ExpressionKind != DbExpressionKind.Project) { return false; } else { DbProjectExpression projectEx = (DbProjectExpression)e; return inputPattern(projectEx.Input.Expression) && projectionPattern(projectEx.Projection); } }); 287return (e => { if (e.ExpressionKind != DbExpressionKind.Case) { return false; } else { DbCaseExpression caseEx = (DbCaseExpression)e; return whenPattern(caseEx.When) && thenPattern(caseEx.Then) && elsePattern(caseEx.Else); } }); 291/// Gets a pattern that is matched if the argument expression is a <see cref="DbCaseExpression"/>. This property can be used instead of repeated calls to <see cref="MatchKind"/> with an argument of <see cref="DbExpressionKind.Case"/> 293internal static Func<DbExpression, bool> MatchNewInstance() { return (e => e.ExpressionKind == DbExpressionKind.NewInstance); } 300return (e => { if (e.ExpressionKind != DbExpressionKind.NewInstance) { return false; } else { DbNewInstanceExpression newInst = (DbNewInstanceExpression)e; return argumentsPattern(newInst.Arguments); } });

90if(result.ExpressionKind == DbExpressionKind.VariableReference) 120if (result.ExpressionKind == DbExpressionKind.ParameterReference)

199if (entityProject.Projection.ExpressionKind == DbExpressionKind.Case) 342Patterns.MatchKind(DbExpressionKind.Equals), 343Patterns.MatchKind(DbExpressionKind.Or) 355Patterns.MatchKind(DbExpressionKind.Property), 356Patterns.MatchKind(DbExpressionKind.Case) 363Patterns.MatchKind(DbExpressionKind.Property), 364Patterns.MatchKind(DbExpressionKind.Or) 370Patterns.MatchForAll(Patterns.MatchKind(DbExpressionKind.Property)), 371Patterns.MatchForAll(Patterns.MatchKind(DbExpressionKind.NewInstance)), 372Patterns.MatchKind(DbExpressionKind.NewInstance) 423.Where(px => px.Instance.ExpressionKind == DbExpressionKind.VariableReference && 451if(columnVal.ExpressionKind != DbExpressionKind.Case) 458casePredicate.Then[0].ExpressionKind != DbExpressionKind.Constant || casePredicate.Else.ExpressionKind != DbExpressionKind.Constant || 539if (expression.Instance.ExpressionKind == DbExpressionKind.VariableReference && 560private static readonly Func<DbExpression, bool> Pattern_Case = Patterns.MatchKind(DbExpressionKind.Case); 592if (predicate.ExpressionKind != DbExpressionKind.Case) { return false; } 594if (caseExpression.Then.Count != 1 && caseExpression.Then[0].ExpressionKind == DbExpressionKind.Constant) 602if (caseExpression.Else.ExpressionKind != DbExpressionKind.Constant) { return false; } 621Patterns.MatchKind(DbExpressionKind.NewInstance) 726if (property.Instance.ExpressionKind == DbExpressionKind.VariableReference && 768exp => (exp.ExpressionKind != DbExpressionKind.Or), 807if (expression.ExpressionKind != DbExpressionKind.Equals) { return false; } 809if (equals.Left.ExpressionKind != DbExpressionKind.Property) { return false; } 814if (property.Instance.ExpressionKind != DbExpressionKind.VariableReference || 822if (expression.ExpressionKind == DbExpressionKind.Constant) 827if (expression.ExpressionKind == DbExpressionKind.Cast &&

30: base(DbExpressionKind.And, booleanResultType, left, right) 60: base(DbExpressionKind.Or, booleanResultType, left, right) 90: base(DbExpressionKind.Not, booleanResultType, argument) 122internal DbArithmeticExpression(DbExpressionKind kind, TypeUsage numericResultType, DbExpressionList args) 128DbExpressionKind.Divide == kind || 129DbExpressionKind.Minus == kind || 130DbExpressionKind.Modulo == kind || 131DbExpressionKind.Multiply == kind || 132DbExpressionKind.Plus == kind || 133DbExpressionKind.UnaryMinus == kind, 134"Invalid DbExpressionKind used in DbArithmeticExpression: " + Enum.GetName(typeof(DbExpressionKind), kind) 140(DbExpressionKind.UnaryMinus == kind && 1 == args.Count) || 186: base(DbExpressionKind.Case, commonResultType) 237: base(DbExpressionKind.Cast, type, argument) 264/// that is equality comparable (for <see cref="DbExpressionKind"/>.Equals and <see cref="DbExpressionKind"/>.NotEquals), 265/// order comparable (for <see cref="DbExpressionKind"/>.GreaterThan and <see cref="DbExpressionKind"/>.LessThan), 266/// or both (for <see cref="DbExpressionKind"/>.GreaterThanOrEquals and <see cref="DbExpressionKind"/>.LessThanOrEquals). 271internal DbComparisonExpression(DbExpressionKind kind, TypeUsage booleanResultType, DbExpression left, DbExpression right) 278DbExpressionKind.Equals == kind || 279DbExpressionKind.LessThan == kind || 280DbExpressionKind.LessThanOrEquals == kind || 281DbExpressionKind.GreaterThan == kind || 282DbExpressionKind.GreaterThanOrEquals == kind || 283DbExpressionKind.NotEquals == kind, 284"Invalid DbExpressionKind used in DbComparisonExpression: " + Enum.GetName(typeof(DbExpressionKind), kind) 312: base(DbExpressionKind.IsEmpty, booleanResultType, argument) 341: base(DbExpressionKind.IsNull, booleanResultType, arg) 371internal DbIsOfExpression(DbExpressionKind isOfKind, TypeUsage booleanResultType, DbExpression argument, TypeUsage isOfType) 374Debug.Assert(DbExpressionKind.IsOf == this.ExpressionKind || DbExpressionKind.IsOfOnly == this.ExpressionKind, string.Format(CultureInfo.InvariantCulture, "Invalid DbExpressionKind used in DbIsOfExpression: {0}", Enum.GetName(typeof(DbExpressionKind), this.ExpressionKind))); 413internal DbOfTypeExpression(DbExpressionKind ofTypeKind, TypeUsage collectionResultType, DbExpression argument, TypeUsage type) 416Debug.Assert(DbExpressionKind.OfType == ofTypeKind || 417DbExpressionKind.OfTypeOnly == ofTypeKind, 458: base(DbExpressionKind.Treat, asType, argument) 491: base(DbExpressionKind.Like, booleanResultType) 545: base(DbExpressionKind.EntityRef, refResultType, entity) 574: base(DbExpressionKind.RefKey, rowResultType, reference)

30internal DbApplyExpression(DbExpressionKind applyKind, TypeUsage resultRowCollectionTypeUsage, DbExpressionBinding input, DbExpressionBinding apply) 35Debug.Assert(DbExpressionKind.CrossApply == applyKind || DbExpressionKind.OuterApply == applyKind, "Invalid DbExpressionKind for DbApplyExpression"); 79: base(DbExpressionKind.Distinct, resultType, argument) 114: base(DbExpressionKind.Element, resultType, argument) 120: base(DbExpressionKind.Element, resultType, argument) 158: base(DbExpressionKind.Except, resultType, left, right) 190: base(DbExpressionKind.Filter, resultType) 241: base(DbExpressionKind.GroupBy, collectionOfRowResultType) 295: base(DbExpressionKind.Intersect, resultType, left, right) 325: base(DbExpressionKind.CrossJoin, collectionOfRowResultType) 365internal DbJoinExpression(DbExpressionKind joinKind, TypeUsage collectionOfRowResultType, DbExpressionBinding left, DbExpressionBinding right, DbExpression condition) 371Debug.Assert(DbExpressionKind.InnerJoin == joinKind || 372DbExpressionKind.LeftOuterJoin == joinKind || 373DbExpressionKind.FullOuterJoin == joinKind, 424: base(DbExpressionKind.Limit, resultType) 477: base(DbExpressionKind.Project, resultType) 522internal DbQuantifierExpression(DbExpressionKind kind, TypeUsage booleanResultType, DbExpressionBinding input, DbExpression predicate) 607: base(DbExpressionKind.Skip, resultType) 664: base(DbExpressionKind.Sort, resultType) 711: base(DbExpressionKind.UnionAll, resultType, left, right)

29: base(DbExpressionKind.Constant, resultType) 107: base(DbExpressionKind.Null, type) 137: base(DbExpressionKind.VariableReference, type) 175: base(DbExpressionKind.ParameterReference, type) 214: base(DbExpressionKind.Property, resultType) 279: base(DbExpressionKind.Function, resultType) 326: base(DbExpressionKind.Lambda, resultType) 496: base(DbExpressionKind.RelationshipNavigation, resultType) 639: base(DbExpressionKind.NewInstance, type) 696: base(DbExpressionKind.Ref, refResultType, refKeys) 732: base(DbExpressionKind.Deref, entityResultType, refExpr) 763: base(DbExpressionKind.Scan, collectionOfEntityType)

2983if (expr.ExpressionKind != DbExpressionKind.Constant && 2984expr.ExpressionKind != DbExpressionKind.ParameterReference) 3199DbExpressionKind joinKind = MapJoinKind(joinClause.JoinKind); 3207if (DbExpressionKind.CrossJoin != joinKind) 3237/// Maps <see cref="AST.JoinKind"/> to <see cref="DbExpressionKind"/>. 3239private static DbExpressionKind MapJoinKind(AST.JoinKind joinKind) 3244private static readonly DbExpressionKind[] joinMap = { DbExpressionKind.CrossJoin, DbExpressionKind.InnerJoin, DbExpressionKind.LeftOuterJoin, DbExpressionKind.FullOuterJoin }; 3288/// Maps <see cref="AST.ApplyKind"/> to <see cref="DbExpressionKind"/>. 3290private static DbExpressionKind MapApplyKind(AST.ApplyKind applyKind) 3294private static readonly DbExpressionKind[] applyMap = { DbExpressionKind.CrossApply, DbExpressionKind.OuterApply }; 3615converted = converted.ExpressionKind == CommandTrees.DbExpressionKind.Null ? converted : converted.ResultType.Null(); 3952if (lambdaBody.ExpressionKind != DbExpressionKind.Project) 3965if (projectExpression.Projection.ExpressionKind == DbExpressionKind.VariableReference) 3970else if (projectExpression.Projection.ExpressionKind == DbExpressionKind.NewInstance && 3985if (projectionExpression.Arguments[i].ExpressionKind != DbExpressionKind.Property) 4309Debug.Assert(right.ExpressionKind == DbExpressionKind.NewInstance, "right.ExpressionKind == DbExpressionKind.NewInstance"); 4757if (args.Right.ExpressionKind == DbExpressionKind.NewInstance) 4792if (args.Right.ExpressionKind == DbExpressionKind.NewInstance)

139if (DbExpressionKind.InnerJoin != node.ExpressionKind && DbExpressionKind.LeftOuterJoin != node.ExpressionKind)

190if (DbExpressionKind.IsOfOnly != predicate.ExpressionKind) 219if (DbExpressionKind.Equals == predicate.ExpressionKind)

64Debug.Assert(DbExpressionKind.LeftOuterJoin == node.ExpressionKind || DbExpressionKind.InnerJoin == node.ExpressionKind, "(Update/JoinPropagagtor/JoinEvaluator) " + 67if (DbExpressionKind.InnerJoin == m_joinExpression.ExpressionKind)

124if (DbExpressionKind.Equals == node.ExpressionKind)

417if (valueExpression.ExpressionKind == DbExpressionKind.Null)

79if (queryView.ExpressionKind != DbExpressionKind.Project) { return false; } 82if (project.Projection.ExpressionKind != DbExpressionKind.Case) { return false; } 87if (project.Input.Expression.ExpressionKind != DbExpressionKind.Filter) { return false; } 189if (then.ExpressionKind != DbExpressionKind.NewInstance) 258case DbExpressionKind.Property: 265case DbExpressionKind.VariableReference: 268case DbExpressionKind.NewInstance: 282case DbExpressionKind.Ref:

84private void ValidateExpressionKind(DbExpressionKind expressionKind) 89case DbExpressionKind.Constant: 90case DbExpressionKind.Property: 91case DbExpressionKind.Null: 92case DbExpressionKind.VariableReference: 93case DbExpressionKind.Cast: 94case DbExpressionKind.Case: 95case DbExpressionKind.Not: 96case DbExpressionKind.Or: 97case DbExpressionKind.And: 98case DbExpressionKind.IsNull: 99case DbExpressionKind.Equals: 100case DbExpressionKind.NotEquals: 101case DbExpressionKind.LessThan: 102case DbExpressionKind.LessThanOrEquals: 103case DbExpressionKind.GreaterThan: 104case DbExpressionKind.GreaterThanOrEquals: 105case DbExpressionKind.Project: 106case DbExpressionKind.NewInstance: 107case DbExpressionKind.Filter: 108case DbExpressionKind.Ref: 109case DbExpressionKind.UnionAll: 110case DbExpressionKind.Scan: 111case DbExpressionKind.FullOuterJoin: 112case DbExpressionKind.LeftOuterJoin: 113case DbExpressionKind.InnerJoin: 114case DbExpressionKind.EntityRef: 115case DbExpressionKind.Function:

491if (projection.ExpressionKind == DbExpressionKind.VariableReference && 849if (input.ExpressionKind == DbExpressionKind.Project && !TryGetSpan(input, out span)) 1251case DbExpressionKind.Constant: 1254case DbExpressionKind.Constant: // constant EQ constant 1256case DbExpressionKind.Null: // null EQ constant --> false 1261case DbExpressionKind.Null: 1264case DbExpressionKind.Constant: // null EQ constant --> false 1266case DbExpressionKind.Null: // null EQ null --> true 1274case DbExpressionKind.Constant: 1276case DbExpressionKind.Null: // left EQ null --> left IS NULL 1374if (providerSupportsEscapingLikeArgument && translatedPatternExpression.ExpressionKind == DbExpressionKind.Constant)

443if (arg.ExpressionKind == DbExpressionKind.Constant) 897case DbExpressionKind.Constant: 900case DbExpressionKind.ParameterReference: 903case DbExpressionKind.Null: 1193if (argument.ExpressionKind != DbExpressionKind.Constant || 1626return new DbJoinExpression(DbExpressionKind.InnerJoin, TypeUsage.Create(TypeHelpers.CreateCollectionType(resultType)), outerBinding, innerBinding, joinCondition); 2188bool requireSentinel = !(null == defaultValue || defaultValue.ExpressionKind == DbExpressionKind.Null); 2247if (source.ExpressionKind == DbExpressionKind.NewInstance) 2259IEnumerable<DbExpression> constantArguments = arguments.Where(argument => argument.ExpressionKind == DbExpressionKind.Constant); 2267IEnumerable<DbExpression> otherArguments = arguments.Where(argument => argument.ExpressionKind != DbExpressionKind.Constant); 2548return new DbApplyExpression(DbExpressionKind.OuterApply, TypeUsage.Create(TypeHelpers.CreateCollectionType(resultType)), newInput, newApply); 2611if (cqtExpression.ExpressionKind != DbExpressionKind.CrossApply) 2625if (crossApply.Apply.Expression.ExpressionKind != DbExpressionKind.Project) 2632if (rightProject.Input.Expression.ExpressionKind != DbExpressionKind.LeftOuterJoin) 2638if (rightProject.Projection.ExpressionKind != DbExpressionKind.Property) 2650loj.JoinCondition.ExpressionKind != DbExpressionKind.Constant) 2669if (loj.Left.Expression.ExpressionKind != DbExpressionKind.NewInstance) 2674if (lojLeft.Arguments.Count != 1 || lojLeft.Arguments[0].ExpressionKind != DbExpressionKind.Constant) 2683if (loj.Right.Expression.ExpressionKind != DbExpressionKind.Property) 2922if (cqtExpression.ExpressionKind != DbExpressionKind.Project) 2928if (project.Projection.ExpressionKind != DbExpressionKind.NewInstance || 2939if (projection.Arguments[i].ExpressionKind != DbExpressionKind.Property) 2952if (project.Input.Expression.ExpressionKind != DbExpressionKind.Project) 2958if (innerProject.Projection.ExpressionKind != DbExpressionKind.NewInstance || 3016if (DbExpressionKind.Sort != source.ExpressionKind)

102if (source.ExpressionKind == DbExpressionKind.Sort) 106if (source.ExpressionKind == DbExpressionKind.Project) 110if (projectInput.ExpressionKind == DbExpressionKind.Sort) 114if (projectInput.ExpressionKind == DbExpressionKind.Skip) 118if (projectInput.ExpressionKind == DbExpressionKind.Limit) 122if (limitInput.ExpressionKind == DbExpressionKind.Sort) 126if (limitInput.ExpressionKind == DbExpressionKind.Skip) 132if (source.ExpressionKind == DbExpressionKind.Skip) 136if (source.ExpressionKind == DbExpressionKind.Limit) 140if (limitInput.ExpressionKind == DbExpressionKind.Sort) 144if (limitInput.ExpressionKind == DbExpressionKind.Skip) 148if (limitInput.ExpressionKind == DbExpressionKind.Project) 152if (projectInput.ExpressionKind == DbExpressionKind.Sort) 158if (projectInput.ExpressionKind == DbExpressionKind.Skip) 240if (left.ExpressionKind == DbExpressionKind.Constant && 241right.ExpressionKind == DbExpressionKind.Constant) 329if (_limit.Limit.ExpressionKind == DbExpressionKind.Constant && 330k.ExpressionKind == DbExpressionKind.Constant) 381if (_limit.Limit.ExpressionKind == DbExpressionKind.Constant && 382k.ExpressionKind == DbExpressionKind.Constant) 452if (_limit.Limit.ExpressionKind == DbExpressionKind.Constant && 453k.ExpressionKind == DbExpressionKind.Constant) 476if (_skip.Count.ExpressionKind == DbExpressionKind.Constant && 477_limit.Limit.ExpressionKind == DbExpressionKind.Constant && 478k.ExpressionKind == DbExpressionKind.Constant) 549if (_limit.Limit.ExpressionKind == DbExpressionKind.Constant && 550k.ExpressionKind == DbExpressionKind.Constant) 623if (_skip.Count.ExpressionKind == DbExpressionKind.Constant && 624k.ExpressionKind == DbExpressionKind.Constant) 672if (_skip.Count.ExpressionKind == DbExpressionKind.Constant && 673k.ExpressionKind == DbExpressionKind.Constant)

332if (DbExpressionKind.Property == instance.ExpressionKind)

171case DbExpressionKind.Element: 173case DbExpressionKind.Limit: 222if (DbExpressionKind.NewInstance == expression.ExpressionKind) 463if (DbExpressionKind.Project == expression.ExpressionKind) 784case DbExpressionKind.RelationshipNavigation: 785case DbExpressionKind.Distinct: 786case DbExpressionKind.Filter: 787case DbExpressionKind.Limit: 788case DbExpressionKind.OfType: 789case DbExpressionKind.Project: 790case DbExpressionKind.Sort: 791case DbExpressionKind.Skip: 834if (DbExpressionKind.Deref == testExpr.ExpressionKind) 839if (DbExpressionKind.VariableReference == testExpr.ExpressionKind)

1865private DbExpression VisitBinaryJoin(Node joinNode, DbExpressionKind joinKind) 1986return VisitBinaryJoin(n, DbExpressionKind.InnerJoin); 1992return VisitBinaryJoin(n, DbExpressionKind.LeftOuterJoin); 1998return VisitBinaryJoin(n, DbExpressionKind.FullOuterJoin); 2011private DbExpression VisitApply(Node applyNode, DbExpressionKind applyKind) 2061return VisitApply(n, DbExpressionKind.CrossApply); 2067return VisitApply(n, DbExpressionKind.OuterApply);

194private static Dictionary<DbExpressionKind, OpType> s_opMap = InitializeExpressionKindToOpTypeMap(); 217private static Dictionary<DbExpressionKind, OpType> InitializeExpressionKindToOpTypeMap() 219Dictionary<DbExpressionKind, OpType> opMap = new Dictionary<DbExpressionKind, OpType>(12); 224opMap[DbExpressionKind.Plus] = OpType.Plus; 225opMap[DbExpressionKind.Minus] = OpType.Minus; 226opMap[DbExpressionKind.Multiply] = OpType.Multiply; 227opMap[DbExpressionKind.Divide] = OpType.Divide; 228opMap[DbExpressionKind.Modulo] = OpType.Modulo; 229opMap[DbExpressionKind.UnaryMinus] = OpType.UnaryMinus; 234opMap[DbExpressionKind.Equals] = OpType.EQ; 235opMap[DbExpressionKind.NotEquals] = OpType.NE; 236opMap[DbExpressionKind.LessThan] = OpType.LT; 237opMap[DbExpressionKind.GreaterThan] = OpType.GT; 238opMap[DbExpressionKind.LessThanOrEquals] = OpType.LE; 239opMap[DbExpressionKind.GreaterThanOrEquals] = OpType.GE; 275PlanCompiler.Assert(ctree.Query.ExpressionKind == DbExpressionKind.Project, 365case DbExpressionKind.Equals: 366case DbExpressionKind.NotEquals: 367case DbExpressionKind.LessThan: 368case DbExpressionKind.LessThanOrEquals: 369case DbExpressionKind.GreaterThan: 370case DbExpressionKind.GreaterThanOrEquals: 371case DbExpressionKind.And: 372case DbExpressionKind.Or: 373case DbExpressionKind.Not: 374case DbExpressionKind.Like: 375case DbExpressionKind.IsEmpty: 376case DbExpressionKind.IsNull: 377case DbExpressionKind.IsOf: 378case DbExpressionKind.IsOfOnly: 379case DbExpressionKind.Any: 380case DbExpressionKind.All: 382case DbExpressionKind.VariableReference: 385case DbExpressionKind.Lambda: 401case DbExpressionKind.Function: 530List<Node> arguments = new List<Node>((expr.ExpressionKind == DbExpressionKind.IsNull) ? 3 : 5); 539if (expr.ExpressionKind != DbExpressionKind.IsNull) 549if (expr.ExpressionKind != DbExpressionKind.IsNull) 1212if (propertyExpression.Instance.ExpressionKind == DbExpressionKind.Property && 1265if (e.Instance.ExpressionKind == DbExpressionKind.NewInstance && 1325(e.ExpressionKind == DbExpressionKind.Equals || e.ExpressionKind == DbExpressionKind.NotEquals)) 1474if (e.Argument.ExpressionKind == DbExpressionKind.IsNull) 1478else if (e.Argument.ExpressionKind == DbExpressionKind.Not) 1481if (notExpression.Argument.ExpressionKind == DbExpressionKind.IsNull) 1591PlanCompiler.Assert(DbExpressionKind.Except == expression.ExpressionKind || 1592DbExpressionKind.Intersect == expression.ExpressionKind || 1593DbExpressionKind.UnionAll == expression.ExpressionKind, 1623case DbExpressionKind.Except: 1627case DbExpressionKind.Intersect: 1631case DbExpressionKind.UnionAll: 1678if (DbExpressionKind.IsOfOnly == e.ExpressionKind) 1734this.isExact = (template.ExpressionKind == DbExpressionKind.IsOfOnly); 1740this.isExact = (template.ExpressionKind == DbExpressionKind.OfTypeOnly); 1838return Merge(other.OfType, (other.ExpressionKind == DbExpressionKind.IsOfOnly)); 1843return Merge(other.OfType, (other.ExpressionKind == DbExpressionKind.OfTypeOnly)); 1875if(filter.Predicate.ExpressionKind != DbExpressionKind.IsOf && 1876filter.Predicate.ExpressionKind != DbExpressionKind.IsOfOnly) 1882return (isOfArgument.ExpressionKind == DbExpressionKind.VariableReference && 1906case DbExpressionKind.Distinct: 1912case DbExpressionKind.Filter: 1931case DbExpressionKind.OfType: 1932case DbExpressionKind.OfTypeOnly: 1946case DbExpressionKind.Project: 1949if(project.Projection.ExpressionKind == DbExpressionKind.VariableReference && 1963case DbExpressionKind.Sort: 2283PlanCompiler.Assert(DbExpressionKind.CrossJoin == e.ExpressionKind || 2284DbExpressionKind.InnerJoin == e.ExpressionKind || 2285DbExpressionKind.LeftOuterJoin == e.ExpressionKind || 2286DbExpressionKind.FullOuterJoin == e.ExpressionKind, 2336case DbExpressionKind.CrossJoin: 2342case DbExpressionKind.InnerJoin: 2348case DbExpressionKind.LeftOuterJoin: 2354case DbExpressionKind.FullOuterJoin: 2369if (e.ExpressionKind != DbExpressionKind.CrossJoin) 2416PlanCompiler.Assert(DbExpressionKind.CrossApply == e.ExpressionKind || DbExpressionKind.OuterApply == e.ExpressionKind, "Unrecognized DbExpressionKind specified in DbApplyExpression"); 2422if (DbExpressionKind.CrossApply == e.ExpressionKind) 2960PlanCompiler.Assert(DbExpressionKind.Any == e.ExpressionKind || DbExpressionKind.All == e.ExpressionKind, "Invalid DbExpressionKind in DbQuantifierExpression"); 2979if (DbExpressionKind.All == e.ExpressionKind) 3025if (DbExpressionKind.All == e.ExpressionKind)

511Debug.Assert(expression.ExpressionKind == DbExpressionKind.Equals, 531Debug.Assert(propertyExpression.ExpressionKind == DbExpressionKind.Property, 538if (value.ExpressionKind != DbExpressionKind.Null) 540Debug.Assert(value.ExpressionKind == DbExpressionKind.Constant,

69/// <see cref="TransformIntersectOrExcept(DbExpression left, DbExpression right, DbExpressionKind expressionKind, IList<DbPropertyExpression> sortExpressionsOverLeft, string sortExpressionsBindingVariableName)"/> 75return TransformIntersectOrExcept(VisitExpression(e.Left), VisitExpression(e.Right), DbExpressionKind.Except); 79/// <see cref="TransformIntersectOrExcept(DbExpression left, DbExpression right, DbExpressionKind expressionKind, IList<DbPropertyExpression> sortExpressionsOverLeft, string sortExpressionsBindingVariableName)"/> 85return TransformIntersectOrExcept(VisitExpression(e.Left), VisitExpression(e.Right), DbExpressionKind.Intersect); 109/// NON-DISTINCT EXCEPT (specially translated, <see cref="TransformIntersectOrExcept(DbExpression left, DbExpression right, DbExpressionKind expressionKind, IList<DbPropertyExpression> sortExpressionsOverLeft, string sortExpressionsBindingVariableName)"/> 141if (sortClause.Expression.ExpressionKind == DbExpressionKind.Property) 147DbExpression exceptExpression = TransformIntersectOrExcept(leftInput, rightInput, DbExpressionKind.Skip, sortExpressions, e.Input.VariableName); 159/// <see cref="TransformIntersectOrExcept(DbExpression left, DbExpression right, DbExpressionKind expressionKind, IList<DbPropertyExpression> sortExpressionsOverLeft, string sortExpressionsBindingVariableName)"/> 165private DbExpression TransformIntersectOrExcept(DbExpression left, DbExpression right, DbExpressionKind expressionKind) 208private DbExpression TransformIntersectOrExcept(DbExpression left, DbExpression right, DbExpressionKind expressionKind, IList<DbPropertyExpression> sortExpressionsOverLeft, string sortExpressionsBindingVariableName) 210bool negate = (expressionKind == DbExpressionKind.Except) || (expressionKind == DbExpressionKind.Skip); 211bool distinct = (expressionKind == DbExpressionKind.Except) || (expressionKind == DbExpressionKind.Intersect); 226if (expressionKind == DbExpressionKind.Skip) 324/// Helper method for <see cref="TransformIntersectOrExcept(DbExpression left, DbExpression right, DbExpressionKind expressionKind, IList<DbPropertyExpression> sortExpressionsOverLeft, string sortExpressionsBindingVariableName)"/> 402if (expr1.Instance.ExpressionKind == DbExpressionKind.Property) 415/// Helper method for <see cref="TransformIntersectOrExcept(DbExpression left, DbExpression right, DbExpressionKind expressionKind, IList<DbPropertyExpression> sortExpressionsOverLeft, string sortExpressionsBindingVariableName)"/>

806if (instanceExpression.ExpressionKind != DbExpressionKind.Function)

581return VisitBinaryExpression(" AND ", DbExpressionKind.And, e.Left, e.Right); 601case DbExpressionKind.CrossApply: 605case DbExpressionKind.OuterApply: 616return VisitJoinExpression(inputs, DbExpressionKind.CrossJoin, joinString, null); 631case DbExpressionKind.Divide: 634case DbExpressionKind.Minus: 637case DbExpressionKind.Modulo: 640case DbExpressionKind.Multiply: 643case DbExpressionKind.Plus: 647case DbExpressionKind.UnaryMinus: 736case DbExpressionKind.Equals: 739case DbExpressionKind.LessThan: 742case DbExpressionKind.LessThanOrEquals: 745case DbExpressionKind.GreaterThan: 748case DbExpressionKind.GreaterThanOrEquals: 752case DbExpressionKind.NotEquals: 795if (e.ExpressionKind == DbExpressionKind.Like) 824if (expr.ExpressionKind == DbExpressionKind.Function) 869return (argument.ExpressionKind == DbExpressionKind.Property) && 882DbExpressionKind expressionKind = argument.ExpressionKind; 890return (expressionKind == DbExpressionKind.Constant || 891expressionKind == DbExpressionKind.ParameterReference || 892expressionKind == DbExpressionKind.Null) && 1630case DbExpressionKind.FullOuterJoin: 1634case DbExpressionKind.InnerJoin: 1638case DbExpressionKind.LeftOuterJoin: 1673if (e.Escape.ExpressionKind != DbExpressionKind.Null) 1804if (comparisonExpression.ExpressionKind == DbExpressionKind.Equals) 1812SqlBuilder binaryResult = VisitBinaryExpression(" <> ", DbExpressionKind.NotEquals, comparisonExpression.Left, comparisonExpression.Right); 1921var realValues = values.Where(v => v.ExpressionKind != DbExpressionKind.IsNull); 1970DbIsNullExpression isNullExpression = values.FirstOrDefault(v => v.ExpressionKind == DbExpressionKind.IsNull) as DbIsNullExpression; 2015case DbExpressionKind.Constant: 2058case DbExpressionKind.Property: 2064case DbExpressionKind.ParameterReference: 2070case DbExpressionKind.VariableReference: 2074case DbExpressionKind.Cast: 2094case DbExpressionKind.Property: 2098case DbExpressionKind.ParameterReference: 2102case DbExpressionKind.VariableReference: 2106case DbExpressionKind.Cast: 2125return (e.ExpressionKind == DbExpressionKind.Property 2126|| e.ExpressionKind == DbExpressionKind.VariableReference 2127|| e.ExpressionKind == DbExpressionKind.ParameterReference); 2164case DbExpressionKind.Equals: 2168case DbExpressionKind.IsNull: 2178case DbExpressionKind.Or: 2399bool negatePredicate = (e.ExpressionKind == DbExpressionKind.All); 2400if (e.ExpressionKind == DbExpressionKind.Any) 2406Debug.Assert(e.ExpressionKind == DbExpressionKind.All); 2716private SqlBuilder VisitBinaryExpression(string op, DbExpressionKind expressionKind, DbExpression left, DbExpression right) 2744private static IEnumerable<DbExpression> FlattenAssociativeExpression(DbExpressionKind kind, DbExpression left, DbExpression right) 2746if(kind != DbExpressionKind.Or && 2747kind != DbExpressionKind.And && 2748kind != DbExpressionKind.Plus && 2749kind != DbExpressionKind.Multiply) 2770private static void ExtractAssociativeArguments(DbExpressionKind expressionKind, List<DbExpression> argumentList, DbExpression expression) 2806if (left.ExpressionKind == DbExpressionKind.Constant) 2817if (right.ExpressionKind == DbExpressionKind.Constant) 2915if (e.Arguments.Count == 1 && e.Arguments[0].ExpressionKind == DbExpressionKind.Element) 2920if (!IsCompatible(result, DbExpressionKind.Element)) 2975if (e.Argument.ExpressionKind == DbExpressionKind.ParameterReference) 3017private ISqlFragment VisitJoinExpression(IList<DbExpressionBinding> inputs, DbExpressionKind joinKind, 3055bool needsJoinContext = (input.Expression.ExpressionKind == DbExpressionKind.Scan) 3080case DbExpressionKind.FullOuterJoin: 3081case DbExpressionKind.InnerJoin: 3082case DbExpressionKind.LeftOuterJoin: 3897if (e.ExpressionKind == DbExpressionKind.Constant) 3921return (DbExpressionKind.CrossApply == e.ExpressionKind || DbExpressionKind.OuterApply == e.ExpressionKind); 3933return (DbExpressionKind.CrossJoin == e.ExpressionKind || 3934DbExpressionKind.FullOuterJoin == e.ExpressionKind || 3935DbExpressionKind.InnerJoin == e.ExpressionKind || 3936DbExpressionKind.LeftOuterJoin == e.ExpressionKind); 3952case DbExpressionKind.Constant: 3953case DbExpressionKind.ParameterReference: 3954case DbExpressionKind.Property: 3955case DbExpressionKind.Cast: 3970private static bool IsCompatible(SqlSelectStatement result, DbExpressionKind expressionKind) 3974case DbExpressionKind.Distinct: 3981case DbExpressionKind.Filter: 3987case DbExpressionKind.GroupBy: 3994case DbExpressionKind.Limit: 3995case DbExpressionKind.Element: 3998case DbExpressionKind.Project: 4008case DbExpressionKind.Skip: 4014case DbExpressionKind.Sort: 4085case DbExpressionKind.Project: 4086case DbExpressionKind.Filter: 4087case DbExpressionKind.GroupBy: 4088case DbExpressionKind.Sort: 4100case DbExpressionKind.Scan: 4101case DbExpressionKind.CrossJoin: 4102case DbExpressionKind.FullOuterJoin: 4103case DbExpressionKind.InnerJoin: 4104case DbExpressionKind.LeftOuterJoin: 4105case DbExpressionKind.CrossApply: 4106case DbExpressionKind.OuterApply: 4157if (!IsCompatible(result, DbExpressionKind.Filter)) 4196private static void WrapNonQueryExtent(SqlSelectStatement result, ISqlFragment sqlFragment, DbExpressionKind expressionKind) 4200case DbExpressionKind.Function: 4335if (allowConstants && (expression.ExpressionKind == DbExpressionKind.Constant)) 4341if (expression.ExpressionKind == DbExpressionKind.Cast) 4348if (expression.ExpressionKind == DbExpressionKind.Property) 4354if (expression.ExpressionKind == DbExpressionKind.VariableReference)