// <summary> // <see // cref="TransformIntersectOrExcept(DbExpression, DbExpression, DbExpressionKind, System.Collections.Generic.IList{System.Data.Entity.Core.Common.CommandTrees.DbPropertyExpression}, string)" /> // Logicaly, <see cref="DbSkipExpression" /> translates to: // SELECT Y.x1, Y.x2, ..., Y.xn // FROM ( // SELECT X.x1, X.x2, ..., X.xn, // FROM input AS X // EXCEPT // SELECT TOP(count) Z.x1, Z.x2, ..., Z.xn // FROM input AS Z // ORDER BY sk1, sk2, ... // ) AS Y // ORDER BY sk1, sk2, ... // Here, input refers to the input of the <see cref="DbSkipExpression" />, and count to the count property of the // <see // cref="DbSkipExpression" /> // . // The implementation of EXCEPT is non-duplicate eliminating, and does equality comparison only over the // equality comparable columns of the input. // This corresponds to the following expression tree: // SORT // | // NON-DISTINCT EXCEPT (specially translated, // | // | - Left: clone of input // | - Right: // | // Limit // | // | - Limit: Count // | - Input // | // Sort // | // input // </summary> public override DbExpression Visit(DbSkipExpression e) { Check.NotNull(e, "e"); //Build the right input of the except DbExpression rightInput = VisitExpressionBinding(e.Input).Sort(VisitSortOrder(e.SortOrder)).Limit(VisitExpression(e.Count)); //Build the left input for the except var leftInput = VisitExpression(e.Input.Expression); //Another copy of the input var sortOrder = VisitSortOrder(e.SortOrder); //Another copy of the sort order // Create a list of the sort expressions to be used for translating except IList <DbPropertyExpression> sortExpressions = new List <DbPropertyExpression>(e.SortOrder.Count); foreach (var sortClause in sortOrder) { //We only care about property expressions, not about constants if (sortClause.Expression.ExpressionKind == DbExpressionKind.Property) { sortExpressions.Add((DbPropertyExpression)sortClause.Expression); } } var exceptExpression = TransformIntersectOrExcept( leftInput, rightInput, DbExpressionKind.Skip, sortExpressions, e.Input.VariableName); DbExpression result = exceptExpression.BindAs(e.Input.VariableName).Sort(sortOrder); return(result); }
public override bool Visit(DbSkipExpression expression) { VisitExpressionBinding(expression.Input); VisitSortClauseList(expression.SortOrder); VisitExpression(expression.Count); return(true); }
internal LimitSkipLifter(DbLimitExpression limit, DbSkipExpression skip, AliasGenerator aliasGenerator) : base(limit, aliasGenerator) { _limit = limit; _skip = skip; _source = skip.Input.Expression; }
internal ProjectSkipLifter(DbProjectExpression project, DbSkipExpression skip, AliasGenerator aliasGenerator) : base(project, aliasGenerator) { _project = project; _skip = skip; _source = _skip.Input.Expression; }
public override VfpExpression Visit(DbSkipExpression expression) { return(new VfpSkipExpression(expression.ResultType, CreateDbExpressionBinding(expression.Input), CreateDbSortClauses(expression.SortOrder), expression.Count.Accept(this))); }
/// <summary> /// For Sql9 it translates to: /// SELECT Y.x1, Y.x2, ..., Y.xn /// FROM ( /// SELECT X.x1, X.x2, ..., X.xn, row_number() OVER (ORDER BY sk1, sk2, ...) AS [row_number] /// FROM input as X /// ) as Y /// WHERE Y.[row_number] > count /// ORDER BY sk1, sk2, ... /// </summary> /// <param name="e"></param> /// <returns>A <see cref="SqlBuilder"/></returns> public override ISqlFragment Visit(DbSkipExpression e) { Debug.Assert(e.Count is DbConstantExpression || e.Count is DbParameterReferenceExpression, "DbSkipExpression.Count is of invalid expression type"); Symbol fromSymbol; var result = VisitInputExpression(e.Input.Expression, e.Input.VariableName, e.Input.VariableType, out fromSymbol); // Skip should be compatible with anything if (!IsCompatible(result, e.ExpressionKind)) { result = CreateNewSelectStatement(result, e.Input.VariableName, e.Input.VariableType, out fromSymbol); } selectStatementStack.Push(result); symbolTable.EnterScope(); AddFromSymbol(result, e.Input.VariableName, fromSymbol); AddSortKeys(result.OrderBy, e.SortOrder); result.Top.SkipCount = HandleCountExpression(e.Count); symbolTable.ExitScope(); selectStatementStack.Pop(); return(result); }
public override void Visit(DbSkipExpression e) { Begin(e); Dump(e.Input, "Input"); Dump(e.SortOrder); Dump(e.Count, "Count"); End(e); }
protected DbSkipExpression AddToSkip(DbExpression input, DbSkipExpression skip, DbExpression plusK) { // source.Skip(k, o).Skip(k2) -> source.Skip(k + k2, o) DbExpression newCount = CombineIntegers(skip.Count, plusK, (l, r) => l + r); return(RebindSkip(input, skip, newCount)); }
public override void Visit(DbSkipExpression e) { Check.NotNull <DbSkipExpression>(e, nameof(e)); this.Begin((DbExpression)e); this.Dump(e.Input, "Input"); this.Dump(e.SortOrder); this.Dump(e.Count, "Count"); this.End((DbExpression)e); }
/// <summary> /// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbSkipExpression"/>. /// </summary> /// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbSkipExpression"/> that is visited.</param> public override void Visit(DbSkipExpression expression) { expression.Count.Accept(this); expression.Input.Expression.Accept(this); foreach (var sortClause in expression.SortOrder) { sortClause.Expression.Accept(this); } }
public override void Visit(DbSkipExpression expression) { Write(expression); _depth++; Write("Input", expression.Input); Write("Count", expression.Count); Write("SortOrder", expression.SortOrder); _depth--; }
public override TreeNode Visit(DbSkipExpression e) { TreeNode retInfo = NodeFromExpression(e); retInfo.Children.Add(this.VisitBinding("Input", e.Input)); retInfo.Children.Add(this.VisitSortOrder(e.SortOrder)); retInfo.Children.Add(this.Visit("Count", e.Count)); return(retInfo); }
public override void Visit(DbSkipExpression e) { VisitExprKind(e.ExpressionKind); _key.Append('('); VisitBinding(e.Input); VisitSortOrder(e.SortOrder); _key.Append('('); e.Count.Accept(this); _key.Append("))"); }
public override Expression Visit(DbSkipExpression expression) { Expression source = this.Visit(expression.Input.Expression); Type sourceType = TypeHelper.GetElementType(source.Type); // Skip cannot be used without sorting Expression result = this.CreateOrderByExpression(expression.SortOrder, expression.Input.VariableName, source); return queryMethodExpressionBuilder.Skip(result, this.Visit(expression.Count, typeof(int))); }
public override void Visit(DbSkipExpression e) { Check.NotNull(e, "e"); Begin(e); Dump(e.Input, "Input"); Dump(e.SortOrder); Dump(e.Count, "Count"); End(e); }
public override TreeNode Visit(DbSkipExpression e) { Check.NotNull <DbSkipExpression>(e, nameof(e)); TreeNode treeNode = ExpressionPrinter.PrinterVisitor.NodeFromExpression((DbExpression)e); treeNode.Children.Add(this.VisitBinding("Input", e.Input)); treeNode.Children.Add(this.VisitSortOrder(e.SortOrder)); treeNode.Children.Add(this.Visit("Count", e.Count)); return(treeNode); }
public override Expression Visit(DbSkipExpression expression) { Expression source = this.Visit(expression.Input.Expression); Type sourceType = TypeHelper.GetElementType(source.Type); // Skip cannot be used without sorting Expression result = this.CreateOrderByExpression(expression.SortOrder, expression.Input.VariableName, source); return(queryMethodExpressionBuilder.Skip(result, this.Visit(expression.Count, typeof(int)))); }
public override DbExpression Visit(DbSkipExpression expression) { Check.NotNull <DbSkipExpression>(expression, nameof(expression)); DbExpression input = this.Find(expression.Input.Expression); if (!object.ReferenceEquals((object)input, (object)expression.Input.Expression)) { return((DbExpression)input.BindAs(expression.Input.VariableName).Skip((IEnumerable <DbSortClause>)expression.SortOrder, expression.Count)); } return((DbExpression)expression); }
public override void Visit(DbSkipExpression e) { Check.NotNull <DbSkipExpression>(e, nameof(e)); this.VisitExprKind(e.ExpressionKind); this._key.Append('('); this.VisitBinding(e.Input); this.VisitSortOrder(e.SortOrder); this._key.Append('('); e.Count.Accept((DbExpressionVisitor)this); this._key.Append("))"); }
public override void Visit(DbSkipExpression expression) { EntityUtils.CheckArgumentNull <DbSkipExpression>(expression, nameof(expression)); this.VisitExpressionBindingPre(expression.Input); foreach (DbSortClause dbSortClause in (IEnumerable <DbSortClause>)expression.SortOrder) { this.VisitExpression(dbSortClause.Expression); } this.VisitExpressionBindingPost(expression.Input); this.VisitExpression(expression.Count); }
public override TreeNode Visit(DbSkipExpression e) { Check.NotNull(e, "e"); var retInfo = NodeFromExpression(e); retInfo.Children.Add(VisitBinding("Input", e.Input)); retInfo.Children.Add(VisitSortOrder(e.SortOrder)); retInfo.Children.Add(Visit("Count", e.Count)); return(retInfo); }
public override LegacyCommandTrees.DbExpression Visit(DbSkipExpression expression) { Debug.Assert(expression != null, "expression != null"); return (expression.Input.Expression.Accept(this) .BindAs(expression.Input.VariableName) .Skip( expression.SortOrder.Select(ConvertToLegacySortClause), expression.Count.Accept(this))); }
public override bool Visit(DbSkipExpression expression) { Check.NotNull <DbSkipExpression>(expression, nameof(expression)); if (expression.Count is DbParameterReferenceExpression) { throw new NotSupportedException(Strings.SqlGen_ParameterForSkipNotSupportedOnSql8); } this.VisitExpressionBinding(expression.Input); this.VisitSortClauseList(expression.SortOrder); this.VisitExpression(expression.Count); return(true); }
public override DbExpression Visit(DbSkipExpression expression) { DbExpression found = Find(expression.Input.Expression); if (!object.ReferenceEquals(found, expression.Input.Expression)) { return(found.BindAs(expression.Input.VariableName).Skip(expression.SortOrder, expression.Count)); } else { return(expression); } }
/// <summary> /// Visitor pattern method for <see cref="DbSkipExpression" />. /// </summary> /// <param name="expression"> The DbLimitExpression that is being visited. </param> /// <exception cref="ArgumentNullException"> /// <paramref name="expression" /> /// is null /// </exception> public override void Visit(DbSkipExpression expression) { Check.NotNull(expression, "expression"); VisitExpressionBindingPre(expression.Input); foreach (var s in expression.SortOrder) { VisitExpression(s.Expression); } VisitExpressionBindingPost(expression.Input); VisitExpression(expression.Count); }
/// <summary> /// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbSkipExpression"/>. /// </summary> /// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbSkipExpression"/> that is visited.</param> public override void Visit(DbSkipExpression expression) { if (expression == null) { throw new ArgumentNullException("expression"); } expression.Count.Accept(this); expression.Input.Expression.Accept(this); foreach (var sortClause in expression.SortOrder) { sortClause.Expression.Accept(this); } }
/// <summary> /// Resturns true /// </summary> /// <param name="expression"></param> /// <returns></returns> /// <exception cref="NotSupportedException">expression.Count is DbParameterReferenceExpression</exception> public override bool Visit(DbSkipExpression expression) { if (expression.Count is DbParameterReferenceExpression) { throw EntityUtil.NotSupported(System.Data.Entity.Strings.SqlGen_ParameterForSkipNotSupportedOnSql8); } //Walk the structure in case a non-supported construct is encountered VisitExpressionBinding(expression.Input); VisitSortClauseList(expression.SortOrder); VisitExpression(expression.Count); return(true); }
public override void Visit(DbSkipExpression expression) { if (expression == null) { throw new ArgumentException("expression"); } VisitExpressionBindingPre(expression.Input); foreach (DbSortClause clause in expression.SortOrder) { VisitExpression(clause.Expression); } VisitExpressionBindingPost(expression.Input); VisitExpression(expression.Count); }
public override DbExpression Visit(DbSkipExpression expression) { Check.NotNull(expression, "expression"); var found = Find(expression.Input.Expression); if (!ReferenceEquals(found, expression.Input.Expression)) { return(found.BindAs(expression.Input.VariableName).Skip(expression.SortOrder, expression.Count)); } else { return(expression); } }
public override SqlFragment Visit(DbSkipExpression expression) { SelectStatement select = VisitInputExpressionEnsureSelect(expression.Input.Expression, expression.Input.VariableName, expression.Input.VariableType); foreach (DbSortClause sortClause in expression.SortOrder) { select.AddOrderBy( new SortFragment(sortClause.Expression.Accept(this), sortClause.Ascending)); } select = WrapIfNotCompatible(select, expression.ExpressionKind); select.Skip = expression.Count.Accept(this); return(select); }
/// <summary> /// Resturns true /// </summary> /// <param name="expression"> </param> /// <returns> </returns> /// <exception cref="NotSupportedException">expression.Count is DbParameterReferenceExpression</exception> public override bool Visit(DbSkipExpression expression) { Check.NotNull(expression, "expression"); if (expression.Count is DbParameterReferenceExpression) { throw new NotSupportedException(Strings.SqlGen_ParameterForSkipNotSupportedOnSql8); } //Walk the structure in case a non-supported construct is encountered VisitExpressionBinding(expression.Input); VisitSortClauseList(expression.SortOrder); VisitExpression(expression.Count); return(true); }
/// <summary> /// Visitor pattern method for <see cref="DbSkipExpression"/>. /// </summary> /// <param name="expression">The DbSkipExpression that is being visited.</param> /// <exception cref="ArgumentNullException"><paramref name="expression"/> is null</exception> public override void Visit(DbSkipExpression expression) { // #433613: PreSharp warning 56506: Parameter 'expression' to this public method must be validated: A null-dereference can occur here. EntityUtil.CheckArgumentNull(expression, "expression"); VisitExpressionBindingPre(expression.Input); foreach (DbSortClause sortKey in expression.SortOrder) { VisitExpression(sortKey.Expression); } VisitExpressionBindingPost(expression.Input); VisitExpression(expression.Count); }
/// <summary> /// Logicaly, <see cref="DbSkipExpression"/> translates to: /// SELECT Y.x1, Y.x2, ..., Y.xn /// FROM ( /// SELECT X.x1, X.x2, ..., X.xn, /// FROM input AS X /// EXCEPT /// SELECT TOP(count) Z.x1, Z.x2, ..., Z.xn /// FROM input AS Z /// ORDER BY sk1, sk2, ... /// ) AS Y /// ORDER BY sk1, sk2, ... /// /// Here, input refers to the input of the <see cref="DbSkipExpression"/>, and count to the count property of the <see cref="DbSkipExpression"/>. /// The implementation of EXCEPT is non-duplicate eliminating, and does equality comparison only over the /// equality comparable columns of the input. /// /// This corresponds to the following expression tree: /// /// SORT /// | /// NON-DISTINCT EXCEPT (specially translated, <see cref="TransformIntersectOrExcept(DbExpression left, DbExpression right, DbExpressionKind expressionKind, IList<DbPropertyExpression> sortExpressionsOverLeft, string sortExpressionsBindingVariableName)"/> /// | /// | - Left: clone of input /// | - Right: /// | /// Limit /// | /// | - Limit: Count /// | - Input /// | /// Sort /// | /// input /// /// </summary> /// <param name="e"></param> /// <returns></returns> public override DbExpression Visit(DbSkipExpression e) { //Build the right input of the except DbExpression rightInput = VisitExpressionBinding(e.Input).Sort(VisitSortOrder(e.SortOrder)).Limit(VisitExpression(e.Count)); //Build the left input for the except var leftInput = VisitExpression(e.Input.Expression); //Another copy of the input var sortOrder = VisitSortOrder(e.SortOrder); //Another copy of the sort order // Create a list of the sort expressions to be used for translating except IList<DbPropertyExpression> sortExpressions = new List<DbPropertyExpression>(e.SortOrder.Count); foreach (var sortClause in sortOrder) { //We only care about property expressions, not about constants if (sortClause.Expression.ExpressionKind == DbExpressionKind.Property) { sortExpressions.Add((DbPropertyExpression)sortClause.Expression); } } var exceptExpression = TransformIntersectOrExcept( leftInput, rightInput, DbExpressionKind.Skip, sortExpressions, e.Input.VariableName); DbExpression result = exceptExpression.BindAs(e.Input.VariableName).Sort(sortOrder); return result; }
/// <summary> /// Visitor pattern method for DbSkipExpression. /// </summary> /// <param name="expression"> The DbSkipExpression that is being visited. </param> public abstract void Visit(DbSkipExpression expression);
public override void Visit(DbSkipExpression expression) { }
public override void Visit(DbSkipExpression expression) { throw new NotSupportedException("Visit(\"SkipExpression\") is not supported."); }
public override DbExpression Visit(DbSkipExpression expression) { DbExpression found = Find(expression.Input.Expression); if (!object.ReferenceEquals(found, expression.Input.Expression)) { return found.BindAs(expression.Input.VariableName).Skip(expression.SortOrder, expression.Count); } else { return expression; } }
public override SqlFragment Visit(DbSkipExpression expression) { SelectStatement select = VisitInputExpressionEnsureSelect(expression.Input.Expression, expression.Input.VariableName, expression.Input.VariableType); foreach (DbSortClause sortClause in expression.SortOrder) { select.AddOrderBy( new SortFragment(sortClause.Expression.Accept(this), sortClause.Ascending)); } select = WrapIfNotCompatible(select, expression.ExpressionKind); select.Skip = expression.Count.Accept(this); return select; }
internal SkipLifter(DbSkipExpression skip, AliasGenerator aliasGenerator) : base(skip, aliasGenerator) { _skip = skip; _source = skip.Input.Expression; }
public override void Visit(DbSkipExpression expression) { Contract.Requires(expression != null); }
public override SqlFragment Visit(DbSkipExpression expression) { SelectStatement select = VisitInputExpressionEnsureSelect(expression.Input.Expression, expression.Input.VariableName, expression.Input.VariableType); select = WrapIfNotCompatible(select, DbExpressionKind.Sort); foreach (DbSortClause sortClause in expression.SortOrder) { select.AddOrderBy( new SortFragment(sortClause.Expression.Accept(this), sortClause.Ascending)); } // if we wrapped above, then this wrap will not create a new one so there // is no harm in calling it select = WrapIfNotCompatible(select, expression.ExpressionKind); select.Skip = expression.Count.Accept(this); return select; }
protected DbSkipExpression RebindSkip(DbExpression input, DbSkipExpression skip, DbExpression k) { DbExpressionBinding inputBinding = input.BindAs(skip.Input.VariableName); return inputBinding.Skip(skip.SortOrder, k); }
protected DbSortExpression ApplySkipOrderToSort(DbExpression input, DbSkipExpression sortSpec) { DbExpressionBinding inputBinding = input.BindAs(sortSpec.Input.VariableName); return inputBinding.Sort(sortSpec.SortOrder); }
public override void Visit(DbSkipExpression expression) { if (expression == null) throw new ArgumentException("expression"); VisitExpressionBindingPre(expression.Input); foreach (DbSortClause clause in expression.SortOrder) { VisitExpression(clause.Expression); } VisitExpressionBindingPost(expression.Input); VisitExpression(expression.Count); }
/// <summary> /// Visitor pattern method for <see cref="DbSkipExpression"/>. /// </summary> /// <param name="expression">The DbSkipExpression that is being visited.</param> /// <exception cref="ArgumentNullException"><paramref name="expression"/> is null</exception> public override void Visit(DbSkipExpression expression) { VisitExpressionBindingPre(expression.Input); foreach (var sortKey in expression.SortOrder) { VisitExpression(sortKey.Expression); } VisitExpressionBindingPost(expression.Input); VisitExpression(expression.Count); }
protected DbSkipExpression AddToSkip(DbExpression input, DbSkipExpression skip, DbExpression plusK) { // source.Skip(k, o).Skip(k2) -> source.Skip(k + k2, o) DbExpression newCount = CombineIntegers(skip.Count, plusK, (l, r) => l + r); return RebindSkip(input, skip, newCount); }
public override DbExpression Visit(DbSkipExpression expression) { Check.NotNull(expression, "expression"); var found = Find(expression.Input.Expression); if (!ReferenceEquals(found, expression.Input.Expression)) { return found.BindAs(expression.Input.VariableName).Skip(expression.SortOrder, expression.Count); } else { return expression; } }