protected virtual void ProcessOffsetAndLimit(SQLProcessorAggregator aggregator, NonBooleanExpression offset, NonBooleanExpression limit, StringBuilder builder) { NonBooleanExpression first, second; var offsetBeforeLimit = this.IsOffsetBeforeLimit(aggregator.SQLVendor); if (offsetBeforeLimit) { first = offset; second = limit; } else { first = limit; second = offset; } if (first != null) { builder.Append(SQLConstants.NEWLINE); this.ProcessOffsetOrLimit(aggregator, builder, first, offsetBeforeLimit); } if (second != null) { builder.Append(SQLConstants.NEWLINE); this.ProcessOffsetOrLimit(aggregator, builder, second, !offsetBeforeLimit); } }
public BinaryArithmeticExpressionImpl(SQLVendorImpl vendor, ArithmeticOperator op, NonBooleanExpression left, NonBooleanExpression right) : base(vendor, op) { ArgumentValidator.ValidateNotNull(nameof(left), left); ArgumentValidator.ValidateNotNull(nameof(right), right); this._left = left; this._right = right; }
public UnaryArithmeticExpressionImpl(SQLVendorImpl vendor, ArithmeticOperator op, NonBooleanExpression expression) : base(vendor, op) { ArgumentValidator.ValidateNotNull(nameof(expression), expression); if (ArithmeticOperator.Minus != op || ArithmeticOperator.Plus != op) { throw new ArgumentException("Unary arithmetic expression operator must be either plus or minus."); } this._expr = expression; }
public QuerySpecificationImpl(SQLVendorImpl vendor, SelectColumnClause select, FromClause from, BooleanExpression where, GroupByClause groupBy, BooleanExpression having, OrderByClause orderBy, NonBooleanExpression offset, NonBooleanExpression limit) : base(vendor) { ArgumentValidator.ValidateNotNull(nameof(select), select); this._select = select; this._from = from; this._where = where; this._groupBy = groupBy; this._having = having; this._orderBy = orderBy; this._offset = offset; this._limit = limit; }
protected virtual void ProcessOffsetOrLimit(SQLProcessorAggregator aggregator, StringBuilder builder, NonBooleanExpression expr, Boolean isOffset) { var prefix = isOffset ? this.GetOffsetPrefix(aggregator.SQLVendor) : this.GetLimitPrefix(aggregator.SQLVendor); if (prefix != null) { builder.Append(prefix).Append(SQLConstants.TOKEN_SEPARATOR); } var isComplex = !(expr is LiteralExpression); if (isComplex) { builder.Append(SQLConstants.OPEN_PARENTHESIS + SQLConstants.NEWLINE); } aggregator.Process(expr, builder); if (isComplex) { builder.Append(SQLConstants.CLOSE_PARENTHESIS); } var postfix = isOffset ? this.GetOffsetPostfix(aggregator.SQLVendor) : this.GetLimitPostfix(aggregator.SQLVendor); if (postfix != null) { builder.Append(SQLConstants.TOKEN_SEPARATOR).Append(postfix); } }
public virtual QuerySpecification NewQuerySpecification(SelectColumnClause select, FromClause from = null, BooleanExpression where = null, GroupByClause groupBy = null, BooleanExpression having = null, OrderByClause orderBy = null, NonBooleanExpression offset = null, NonBooleanExpression limit = null) { return(new QuerySpecificationImpl(this.vendor, select, from, where, groupBy, having, orderBy, offset, limit)); }
public virtual UnaryArithmeticExpression UnaryMinus(NonBooleanExpression expr) { return(new UnaryArithmeticExpressionImpl(this.vendor, ArithmeticOperator.Minus, expr)); }
public virtual BinaryArithmeticExpression Div(NonBooleanExpression left, NonBooleanExpression right) { return(new BinaryArithmeticExpressionImpl(this.vendor, ArithmeticOperator.Division, left, right)); }
protected override void ProcessOffsetAndLimit(SQLProcessorAggregator aggregator, NonBooleanExpression offset, NonBooleanExpression limit, StringBuilder builder) { if (((MySQLVendor)aggregator.SQLVendor).LegacyLimitSyntax) { // LIMIT X(,Y) builder.Append(SQLConstants.NEWLINE + MYSQL_LIMIT_PREFIX + SQLConstants.TOKEN_SEPARATOR); if (offset != null) { aggregator.Process(offset, builder); builder.Append(SQLConstants.COMMA); } if (limit != null) { aggregator.Process(limit, builder); } else if (offset != null) { builder.Append(Int64.MaxValue); } } else { if (limit == null) { limit = aggregator.SQLVendor.CommonFactory.I64(Int64.MaxValue); } base.ProcessOffsetAndLimit(aggregator, offset, limit, builder); } }
public static Negation NotRegexp(this CommonFactory factory, NonBooleanExpression what, NonBooleanExpression pattern) { return(factory.Not(factory.Regexp(what, pattern))); }
public static Negation NotIn(this CommonFactory factory, NonBooleanExpression what, params NonBooleanExpression[] values) { return(factory.Not(factory.In(what, values))); }
public static Negation NotBetween(this CommonFactory factory, NonBooleanExpression left, NonBooleanExpression minimum, NonBooleanExpression maximum) { return(factory.Not(factory.Between(left, minimum, maximum))); }
public static Negation IsNotNull(this CommonFactory factory, NonBooleanExpression what) { return(factory.Not(factory.IsNull(what))); }
public QuerySpecificationBuilder Offset(NonBooleanExpression skip) { this._offset = skip; return(this); }
public QuerySpecificationBuilder Limit(NonBooleanExpression max) { this._limit = max; return(this); }