public override Expression Visit(DbLimitExpression expression) { Expression source = this.Visit(expression.Argument); Type sourceType = TypeHelper.GetElementType(source.Type); return(queryMethodExpressionBuilder.Take(source, this.Visit(expression.Limit, typeof(int)))); }
protected DbLimitExpression MinimumLimit(DbExpression input, DbLimitExpression limit, DbExpression k) { // source.Limit(k).Limit(k2) -> source.Limit(Min(k, k2)) DbExpression newCount = CombineIntegers(limit.Limit, k, Math.Min); return(DbExpressionBuilder.Limit(input, newCount)); }
protected static DbLimitExpression MinimumLimit(DbExpression input, DbLimitExpression limit, DbExpression k) { // source.Limit(k).Limit(k2) -> source.Limit(Min(k, k2)) var newCount = CombineIntegers(limit.Limit, k, Math.Min); return(input.Limit(newCount)); }
public override VfpExpression Visit(DbLimitExpression expression) { return(new VfpLimitExpression(expression.ResultType, expression.Argument.Accept(this), expression.Limit.Accept(this), expression.WithTies)); }
public override Expression Visit(DbLimitExpression expression) { Expression source = this.Visit(expression.Argument); Type sourceType = TypeHelper.GetElementType(source.Type); return queryMethodExpressionBuilder.Take(source, this.Visit(expression.Limit, typeof(int))); }
internal LimitSortLifter(DbLimitExpression limit, DbSortExpression sort, AliasGenerator aliasGenerator) : base(limit, aliasGenerator) { _limit = limit; _sort = sort; _source = sort.Input.Expression; }
public override void Visit(DbLimitExpression e) { Begin(e, "WithTies", e.WithTies); Dump(e.Argument, "Argument"); Dump(e.Limit, "Limit"); End(e); }
protected DbLimitExpression SubtractFromLimit(DbExpression input, DbLimitExpression limit, DbExpression minusK) { DbExpression newCount = CombineIntegers(limit.Limit, minusK, (l, r) => r > l ? 0 : l - r); // can't limit to less than zero rows) return(DbExpressionBuilder.Limit(input, newCount)); }
internal LimitSkipLifter(DbLimitExpression limit, DbSkipExpression skip, AliasGenerator aliasGenerator) : base(limit, aliasGenerator) { _limit = limit; _skip = skip; _source = skip.Input.Expression; }
internal ProjectLimitSkipLifter(DbProjectExpression project, DbLimitExpression limit, DbSkipExpression skip, AliasGenerator aliasGenerator) : base(project, aliasGenerator) { _project = project; _limit = limit; _skip = skip; _source = skip.Input.Expression; }
internal ProjectLimitSortLifter(DbProjectExpression project, DbLimitExpression limit, DbSortExpression sort, AliasGenerator aliasGenerator) : base(project, aliasGenerator) { _project = project; _limit = limit; _sort = sort; _source = sort.Input.Expression; }
/// <summary> /// Visitor pattern method for <see cref="DbLimitExpression" />. /// </summary> /// <param name="expression"> The DbLimitExpression that is being visited. </param> /// <exception cref="ArgumentNullException"> /// <paramref name="expression" /> /// is null /// </exception> public override void Visit(DbLimitExpression expression) { // #433613: PreSharp warning 56506: Parameter 'expression' to this public method must be validated: A null-dereference can occur here. Check.NotNull(expression, "expression"); VisitExpression(expression.Argument); VisitExpression(expression.Limit); }
public override void Visit(DbLimitExpression e) { Check.NotNull <DbLimitExpression>(e, nameof(e)); this.Begin((DbExpression)e, "WithTies", (object)e.WithTies); this.Dump(e.Argument, "Argument"); this.Dump(e.Limit, "Limit"); this.End((DbExpression)e); }
public override SqlFragment Visit(DbLimitExpression expression) { SelectStatement statement = (SelectStatement)VisitInputExpressionEnsureSelect( expression.Argument, null, null); statement.Limit = expression.Limit.Accept(this); return(statement); }
public override LegacyCommandTrees.DbExpression Visit(DbLimitExpression expression) { Debug.Assert(expression != null, "expression != null"); return (expression.Argument.Accept(this) .Limit(expression.Limit.Accept(this))); }
public override bool Visit(DbLimitExpression expression) { Check.NotNull <DbLimitExpression>(expression, nameof(expression)); if (expression.Limit is DbParameterReferenceExpression) { throw new NotSupportedException(Strings.SqlGen_ParameterForLimitNotSupportedOnSql8); } return(this.VisitExpression(expression.Argument)); }
/// <summary> /// Walks the structure /// </summary> /// <param name="expression"></param> /// <returns></returns> /// <exception cref="NotSupportedException">expression.Limit is DbParameterReferenceExpression</exception> public override bool Visit(DbLimitExpression expression) { if (expression.Limit is DbParameterReferenceExpression) { throw EntityUtil.NotSupported(System.Data.Entity.Strings.SqlGen_ParameterForLimitNotSupportedOnSql8); } return(VisitExpression(expression.Argument)); }
public override void Visit(DbLimitExpression expression) { if (expression == null) { throw new ArgumentException("expression"); } VisitExpression(expression.Argument); VisitExpression(expression.Limit); }
public override SqlFragment Visit(DbLimitExpression expression) { SelectStatement select = (SelectStatement)VisitInputExpressionEnsureSelect( expression.Argument, null, null); select = WrapIfNotCompatible(select, expression.ExpressionKind); select.Limit = expression.Limit.Accept(this); return(select); }
public override void Visit(DbLimitExpression expression) { Write(expression); _depth++; Write("Argument", expression.Argument); Write("Limit", expression.Limit); Write("WithTies", expression.WithTies); _depth--; }
private DbExpression RewriteLimitExpression(DbLimitExpression expression) { DbExpression dbExpression = this.Rewrite(expression.Argument); if (!object.ReferenceEquals((object)expression.Argument, (object)dbExpression)) { expression = dbExpression.Limit(expression.Limit); } return((DbExpression)expression); }
/// <summary> /// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbLimitExpression"/>. /// </summary> /// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbLimitExpression"/> that is visited.</param> public override void Visit(DbLimitExpression expression) { if (expression == null) { throw new ArgumentNullException("expression"); } expression.Argument.Accept(this); expression.Limit.Accept(this); }
private DbExpression RewriteLimitExpression(DbLimitExpression expression) { DbExpression rewrittenInput = Rewrite(expression.Argument); if (!object.ReferenceEquals(expression.Argument, rewrittenInput)) { // Note that here we use the original expression.Limit. It is safe to do so, // because we only allow physical paging (i.e. Limit can only be a constant or parameter) expression = rewrittenInput.Limit(expression.Limit); } return(expression); }
public override void Visit(DbLimitExpression e) { VisitExprKind(e.ExpressionKind); if (e.WithTies) { _key.Append("WithTies"); } _key.Append('('); e.Argument.Accept(this); _key.Append(")("); e.Limit.Accept(this); _key.Append(')'); }
public override void Visit(DbLimitExpression e) { Check.NotNull <DbLimitExpression>(e, nameof(e)); this.VisitExprKind(e.ExpressionKind); if (e.WithTies) { this._key.Append("WithTies"); } this._key.Append('('); e.Argument.Accept((DbExpressionVisitor)this); this._key.Append(")("); e.Limit.Accept((DbExpressionVisitor)this); this._key.Append(')'); }
/// <summary> /// Translates to TOP expression. /// </summary> /// <param name="e"></param> /// <returns>A <see cref="SqlBuilder"/></returns> public override ISqlFragment Visit(DbLimitExpression e) { Debug.Assert(e.Limit is DbConstantExpression || e.Limit is DbParameterReferenceExpression, "DbLimitExpression.Limit is of invalid expression type"); var result = VisitExpressionEnsureSqlStatement(e.Argument, false); if (!IsCompatible(result, e.ExpressionKind)) { TypeUsage inputType = MetadataHelpers.GetElementTypeUsage(e.Argument.ResultType); Symbol fromSymbol; result = CreateNewSelectStatement(result, "first", inputType, out fromSymbol); AddFromSymbol(result, "first", fromSymbol, false); } result.Top.TopCount = HandleCountExpression(e.Limit); return(result); }
public override SqlFragment Visit(DbLimitExpression expression) { SelectStatement select = (SelectStatement)VisitInputExpressionEnsureSelect( expression.Argument, null, null); select = WrapIfNotCompatible(select, expression.ExpressionKind); select.Limit = expression.Limit.Accept(this); return select; }
public override void Visit(DbLimitExpression expression) { if (expression == null) throw new ArgumentException("expression"); VisitExpression(expression.Argument); VisitExpression(expression.Limit); }
protected static DbLimitExpression SubtractFromLimit(DbExpression input, DbLimitExpression limit, DbExpression minusK) { var newCount = CombineIntegers( limit.Limit, minusK, (l, r) => r > l ? 0 : l - r); // can't limit to less than zero rows) return input.Limit(newCount); }
public override DbExpression Visit(DbLimitExpression expression) { System.Diagnostics.Debug.Print("Visit(DbLimitExpression): {0}", expression); return base.Visit(expression); }
private DbExpression RewriteLimitExpression(DbLimitExpression expression) { DbExpression rewrittenInput = Rewrite(expression.Argument); if (!object.ReferenceEquals(expression.Argument, rewrittenInput)) { // Note that here we use the original expression.Limit. It is safe to do so, // because we only allow physical paging (i.e. Limit can only be a constant or parameter) expression = rewrittenInput.Limit(expression.Limit); } return expression; }
public override void Visit(DbLimitExpression expression) { Contract.Requires(expression != null); }
public override void Visit(DbLimitExpression expression) { throw new NotSupportedException("Visit(\"DbLimitExpression\") is not supported."); }
protected DbLimitExpression SubtractFromLimit(DbExpression input, DbLimitExpression limit, DbExpression minusK) { DbExpression newCount = CombineIntegers(limit.Limit, minusK, (l, r) => r > l ? 0 : l - r); // can't limit to less than zero rows) return DbExpressionBuilder.Limit(input, newCount); }
public override bool Visit(DbLimitExpression expression) { return(VisitExpression(expression.Argument)); }
public override void Visit(DbLimitExpression expression) { }
/// <summary> /// Visitor pattern method for DbLimitExpression. /// </summary> /// <param name="expression"> The DbLimitExpression that is being visited. </param> public abstract void Visit(DbLimitExpression expression);
protected static DbLimitExpression MinimumLimit(DbExpression input, DbLimitExpression limit, DbExpression k) { // source.Limit(k).Limit(k2) -> source.Limit(Min(k, k2)) var newCount = CombineIntegers(limit.Limit, k, Math.Min); return input.Limit(newCount); }
public override SqlFragment Visit(DbLimitExpression expression) { throw new NotImplementedException(); }
/// <summary> /// Visitor pattern method for <see cref="DbLimitExpression" />. /// </summary> /// <param name="expression"> The DbLimitExpression that is being visited. </param> /// <exception cref="ArgumentNullException"> /// <paramref name="expression" /> /// is null /// </exception> public override void Visit(DbLimitExpression expression) { Check.NotNull(expression, "expression"); VisitExpression(expression.Argument); VisitExpression(expression.Limit); }
public override void Visit(DbLimitExpression expression) { throw new NotSupportedException("Visit(\"LimitExpression\") is not supported."); }
protected DbLimitExpression MinimumLimit(DbExpression input, DbLimitExpression limit, DbExpression k) { // source.Limit(k).Limit(k2) -> source.Limit(Min(k, k2)) DbExpression newCount = CombineIntegers(limit.Limit, k, Math.Min); return DbExpressionBuilder.Limit(input, newCount); }
public override TreeNode Visit(DbLimitExpression e) { Check.NotNull <DbLimitExpression>(e, nameof(e)); return(this.Visit(e.WithTies ? "LimitWithTies" : "Limit", e.Argument, e.Limit)); }
public override SqlFragment Visit(DbLimitExpression expression) { SelectStatement statement = (SelectStatement)VisitInputExpressionEnsureSelect( expression.Argument, null, null); statement.Limit = expression.Limit.Accept(this); return statement; }
public override DbExpressionEntitySetInfo Visit(DbLimitExpression expression) { return(null); }
/// <summary> /// Visitor pattern method for <see cref="DbLimitExpression"/>. /// </summary> /// <param name="expression">The DbLimitExpression that is being visited.</param> /// <exception cref="ArgumentNullException"><paramref name="expression"/> is null</exception> public override void Visit(DbLimitExpression expression) { VisitExpression(expression.Argument); VisitExpression(expression.Limit); }