public override DbExpression Visit(DbNewInstanceExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; TypeUsage newType = this.VisitTypeUsage(expression.ResultType); IList <DbExpression> newArguments = this.VisitExpressionList(expression.Arguments); bool unchanged = (object.ReferenceEquals(expression.ResultType, newType) && object.ReferenceEquals(expression.Arguments, newArguments)); if (expression.HasRelatedEntityReferences) { IList <DbRelatedEntityRef> newRefs = this.VisitList(expression.RelatedEntityReferences, this.VisitRelatedEntityRef); if (!unchanged || !object.ReferenceEquals(expression.RelatedEntityReferences, newRefs)) { result = CqtBuilder.CreateNewEntityWithRelationshipsExpression((EntityType)newType.EdmType, newArguments, newRefs); } } else { if (!unchanged) { result = CqtBuilder.New(newType, System.Linq.Enumerable.ToArray(newArguments)); } } NotifyIfChanged(expression, result); return(result); }
protected virtual DbLambda VisitLambda(DbLambda lambda) { EntityUtil.CheckArgumentNull(lambda, "lambda"); DbLambda result = lambda; IList <DbVariableReferenceExpression> newFormals = this.VisitList(lambda.Variables, varRef => { TypeUsage newVarType = this.VisitTypeUsage(varRef.ResultType); if (!object.ReferenceEquals(varRef.ResultType, newVarType)) { return(CqtBuilder.Variable(newVarType, varRef.VariableName)); } else { return(varRef); } } ); this.EnterScope(newFormals.ToArray()); // ToArray: Don't pass the List instance directly to OnEnterScope DbExpression newBody = this.VisitExpression(lambda.Body); this.ExitScope(); if (!object.ReferenceEquals(lambda.Variables, newFormals) || !object.ReferenceEquals(lambda.Body, newBody)) { result = CqtBuilder.Lambda(newBody, newFormals); } return(result); }
public override DbExpression Visit(DbJoinExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; DbExpressionBinding newLeft = this.VisitExpressionBinding(expression.Left); DbExpressionBinding newRight = this.VisitExpressionBinding(expression.Right); this.EnterScope(newLeft.Variable, newRight.Variable); DbExpression newCondition = this.VisitExpression(expression.JoinCondition); this.ExitScope(); if (!object.ReferenceEquals(expression.Left, newLeft) || !object.ReferenceEquals(expression.Right, newRight) || !object.ReferenceEquals(expression.JoinCondition, newCondition)) { if (DbExpressionKind.InnerJoin == expression.ExpressionKind) { result = CqtBuilder.InnerJoin(newLeft, newRight, newCondition); } else if (DbExpressionKind.LeftOuterJoin == expression.ExpressionKind) { result = CqtBuilder.LeftOuterJoin(newLeft, newRight, newCondition); } else { Debug.Assert(expression.ExpressionKind == DbExpressionKind.FullOuterJoin, "DbJoinExpression had ExpressionKind other than InnerJoin, LeftOuterJoin or FullOuterJoin?"); result = CqtBuilder.FullOuterJoin(newLeft, newRight, newCondition); } } NotifyIfChanged(expression, result); return(result); }
public override DbExpression Visit(DbApplyExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; DbExpressionBinding newInput = this.VisitExpressionBindingEnterScope(expression.Input); DbExpressionBinding newApply = this.VisitExpressionBinding(expression.Apply); this.ExitScope(); if (!object.ReferenceEquals(expression.Input, newInput) || !object.ReferenceEquals(expression.Apply, newApply)) { if (DbExpressionKind.CrossApply == expression.ExpressionKind) { result = CqtBuilder.CrossApply(newInput, newApply); } else { Debug.Assert(expression.ExpressionKind == DbExpressionKind.OuterApply, "DbApplyExpression had ExpressionKind other than CrossApply or OuterApply?"); result = CqtBuilder.OuterApply(newInput, newApply); } } NotifyIfChanged(expression, result); return(result); }
protected virtual DbFunctionAggregate VisitFunctionAggregate(DbFunctionAggregate aggregate) { DbFunctionAggregate result = aggregate; if (aggregate != null) { EdmFunction newFunction = this.VisitFunction(aggregate.Function); IList <DbExpression> newArguments = this.VisitExpressionList(aggregate.Arguments); Debug.Assert(newArguments.Count == 1, "Function aggregate had more than one argument?"); if (!object.ReferenceEquals(aggregate.Function, newFunction) || !object.ReferenceEquals(aggregate.Arguments, newArguments)) { if (aggregate.Distinct) { result = CqtBuilder.AggregateDistinct(newFunction, newArguments[0]); } else { result = CqtBuilder.Aggregate(newFunction, newArguments[0]); } } } return(result); }
public override DbExpression Visit(DbQuantifierExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; DbExpressionBinding input = this.VisitExpressionBindingEnterScope(expression.Input); DbExpression predicate = this.VisitExpression(expression.Predicate); this.ExitScope(); if (!object.ReferenceEquals(expression.Input, input) || !object.ReferenceEquals(expression.Predicate, predicate)) { if (DbExpressionKind.All == expression.ExpressionKind) { result = CqtBuilder.All(input, predicate); } else { Debug.Assert(expression.ExpressionKind == DbExpressionKind.Any, "DbQuantifierExpression had ExpressionKind other than All or Any?"); result = CqtBuilder.Any(input, predicate); } } NotifyIfChanged(expression, result); return(result); }
public override DbExpression Visit(DbGroupByExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; DbGroupExpressionBinding newInput = this.VisitGroupExpressionBinding(expression.Input); this.EnterScope(newInput.Variable); IList <DbExpression> newKeys = this.VisitExpressionList(expression.Keys); this.ExitScope(); this.EnterScope(newInput.GroupVariable); IList <DbAggregate> newAggs = this.VisitList <DbAggregate>(expression.Aggregates, this.VisitAggregate); this.ExitScope(); if (!object.ReferenceEquals(expression.Input, newInput) || !object.ReferenceEquals(expression.Keys, newKeys) || !object.ReferenceEquals(expression.Aggregates, newAggs)) { RowType groupOutput = TypeHelpers.GetEdmType <RowType>(TypeHelpers.GetEdmType <CollectionType>(expression.ResultType).TypeUsage); var boundKeys = groupOutput.Properties.Take(newKeys.Count).Select(p => p.Name).Zip(newKeys).ToList(); var boundAggs = groupOutput.Properties.Skip(newKeys.Count).Select(p => p.Name).Zip(newAggs).ToList(); result = CqtBuilder.GroupBy(newInput, boundKeys, boundAggs); } NotifyIfChanged(expression, result); return(result); }
public override DbExpression Visit(DbConstantExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); // Note that it is only safe to call DbConstantExpression.GetValue because the call to // DbExpressionBuilder.Constant must clone immutable values (byte[]). return(VisitTerminal(expression, newType => CqtBuilder.Constant(newType, expression.GetValue()))); }
public override DbExpression Visit(DbPropertyExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; DbExpression newInstance = this.VisitExpression(expression.Instance); if (!object.ReferenceEquals(expression.Instance, newInstance)) { result = CqtBuilder.Property(newInstance, expression.Property.Name); } NotifyIfChanged(expression, result); return(result); }
public override DbExpression Visit(DbScanExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; EntitySetBase newSet = this.VisitEntitySet(expression.Target); if (!object.ReferenceEquals(expression.Target, newSet)) { result = CqtBuilder.Scan(newSet); } NotifyIfChanged(expression, result); return(result); }
public override DbExpression Visit(DbCrossJoinExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; IList <DbExpressionBinding> newInputs = this.VisitExpressionBindingList(expression.Inputs); if (!object.ReferenceEquals(expression.Inputs, newInputs)) { result = CqtBuilder.CrossJoin(newInputs); } NotifyIfChanged(expression, result); return(result); }
protected virtual DbExpressionBinding VisitExpressionBinding(DbExpressionBinding binding) { DbExpressionBinding result = binding; if (binding != null) { DbExpression newInput = this.VisitExpression(binding.Expression); if (!object.ReferenceEquals(binding.Expression, newInput)) { result = CqtBuilder.BindAs(newInput, binding.VariableName); this.RebindVariable(binding.Variable, result.Variable); } } return(result); }
public override DbExpression Visit(DbLambdaExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; IList <DbExpression> newArguments = this.VisitExpressionList(expression.Arguments); DbLambda newLambda = this.VisitLambda(expression.Lambda); if (!object.ReferenceEquals(expression.Arguments, newArguments) || !object.ReferenceEquals(expression.Lambda, newLambda)) { result = CqtBuilder.Invoke(newLambda, newArguments); } NotifyIfChanged(expression, result); return(result); }
protected virtual DbGroupAggregate VisitGroupAggregate(DbGroupAggregate aggregate) { DbGroupAggregate result = aggregate; if (aggregate != null) { IList <DbExpression> newArguments = this.VisitExpressionList(aggregate.Arguments); Debug.Assert(newArguments.Count == 1, "Group aggregate had more than one argument?"); if (!object.ReferenceEquals(aggregate.Arguments, newArguments)) { result = CqtBuilder.GroupAggregate(newArguments[0]); } } return(result); }
public override DbExpression Visit(DbFunctionExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; IList <DbExpression> newArguments = this.VisitExpressionList(expression.Arguments); EdmFunction newFunction = this.VisitFunction(expression.Function); if (!object.ReferenceEquals(expression.Arguments, newArguments) || !object.ReferenceEquals(expression.Function, newFunction)) { result = CqtBuilder.Invoke(newFunction, newArguments); } NotifyIfChanged(expression, result); return(result); }
public override DbExpression Visit(DbIsNullExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); return(VisitUnary(expression, exp => { if (TypeSemantics.IsRowType(exp.ResultType)) { // return CqtBuilder.CreateIsNullExpressionAllowingRowTypeArgument(exp); } else { return CqtBuilder.IsNull(exp); } } )); }
public override DbExpression Visit(DbLimitExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; DbExpression newArgument = this.VisitExpression(expression.Argument); DbExpression newLimit = this.VisitExpression(expression.Limit); if (!object.ReferenceEquals(expression.Argument, newArgument) || !object.ReferenceEquals(expression.Limit, newLimit)) { Debug.Assert(!expression.WithTies, "Limit.WithTies == true?"); result = CqtBuilder.Limit(newArgument, newLimit); } NotifyIfChanged(expression, result); return(result); }
public override DbExpression Visit(DbProjectExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; DbExpressionBinding input = this.VisitExpressionBindingEnterScope(expression.Input); DbExpression projection = this.VisitExpression(expression.Projection); this.ExitScope(); if (!object.ReferenceEquals(expression.Input, input) || !object.ReferenceEquals(expression.Projection, projection)) { result = CqtBuilder.Project(input, projection); } NotifyIfChanged(expression, result); return(result); }
private DbRelatedEntityRef VisitRelatedEntityRef(DbRelatedEntityRef entityRef) { RelationshipEndMember newSource; RelationshipEndMember newTarget; VisitRelationshipEnds(entityRef.SourceEnd, entityRef.TargetEnd, out newSource, out newTarget); DbExpression newTargetRef = this.VisitExpression(entityRef.TargetEntityReference); if (!object.ReferenceEquals(entityRef.SourceEnd, newSource) || !object.ReferenceEquals(entityRef.TargetEnd, newTarget) || !object.ReferenceEquals(entityRef.TargetEntityReference, newTargetRef)) { return(CqtBuilder.CreateRelatedEntityRef(newSource, newTarget, newTargetRef)); } else { return(entityRef); } }
public override DbExpression Visit(DbLikeExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; DbExpression newArgument = this.VisitExpression(expression.Argument); DbExpression newPattern = this.VisitExpression(expression.Pattern); DbExpression newEscape = this.VisitExpression(expression.Escape); if (!object.ReferenceEquals(expression.Argument, newArgument) || !object.ReferenceEquals(expression.Pattern, newPattern) || !object.ReferenceEquals(expression.Escape, newEscape)) { result = CqtBuilder.Like(newArgument, newPattern, newEscape); } NotifyIfChanged(expression, result); return(result); }
public override DbExpression Visit(DbSortExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; DbExpressionBinding newInput = this.VisitExpressionBindingEnterScope(expression.Input); IList <DbSortClause> newSortOrder = this.VisitSortOrder(expression.SortOrder); this.ExitScope(); if (!object.ReferenceEquals(expression.Input, newInput) || !object.ReferenceEquals(expression.SortOrder, newSortOrder)) { result = CqtBuilder.Sort(newInput, newSortOrder); } NotifyIfChanged(expression, result); return(result); }
public override DbExpression Visit(DbCaseExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; IList <DbExpression> newWhens = this.VisitExpressionList(expression.When); IList <DbExpression> newThens = this.VisitExpressionList(expression.Then); DbExpression newElse = this.VisitExpression(expression.Else); if (!object.ReferenceEquals(expression.When, newWhens) || !object.ReferenceEquals(expression.Then, newThens) || !object.ReferenceEquals(expression.Else, newElse)) { result = CqtBuilder.Case(newWhens, newThens, newElse); } NotifyIfChanged(expression, result); return(result); }
public override DbExpression Visit(DbArithmeticExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; IList <DbExpression> newArguments = this.VisitExpressionList(expression.Arguments); if (!object.ReferenceEquals(expression.Arguments, newArguments)) { switch (expression.ExpressionKind) { case DbExpressionKind.Divide: result = CqtBuilder.Divide(newArguments[0], newArguments[1]); break; case DbExpressionKind.Minus: result = CqtBuilder.Minus(newArguments[0], newArguments[1]); break; case DbExpressionKind.Modulo: result = CqtBuilder.Modulo(newArguments[0], newArguments[1]); break; case DbExpressionKind.Multiply: result = CqtBuilder.Multiply(newArguments[0], newArguments[1]); break; case DbExpressionKind.Plus: result = CqtBuilder.Plus(newArguments[0], newArguments[1]); break; case DbExpressionKind.UnaryMinus: result = CqtBuilder.UnaryMinus(newArguments[0]); break; default: throw EntityUtil.NotSupported(); } } NotifyIfChanged(expression, result); return(result); }
protected virtual DbSortClause VisitSortClause(DbSortClause clause) { DbSortClause result = clause; if (clause != null) { DbExpression newExpression = this.VisitExpression(clause.Expression); if (!object.ReferenceEquals(clause.Expression, newExpression)) { if (!string.IsNullOrEmpty(clause.Collation)) { result = (clause.Ascending ? CqtBuilder.ToSortClause(newExpression, clause.Collation) : CqtBuilder.ToSortClauseDescending(newExpression, clause.Collation)); } else { result = (clause.Ascending ? CqtBuilder.ToSortClause(newExpression) : CqtBuilder.ToSortClauseDescending(newExpression)); } } } return(result); }
public override DbExpression Visit(DbRelationshipNavigationExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; RelationshipEndMember newFrom; RelationshipEndMember newTo; VisitRelationshipEnds(expression.NavigateFrom, expression.NavigateTo, out newFrom, out newTo); DbExpression newNavSource = this.VisitExpression(expression.NavigationSource); if (!object.ReferenceEquals(expression.NavigateFrom, newFrom) || !object.ReferenceEquals(expression.NavigateTo, newTo) || !object.ReferenceEquals(expression.NavigationSource, newNavSource)) { result = CqtBuilder.Navigate(newNavSource, newFrom, newTo); } NotifyIfChanged(expression, result); return(result); }
public override DbExpression Visit(DbRefExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); DbExpression result = expression; EntityType targetType = (EntityType)TypeHelpers.GetEdmType <RefType>(expression.ResultType).ElementType; DbExpression newArgument = this.VisitExpression(expression.Argument); EntityType newType = (EntityType)this.VisitType(targetType); EntitySet newSet = (EntitySet)this.VisitEntitySet(expression.EntitySet); if (!object.ReferenceEquals(expression.Argument, newArgument) || !object.ReferenceEquals(targetType, newType) || !object.ReferenceEquals(expression.EntitySet, newSet)) { result = CqtBuilder.RefFromKey(newSet, newArgument, newType); } NotifyIfChanged(expression, result); return(result); }
public override DbExpression Visit(DbParameterReferenceExpression expression) { EntityUtil.CheckArgumentNull(expression, "expression"); return(VisitTerminal(expression, newType => CqtBuilder.Parameter(newType, expression.ParameterName))); }