/// <summary> /// Performs projection for a single row. Evaluates each projection argument against the specified /// row, returning a result with the specified type. /// </summary> /// <param name="node">Projection expression.</param> /// <param name="row">Row to project.</param> /// <param name="resultType">Type of the projected row.</param> /// <returns>Projected row.</returns> private PropagatorResult Project(DbProjectExpression node, PropagatorResult row, TypeUsage resultType) { EntityUtil.CheckArgumentNull(node, "node"); Debug.Assert(null != node.Projection, "CQT validates DbProjectExpression.Projection property"); DbNewInstanceExpression projection = node.Projection as DbNewInstanceExpression; if (null == projection) { throw EntityUtil.NotSupported(System.Data.Entity.Strings.Update_UnsupportedProjection(node.Projection.ExpressionKind)); } // Initialize empty structure containing space for every element of the projection. PropagatorResult[] projectedValues = new PropagatorResult[projection.Arguments.Count]; // Extract value from the input row for every projection argument requested. for (int ordinal = 0; ordinal < projectedValues.Length; ordinal++) { projectedValues[ordinal] = Evaluator.Evaluate(projection.Arguments[ordinal], row, this); } // Return a new row containing projected values. PropagatorResult projectedRow = PropagatorResult.CreateStructuralValue(projectedValues, (StructuralType)resultType.EdmType, false); return(projectedRow); }
public override void Visit(DbProjectExpression e) { Begin(e); Dump(e.Input, "Input"); Dump(e.Projection, "Projection"); End(e); }
private RowType GetRowTypeFromCommandTree(DbCommandTree tree) { DbQueryCommandTree commandTree = tree as DbQueryCommandTree; if (commandTree == null) { return(null); } DbProjectExpression projectExpression = commandTree.Query as DbProjectExpression; // Try filter then if (projectExpression == null) { DbFilterExpression filterExpression = commandTree.Query as DbFilterExpression; if (filterExpression != null && filterExpression.Input != null) { projectExpression = filterExpression.Input.Expression as DbProjectExpression; } } if (projectExpression != null) { var newExpression = projectExpression.Projection; if (newExpression != null) { return(newExpression.ResultType.EdmType as RowType); } } return(null); }
public override bool Visit(DbProjectExpression expression) { bool flag1 = VisitExpressionBinding(expression.Input); bool flag2 = VisitExpression(expression.Projection); return(flag1 || flag2); }
internal ProjectSkipLifter(DbProjectExpression project, DbSkipExpression skip, AliasGenerator aliasGenerator) : base(project, aliasGenerator) { _project = project; _skip = skip; _source = _skip.Input.Expression; }
/// <summary> /// Walks the structure /// </summary> /// <param name="expression">The DbProjectExpression that is being visited.</param> /// <returns></returns> public override bool Visit(DbProjectExpression expression) { bool inputNeedsRewrite = VisitExpressionBinding(expression.Input); bool projectionNeedsRewrite = VisitExpression(expression.Projection); return(inputNeedsRewrite || projectionNeedsRewrite); }
// <summary> // Propagate projection. // Propagation rule (P = projection node, S = projection input, D(x) = deleted rows in x, // I(x) = inserted rows in x) // P = Proj_f S // D(P) = Proj_f D(S) // I(P) = Proj_f I(S) // </summary> // <param name="node"> Projection expression node. </param> // <returns> Result of propagating changes to the projection expression node. </returns> public override ChangeNode Visit(DbProjectExpression node) { Check.NotNull(node, "node"); // Initialize an empty change node result for the projection node. var result = BuildChangeNode(node); // Retrieve result of propagating changes to the input of the projection. var input = Visit(node.Input.Expression); // Implement propagation rule for insert I(P) = Proj_f I(S) foreach (var row in input.Inserted) { result.Inserted.Add(Project(node, row, result.ElementType)); } // Implement propagation rule for delete D(P) = Proj_f D(S) foreach (var row in input.Deleted) { result.Deleted.Add(Project(node, row, result.ElementType)); } // Generate a placeholder for the projection node by projecting values in the // placeholder for the input node. result.Placeholder = Project(node, input.Placeholder, result.ElementType); return(result); }
internal ProjectSortLifter(DbProjectExpression project, DbSortExpression sort, AliasGenerator aliasGenerator) : base(project, aliasGenerator) { _project = project; _sort = sort; _source = sort.Input.Expression; }
// <summary> // Performs projection for a single row. Evaluates each projection argument against the specified // row, returning a result with the specified type. // </summary> // <param name="node"> Projection expression. </param> // <param name="row"> Row to project. </param> // <param name="resultType"> Type of the projected row. </param> // <returns> Projected row. </returns> private static PropagatorResult Project(DbProjectExpression node, PropagatorResult row, TypeUsage resultType) { DebugCheck.NotNull(node); DebugCheck.NotNull(node.Projection); var projection = node.Projection as DbNewInstanceExpression; if (null == projection) { throw new NotSupportedException(Strings.Update_UnsupportedProjection(node.Projection.ExpressionKind)); } // Initialize empty structure containing space for every element of the projection. var projectedValues = new PropagatorResult[projection.Arguments.Count]; // Extract value from the input row for every projection argument requested. for (var ordinal = 0; ordinal < projectedValues.Length; ordinal++) { projectedValues[ordinal] = Evaluator.Evaluate(projection.Arguments[ordinal], row); } // Return a new row containing projected values. var projectedRow = PropagatorResult.CreateStructuralValue(projectedValues, (StructuralType)resultType.EdmType, false); return(projectedRow); }
public override void Visit(DbProjectExpression expression) { EntityUtils.CheckArgumentNull <DbProjectExpression>(expression, nameof(expression)); this.VisitExpressionBindingPre(expression.Input); this.VisitExpression(expression.Projection); this.VisitExpressionBindingPost(expression.Input); }
public override DbExpression Visit(DbProjectExpression expression) { // Only allowed cases: // SELECT Deref(x) FROM <expression> AS x // SELECT x FROM <expression> as x DbExpression testExpr = expression.Projection; if (DbExpressionKind.Deref == testExpr.ExpressionKind) { testExpr = ((DbDerefExpression)testExpr).Argument; } if (DbExpressionKind.VariableReference == testExpr.ExpressionKind) { DbVariableReferenceExpression varRef = (DbVariableReferenceExpression)testExpr; if (varRef.VariableName.Equals(expression.Input.VariableName, StringComparison.Ordinal)) { DbExpression found = Find(expression.Input.Expression); if (!object.ReferenceEquals(found, expression.Input.Expression)) { return(found.BindAs(expression.Input.VariableName).Project(expression.Projection)); } } } return(expression); }
internal ProjectLimitSortLifter( DbProjectExpression project, DbLimitExpression limit, DbSortExpression sort, AliasGenerator aliasGenerator) : base(project, aliasGenerator) { _project = project; _limit = limit; _sort = sort; }
public override DbExpression Translate(ExpressionParser parser, MethodCallExpression callExpression) { DbProjectExpression input = parser.Parse(callExpression.Arguments[0]) as DbProjectExpression; LambdaExpression lambda = parser.GetLambdaExpression(callExpression.Arguments[1]); DbExpression body = parser.ParseLambda(input.Input, lambda); return(new DbWhereExpression(input.Input, body, input.ResultType)); }
public override void Visit(DbProjectExpression e) { Check.NotNull <DbProjectExpression>(e, nameof(e)); this.Begin((DbExpression)e); this.Dump(e.Input, "Input"); this.Dump(e.Projection, "Projection"); this.End((DbExpression)e); }
public override DbExpressionEntitySetInfo Visit(DbProjectExpression expression) { this.VisitExpressionBindingEnterScope(expression.Input); DbExpressionEntitySetInfo setInfo = VisitExpression(expression.Projection); this.VisitExpressionBindingExitScope(); return(setInfo); }
public override void Visit(DbProjectExpression expression) { Write(expression); _depth++; Write("Input", expression.Input); Write("Projection", expression.Projection); _depth--; }
public override LegacyCommandTrees.DbExpression Visit(DbProjectExpression expression) { Debug.Assert(expression != null, "expression != null"); return(expression.Input.Expression.Accept(this) .BindAs(expression.Input.VariableName) .Project(expression.Projection.Accept(this))); }
public override TreeNode Visit(DbProjectExpression e) { TreeNode retInfo = NodeFromExpression(e); retInfo.Children.Add(this.VisitBinding("Input", e.Input)); retInfo.Children.Add(this.Visit("Projection", e.Projection)); return(retInfo); }
internal override DbExpression Project(DbProjectExpression project) { // source.Sort(o).Limit(k).Project(p).Project(p2) -> source.Sort(o).Limit(k).Project(e => p2(p(e))) return(ComposeProject( DbExpressionBuilder.Limit(_sort, _limit.Limit), _project, project)); }
public override void Visit(DbProjectExpression e) { VisitExprKind(e.ExpressionKind); _key.Append('('); VisitBinding(e.Input); _key.Append('('); e.Projection.Accept(this); _key.Append("))"); }
/// <summary> /// Walks the structure /// </summary> /// <param name="expression"> The DbProjectExpression that is being visited. </param> /// <returns> </returns> public override bool Visit(DbProjectExpression expression) { Check.NotNull(expression, "expression"); var inputNeedsRewrite = VisitExpressionBinding(expression.Input); var projectionNeedsRewrite = VisitExpression(expression.Projection); return(inputNeedsRewrite || projectionNeedsRewrite); }
internal override DbExpression Project(DbProjectExpression project) { // source.Skip(k, o).Limit(k2).Project(p).Project(p2) -> // source.Skip(k, o).Limit(k2).Project(e => p2(p(e))) return(ComposeProject( _skip.Limit(_limit.Limit), _project, project)); }
/// <summary> /// Visitor pattern method for <see cref="DbProjectExpression" />. /// </summary> /// <param name="expression"> The DbProjectExpression that is being visited. </param> /// <exception cref="ArgumentNullException"> /// <paramref name="expression" /> /// is null /// </exception> public override void Visit(DbProjectExpression expression) { // #433613: PreSharp warning 56506: Parameter 'expression' to this public method must be validated: A null-dereference can occur here. Check.NotNull(expression, "expression"); VisitExpressionBindingPre(expression.Input); VisitExpression(expression.Projection); VisitExpressionBindingPost(expression.Input); }
public override TreeNode Visit(DbProjectExpression e) { Check.NotNull <DbProjectExpression>(e, nameof(e)); TreeNode treeNode = ExpressionPrinter.PrinterVisitor.NodeFromExpression((DbExpression)e); treeNode.Children.Add(this.VisitBinding("Input", e.Input)); treeNode.Children.Add(this.Visit("Projection", e.Projection)); return(treeNode); }
public override ViewValidator.DbExpressionEntitySetInfo Visit( DbProjectExpression expression) { Check.NotNull <DbProjectExpression>(expression, nameof(expression)); this.VisitExpressionBindingEnterScope(expression.Input); ViewValidator.DbExpressionEntitySetInfo expressionEntitySetInfo = this.VisitExpression(expression.Projection); this.VisitExpressionBindingExitScope(); return(expressionEntitySetInfo); }
public override void Visit(DbProjectExpression e) { Check.NotNull(e, "e"); Begin(e); Dump(e.Input, "Input"); Dump(e.Projection, "Projection"); End(e); }
private DbExpression RewriteCollection(DbExpression expression) { DbExpression dbExpression = expression; DbProjectExpression projectExpression = (DbProjectExpression)null; if (DbExpressionKind.Project == expression.ExpressionKind) { projectExpression = (DbProjectExpression)expression; dbExpression = projectExpression.Input.Expression; } ObjectSpanRewriter.NavigationInfo navInfo = (ObjectSpanRewriter.NavigationInfo)null; if (this.RelationshipSpan) { dbExpression = ObjectSpanRewriter.RelationshipNavigationVisitor.FindNavigationExpression(dbExpression, this._aliasGenerator, out navInfo); } if (navInfo != null) { this.EnterNavigationCollection(navInfo); } else { this.EnterCollection(); } DbExpression body = expression; if (projectExpression != null) { DbExpression projection = this.Rewrite(projectExpression.Projection); if (!object.ReferenceEquals((object)projectExpression.Projection, (object)projection)) { body = (DbExpression)dbExpression.BindAs(projectExpression.Input.VariableName).Project(projection); } } else { DbExpressionBinding input = dbExpression.BindAs(this._aliasGenerator.Next()); DbExpression variable = (DbExpression)input.Variable; DbExpression projection = this.Rewrite(variable); if (!object.ReferenceEquals((object)variable, (object)projection)) { body = (DbExpression)input.Project(projection); } } this.ExitCollection(); if (navInfo != null && navInfo.InUse) { body = (DbExpression)DbExpressionBuilder.Lambda(body, (IEnumerable <DbVariableReferenceExpression>) new List <DbVariableReferenceExpression>(1) { navInfo.SourceVariable }).Invoke((IEnumerable <DbExpression>) new List <DbExpression>(1) { navInfo.Source }); } return(body); }
public override TreeNode Visit(DbProjectExpression e) { Check.NotNull(e, "e"); var retInfo = NodeFromExpression(e); retInfo.Children.Add(VisitBinding("Input", e.Input)); retInfo.Children.Add(Visit("Projection", e.Projection)); return(retInfo); }
public override void Visit(DbProjectExpression expression) { if (expression == null) { throw new ArgumentException("expression"); } VisitExpressionBindingPre(expression.Input); VisitExpression(expression.Projection); VisitExpressionBindingPost(expression.Input); }
public override DbExpressionEntitySetInfo Visit(DbProjectExpression expression) { Check.NotNull(expression, "expression"); VisitExpressionBindingEnterScope(expression.Input); var setInfo = VisitExpression(expression.Projection); VisitExpressionBindingExitScope(); return(setInfo); }
public override Expression Visit(DbProjectExpression expression) { Expression source = this.Visit(expression.Input.Expression); Type elementType = TypeHelper.GetElementType(source.Type); ParameterExpression param = Expression.Parameter(elementType, expression.Input.VariableName); using (this.CreateVariable(param, expression.Input.VariableName)) { Expression projection = this.Visit(expression.Projection); LambdaExpression projectionLambda = Expression.Lambda(projection, param); return queryMethodExpressionBuilder.Select(source, projectionLambda); } }
public override DbExpression Visit(DbProjectExpression expression) { System.Diagnostics.Debug.Print("Visit(DbProjectExpression): {0}", expression); return base.Visit(expression); }
public override void Visit(DbProjectExpression expression) { throw new NotSupportedException("Visit(\"ProjectExpression\") is not supported."); }
/// <summary> /// Visitor pattern method for DbProjectExpression. /// </summary> /// <param name="expression"> The DbProjectExpression that is being visited. </param> public abstract void Visit(DbProjectExpression expression);
protected DbProjectExpression RebindProject(DbExpression input, DbProjectExpression project) { DbExpressionBinding inputBinding = input.BindAs(project.Input.VariableName); return inputBinding.Project(project.Projection); }
protected static DbProjectExpression ComposeProject( DbExpression input, DbProjectExpression first, DbProjectExpression second) { // source.Project(first).Project(second) -> source.Project(e => second(first(e))) // create lambda expression representing the second projection (e => second(e)) var secondLambda = DbExpressionBuilder.Lambda(second.Projection, second.Input.Variable); // invoke lambda with variable from the first projection var composed = first.Input.Project(secondLambda.Invoke(first.Projection)); return RebindProject(input, composed); }
public override void Visit(DbProjectExpression expression) { Contract.Requires(expression != null); }
internal override DbExpression Project(DbProjectExpression project) { // the result is already ordered (no compensation is required) return project; }
internal override DbExpression Project(DbProjectExpression project) { return project; }
public override void Visit(DbProjectExpression expression) { if (expression == null) throw new ArgumentException("expression"); VisitExpressionBindingPre(expression.Input); VisitExpression(expression.Projection); VisitExpressionBindingPost(expression.Input); }
public override void Visit(DbProjectExpression expression) { }
public override DbExpression Visit(DbProjectExpression expression) { // Only allowed cases: // SELECT Deref(x) FROM <expression> AS x // SELECT x FROM <expression> as x DbExpression testExpr = expression.Projection; if (DbExpressionKind.Deref == testExpr.ExpressionKind) { testExpr = ((DbDerefExpression)testExpr).Argument; } if (DbExpressionKind.VariableReference == testExpr.ExpressionKind) { DbVariableReferenceExpression varRef = (DbVariableReferenceExpression)testExpr; if (varRef.VariableName.Equals(expression.Input.VariableName, StringComparison.Ordinal)) { DbExpression found = Find(expression.Input.Expression); if (!object.ReferenceEquals(found, expression.Input.Expression)) { return found.BindAs(expression.Input.VariableName).Project(expression.Projection); } } } return expression; }
/// <summary> /// Visitor pattern method for <see cref="DbProjectExpression" />. /// </summary> /// <param name="expression"> The DbProjectExpression that is being visited. </param> /// <exception cref="ArgumentNullException"> /// <paramref name="expression" /> /// is null /// </exception> public override void Visit(DbProjectExpression expression) { Check.NotNull(expression, "expression"); VisitExpressionBindingPre(expression.Input); VisitExpression(expression.Projection); VisitExpressionBindingPost(expression.Input); }
internal override DbExpression Project(DbProjectExpression project) { // source.Sort(o).Limit(k).Project(p).Project(p2) -> source.Sort(o).Limit(k).Project(e => p2(p(e))) return ComposeProject( DbExpressionBuilder.Limit(_sort, _limit.Limit), _project, project); }
public override SqlFragment Visit(DbProjectExpression expression) { SelectStatement select = VisitInputExpressionEnsureSelect(expression.Input.Expression, expression.Input.VariableName, expression.Input.VariableType); // see if we need to wrap this select inside a new select select = WrapIfNotCompatible(select, expression.ExpressionKind); Debug.Assert(expression.Projection is DbNewInstanceExpression); VisitNewInstanceExpression(select, expression.Projection as DbNewInstanceExpression); return select; }
internal override DbExpression Project(DbProjectExpression project) { // source.Skip(k, o).Project(p).Project(p2) -> source.Skip(k, o).Project(e => p2(p(e))) return ComposeProject(_skip, _project, project); }
/// <summary> /// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbProjectExpression"/>. /// </summary> /// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbProjectExpression"/> that is visited.</param> public override void Visit(DbProjectExpression expression) { if (expression == null) { throw new ArgumentNullException("expression"); } expression.Projection.Accept(this); expression.Input.Expression.Accept(this); }
internal abstract DbExpression Project(DbProjectExpression project);
internal override DbExpression Project(DbProjectExpression project) { // source.Sort(o).Project(p).Project(p2) -> source.Sort(o).Project(e => p2(p(2))) return ComposeProject(_sort, _project, project); }
protected DbFilterExpression ComposeFilter(DbExpression input, DbProjectExpression first, DbFilterExpression second) { // source.Project(first).Filter(second) -> source.Filter(e => second(first(e))) // create lambda expression representing the filter (e => second(e)) DbLambda secondLambda = DbExpressionBuilder.Lambda(second.Predicate, second.Input.Variable); // invoke lambda with variable from the project DbFilterExpression composed = first.Input.Filter(secondLambda.Invoke(first.Projection)); return RebindFilter(input, composed); }
/// <summary> /// Visitor pattern method for <see cref="DbProjectExpression"/>. /// </summary> /// <param name="expression">The DbProjectExpression that is being visited.</param> /// <exception cref="ArgumentNullException"><paramref name="expression"/> is null</exception> public override void Visit(DbProjectExpression expression) { VisitExpressionBindingPre(expression.Input); VisitExpression(expression.Projection); VisitExpressionBindingPost(expression.Input); }