public AggregateExpression(string aggregateName, SqlExpression argument, bool isDistinct)
: base(SqlExpressionType.Aggregate)
{
this.AggregateName = aggregateName;
this.Argument = argument;
this.IsDistinct = isDistinct;
}
public UnaryExpression(SqlExpressionType nodeType, SqlExpression operand)
: base(nodeType)
{
switch(nodeType)
{
case SqlExpressionType.Exists:
case SqlExpressionType.IsNull:
case SqlExpressionType.Negate:
case SqlExpressionType.Not:
case SqlExpressionType.UnaryPlus:
this.Operand = operand;
break;
default:
throw new ArgumentOutOfRangeException(nameof(nodeType));
}
}
public UpdateExpression(TableExpression table, SqlExpression where, IEnumerable<ColumnAssignment> assignments)
: base(SqlExpressionType.Update)
{
this.Table = table;
this.Where = where;
this.Assignments = assignments.ToReadOnly();
}
public SelectExpression(
TableAlias tableAlias,
IEnumerable<ColumnDeclaration> columns,
SqlExpression from,
SqlExpression where,
IEnumerable<OrderByDeclaration> orderBy,
IEnumerable<SqlExpression> groupBy
)
: this(tableAlias, columns, from, where, orderBy, groupBy, null, null, false)
{
}
public SelectExpression(
TableAlias tableAlias,
IEnumerable<ColumnDeclaration> columns,
SqlExpression from,
SqlExpression where
)
: this(tableAlias, columns, from, where, null, null)
{
}
public static SqlExpression Rewrite(SqlExpression expression)
{
return new OrderByRewriter().Visit(expression);
}
public BinaryExpression(SqlExpressionType nodeType, SqlExpression left, SqlExpression right)
: base(nodeType)
{
switch(nodeType)
{
case SqlExpressionType.Add:
case SqlExpressionType.Subtract:
case SqlExpressionType.Multiply:
case SqlExpressionType.Divide:
case SqlExpressionType.Modulo:
case SqlExpressionType.And:
case SqlExpressionType.Or:
case SqlExpressionType.LessThan:
case SqlExpressionType.GreaterThan:
case SqlExpressionType.Equal:
case SqlExpressionType.NotEqual:
case SqlExpressionType.RightShift:
case SqlExpressionType.LeftShift:
case SqlExpressionType.ExclusiveOr:
this.Left = left;
this.Right = right;
break;
default:
throw new ArgumentOutOfRangeException(nameof(nodeType));
}
}
public InExpression(SqlExpression expression, IEnumerable<SqlExpression> values)
: base(SqlExpressionType.In)
{
this.Expression = expression;
this.Values = values.ToReadOnly();
}
public JoinExpression(JoinType joinType, SqlExpression left, SqlExpression right, SqlExpression condition)
: base(SqlExpressionType.Join)
{
this.JoinType = joinType;
this.Left = left;
this.Right = right;
this.Condition = condition;
}
public DeleteExpression(TableExpression table, SqlExpression where)
: base(SqlExpressionType.Delete)
{
this.Table = table;
this.Where = where;
}
public InExpression(SqlExpression expression, SelectExpression select)
: base(SqlExpressionType.In)
{
this.Expression = expression;
this.Select = select;
}
public ConditionalExpression(SqlExpression test, SqlExpression ifTrue, SqlExpression ifFalse)
: base(SqlExpressionType.Conditional)
{
this.Test = test;
this.IfTrue = ifTrue;
this.IfFalse = ifFalse;
}
public ColumnDeclaration(string declaredName, SqlExpression expression)
{
this.DeclaredName = declaredName;
this.Expression = expression;
}
public ColumnAssignment(ColumnExpression column, SqlExpression expression)
{
this.Column = column;
this.Expression = expression;
}
protected override SqlExpression VisitSource(SqlExpression expr)
{
switch(expr.NodeType)
{
case SqlExpressionType.Table:
this.Visit(expr);
break;
case SqlExpressionType.Select:
SelectExpression select = (SelectExpression)expr;
this.Write("(");
this.NewLine(Indentation.Inner);
this.Visit(select);
this.NewLine(Indentation.Outer);
this.Write(") " + GetAliasName(select.TableAlias) + " ");
break;
case SqlExpressionType.Join:
this.Visit(expr);
break;
default:
throw new ArgumentException("Invalid Source!", nameof(expr));
}
return expr;
}
public OrderByDeclaration(OrderType orderType, SqlExpression expression)
{
this.OrderType = orderType;
this.Expression = expression;
}
public static FormatResult Format(SqlExpression expression)
{
SqlFormatter formatter = new SqlFormatter();
formatter.Visit(expression);
return new FormatResult() { SqlText = formatter.sb.ToString(), Parameters = formatter.parameters };
}
public SelectExpression(
TableAlias tableAlias,
IEnumerable<ColumnDeclaration> columns,
SqlExpression from,
SqlExpression where,
IEnumerable<OrderByDeclaration> orderBy,
IEnumerable<SqlExpression> groupBy,
int? skip,
int? take,
bool isDistinct
)
: base(SqlExpressionType.Select, tableAlias)
{
this.Columns = columns.ToReadOnly();
this.From = from;
this.Where = where;
this.OrderBy = orderBy.ToReadOnly();
this.GroupBy = groupBy.ToReadOnly();
this.Skip = skip;
this.Take = take;
this.IsDistinct = isDistinct;
}
public static HashSet<TableAlias> Gather(SqlExpression source)
{
DeclaredAliasGatherer gatherer = new DeclaredAliasGatherer();
gatherer.Visit(source);
return gatherer.aliases;
}
public BetweenExpression(SqlExpression expression, SqlExpression lower, SqlExpression upper)
: base(SqlExpressionType.Between)
{
this.Expression = expression;
this.Lower = lower;
this.Upper = upper;
}