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);
}
