public string Build(SqlOrderType type)
{
if (string.IsNullOrWhiteSpace(_tableName))
{
throw new ArgumentNullException(nameof(_tableName));
}
if (string.IsNullOrWhiteSpace(_columnName))
{
return(string.Empty);
}
var tableAlias = _tableName.TableNameAlias();
switch (type)
{
case SqlOrderType.Ascending:
return($" ORDER BY {tableAlias}.{_columnName}");
case SqlOrderType.Descending:
return($" ORDER BY {tableAlias}.{_columnName} DESC");
default:
return(string.Empty);
}
}
/// <summary>
/// 初始化新的Sql语句排序类
/// </summary>
/// <param name="baseCommand">选择语句</param>
/// <param name="tableName">表格名称</param>
/// <param name="function">合计函数</param>
/// <param name="columnName">字段名</param>
/// <param name="useDistinct">是否保证记录唯一</param>
/// <param name="orderType">排序方式</param>
private SqlOrder(SelectCommand baseCommand, String tableName, SqlAggregateFunction function, String columnName, Boolean useDistinct, SqlOrderType orderType)
{
this._tableName = tableName;
this._columnName = columnName;
this._orderType = orderType;
this._useFunction = true;
this._useDistinct = useDistinct;
this._function = function.ToString().ToUpperInvariant();
}
/// <summary>
/// 初始化新的Sql语句排序类
/// </summary>
/// <param name="baseCommand">选择语句</param>
/// <param name="tableName">表格名称</param>
/// <param name="columnName">字段名</param>
/// <param name="orderType">排序方式</param>
private SqlOrder(SelectCommand baseCommand, String tableName, String columnName, SqlOrderType orderType)
{
this._tableName = tableName;
this._columnName = columnName;
this._orderType = orderType;
this._useFunction = false;
this._useDistinct = false;
this._function = String.Empty;
}
/// <summary>
/// 初始化新的Sql语句排序类
/// </summary>
/// <param name="baseCommand">选择语句</param>
/// <param name="tableName">表格名称</param>
/// <param name="columnName">字段名</param>
/// <param name="orderType">排序方式</param>
private SqlOrder(SelectCommand baseCommand, String tableName, String columnName, SqlOrderType orderType)
{
this._tableName = tableName;
this._columnName = columnName;
this._orderType = orderType;
this._useFunction = false;
this._useDistinct = false;
this._function = String.Empty;
}
/// <summary>
/// 创建新的Sql语句排序类
/// </summary>
/// <param name="cmd">选择语句</param>
/// <param name="tableName">表格名称</param>
/// <param name="function">合计函数</param>
/// <param name="useDistinct">是否保证记录唯一</param>
/// <param name="orderType">排序方式</param>
internal static SqlOrder InternalCreateFromAggregateFunction(SelectCommand cmd, String tableName, SqlAggregateFunction function, Boolean useDistinct, SqlOrderType orderType)
{
return new SqlOrder(cmd, tableName, function, "*", useDistinct, orderType);
}
private SqlSelect VisitThenBy(Expression sequence, LambdaExpression expression, SqlOrderType orderType) {
if (IsGrouping(expression.Body.Type)) {
throw Error.GroupingNotSupportedAsOrderCriterion();
}
if (!this.typeProvider.From(expression.Body.Type).IsOrderable) {
throw Error.TypeCannotBeOrdered(expression.Body.Type);
}
SqlSelect select = this.VisitSequence(sequence);
System.Diagnostics.Debug.Assert(select.Selection.NodeType == SqlNodeType.AliasRef);
this.map[expression.Parameters[0]] = (SqlAliasRef)select.Selection;
SqlExpression expr = this.VisitExpression(expression.Body);
select.OrderBy.Add(new SqlOrderExpression(orderType, expr));
return select;
}
public Criteria <T> AddOrderProperty(Expression <Func <T, object> > expression, SqlOrderType type = SqlOrderType.ASC)
{
string prop = ExpressionHelper.GetExpressionMemberName(expression);
ColumnMapping column = TableMapping.GetColumnMappingByProperty(prop);
base.AddOrderColumn(column != null ? column.Name : prop, type);
return(this);
}
/// <summary>
/// 创建新的Sql语句排序类
/// </summary>
/// <param name="cmd">选择语句</param>
/// <param name="function">合计函数</param>
/// <param name="orderType">排序方式</param>
internal static SqlOrder InternalCreateFromAggregateFunction(SelectCommand cmd, SqlAggregateFunction function, SqlOrderType orderType)
{
return new SqlOrder(cmd, String.Empty, function, "*", false, orderType);
}
/// <summary>
/// 创建新的Sql语句排序类
/// </summary>
/// <param name="cmd">选择语句</param>
/// <param name="function">合计函数</param>
/// <param name="orderType">排序方式</param>
internal static SqlOrder InternalCreateFromAggregateFunction(SelectCommand cmd, SqlAggregateFunction function, SqlOrderType orderType)
{
return(new SqlOrder(cmd, String.Empty, function, "*", false, orderType));
}
/// <summary>
/// 创建新的Sql语句排序类
/// </summary>
/// <param name="cmd">选择语句</param>
/// <param name="tableName">表格名称</param>
/// <param name="function">合计函数</param>
/// <param name="useDistinct">是否保证记录唯一</param>
/// <param name="orderType">排序方式</param>
internal static SqlOrder InternalCreateFromAggregateFunction(SelectCommand cmd, String tableName, SqlAggregateFunction function, Boolean useDistinct, SqlOrderType orderType)
{
return(new SqlOrder(cmd, tableName, function, "*", useDistinct, orderType));
}
/// <summary>
/// 创建新的Sql语句排序类
/// </summary>
/// <param name="cmd">选择语句</param>
/// <param name="columnName">字段名</param>
/// <param name="orderType">排序方式</param>
internal static SqlOrder InternalCreate(SelectCommand cmd, String columnName, SqlOrderType orderType)
{
return(new SqlOrder(cmd, String.Empty, columnName, orderType));
}
/// <summary>
/// 按指定列排序并返回当前语句
/// </summary>
/// <typeparam name="T">实体类类型</typeparam>
/// <param name="cmd">查询语句</param>
/// <param name="expr">实体类属性</param>
/// <param name="orderType">排序类型</param>
/// <exception cref="ExpressionInvalidException">表达式不正确</exception>
/// <exception cref="NullAttributeException">没有设置特性</exception>
/// <returns>当前语句</returns>
/// <example>
/// <code lang="C#">
/// <![CDATA[
/// public class UserRepository : DatabaseTable<User>
/// {
/// //other necessary code
///
/// public List<User> GetAllEntities()
/// {
/// return this.Select()
/// .Querys<User>(c => new { c.UserID, c.UserName })
/// .OrderBy<User>(c => c.UserID, SqlOrderType.Desc)
/// .ToEntityList<User>(this);
///
/// //SELECT UserID, UserName From tbl_Users ORDER BY UserID DESC
/// }
/// }
/// ]]>
/// </code>
/// </example>
public static SelectCommand OrderBy <T>(this SelectCommand cmd, Expression <Func <T, Object> > expr, SqlOrderType orderType)
{
DatabaseColumnAttribute attr = SelectCommandExtension.GetColumnAttribute(cmd, expr.Body);
String tableName = EntityHelper.InternalGetTableName(typeof(T));
return(cmd.OrderBy(tableName, attr.ColumnName, orderType));
}
public Criteria AddOrderColumn(string column, SqlOrderType type = SqlOrderType.ASC)
{
this.Orders.Add(new SqlOrder(column, type));
return(this);
}
/// <summary>
/// 按指定列排序并返回当前语句
/// </summary>
/// <param name="columnName">字段名</param>
/// <param name="orderType">排序类型</param>
/// <returns>当前语句</returns>
public SelectCommand OrderBy(String columnName, SqlOrderType orderType)
{
this._orders.Add(SqlOrder.Create(columnName, orderType));
return this;
}
/// <summary>
/// 初始化新的Sql语句排序类
/// </summary>
/// <param name="baseCommand">选择语句</param>
/// <param name="tableName">表格名称</param>
/// <param name="function">合计函数</param>
/// <param name="columnName">字段名</param>
/// <param name="useDistinct">是否保证记录唯一</param>
/// <param name="orderType">排序方式</param>
private SqlOrder(SelectCommand baseCommand, String tableName, SqlAggregateFunction function, String columnName, Boolean useDistinct, SqlOrderType orderType)
{
this._tableName = tableName;
this._columnName = columnName;
this._orderType = orderType;
this._useFunction = true;
this._useDistinct = useDistinct;
this._function = function.ToString().ToUpperInvariant();
}
/// <summary>
/// 创建新的Sql语句排序类
/// </summary>
/// <param name="cmd">源选择语句</param>
/// <param name="function">函数内容</param>
/// <param name="orderType">排序方式</param>
internal static SqlOrder InternalCreateFromFunction(SelectCommand cmd, String function, SqlOrderType orderType)
{
return new SqlOrder(cmd, function, orderType);
}
/// <summary>
/// 初始化新的Sql语句排序类
/// </summary>
/// <param name="cmd">选择语句</param>
/// <param name="columnName">字段名</param>
/// <param name="orderType">排序方式</param>
internal static SqlOrder Create(SelectCommand cmd, String columnName, SqlOrderType orderType)
{
return new SqlOrder(cmd, columnName, orderType);
}
/// <summary>
/// 按指定列排序并返回当前语句
/// </summary>
/// <param name="columnName">字段名</param>
/// <param name="orderType">排序类型</param>
/// <returns>当前语句</returns>
public SelectCommand OrderBy(String columnName, SqlOrderType orderType)
{
this._orders.Add(SqlOrder.Create(columnName, orderType));
return(this);
}
/// <summary>
/// 初始化新的Sql语句排序类
/// </summary>
/// <param name="fieldName">字段名</param>
/// <param name="orderType">排序方式</param>
private SqlOrder(String fieldName, SqlOrderType orderType)
{
this._fieldName = fieldName;
this._orderType = orderType;
}
/// <summary>
/// 创建新的Sql语句排序类
/// </summary>
/// <param name="cmd">选择语句</param>
/// <param name="tableName">表格名称</param>
/// <param name="function">合计函数</param>
/// <param name="columnName">字段名称</param>
/// <param name="orderType">排序方式</param>
internal static SqlOrder InternalCreateFromAggregateFunction(SelectCommand cmd, String tableName, SqlAggregateFunction function, String columnName, SqlOrderType orderType)
{
return(new SqlOrder(cmd, tableName, function, columnName, false, orderType));
}
/// <summary>
/// 初始化新的Sql语句排序类
/// </summary>
/// <param name="fieldName">字段名</param>
/// <param name="orderType">排序方式</param>
public static SqlOrder Create(String fieldName, SqlOrderType orderType)
{
return(new SqlOrder(fieldName, orderType));
}
/// <summary>
/// 创建新的Sql语句排序类
/// </summary>
/// <param name="cmd">选择语句</param>
/// <param name="function">合计函数</param>
/// <param name="columnName">字段名称</param>
/// <param name="useDistinct">是否保证记录唯一</param>
/// <param name="orderType">排序方式</param>
internal static SqlOrder InternalCreateFromAggregateFunction(SelectCommand cmd, SqlAggregateFunction function, String columnName, Boolean useDistinct, SqlOrderType orderType)
{
return(new SqlOrder(cmd, String.Empty, function, columnName, useDistinct, orderType));
}
public SqlOrder(string column, SqlOrderType type)
{
this.Column = column;
this.Type = type;
}
/// <summary>
/// 创建新的Sql语句排序类
/// </summary>
/// <param name="cmd">源选择语句</param>
/// <param name="function">函数内容</param>
/// <param name="orderType">排序方式</param>
internal static SqlOrder InternalCreateFromFunction(SelectCommand cmd, String function, SqlOrderType orderType)
{
return(new SqlOrder(cmd, function, orderType));
}
/// <summary>
/// 创建新的Sql语句排序类
/// </summary>
/// <param name="cmd">选择语句</param>
/// <param name="function">合计函数</param>
/// <param name="columnName">字段名称</param>
/// <param name="useDistinct">是否保证记录唯一</param>
/// <param name="orderType">排序方式</param>
internal static SqlOrder InternalCreateFromAggregateFunction(SelectCommand cmd, SqlAggregateFunction function, String columnName, Boolean useDistinct, SqlOrderType orderType)
{
return new SqlOrder(cmd, String.Empty, function, columnName, useDistinct, orderType);
}
/// <summary>
/// 初始化新的Sql语句排序类
/// </summary>
/// <param name="fieldName">字段名</param>
/// <param name="orderType">排序方式</param>
private SqlOrder(String fieldName, SqlOrderType orderType)
{
this._fieldName = fieldName;
this._orderType = orderType;
}
/// <summary>
/// 初始化新的Sql语句排序类
/// </summary>
/// <param name="fieldName">字段名</param>
/// <param name="orderType">排序方式</param>
public static SqlOrder Create(String fieldName, SqlOrderType orderType)
{
return new SqlOrder(fieldName, orderType);
}
public new Criteria <T> AddOrderColumn(string column, SqlOrderType type = SqlOrderType.ASC)
{
base.AddOrderColumn(column, type);
return(this);
}
public IFluentSqlQueryBuilder OrderBy(string columnName)
{
_orderType = SqlOrderType.Ascending;
_orderByColumn = columnName;
return(this);
}
private SqlSelect VisitOrderBy(Expression sequence, LambdaExpression expression, SqlOrderType orderType) {
if (IsGrouping(expression.Body.Type)) {
throw Error.GroupingNotSupportedAsOrderCriterion();
}
if (!this.typeProvider.From(expression.Body.Type).IsOrderable) {
throw Error.TypeCannotBeOrdered(expression.Body.Type);
}
SqlSelect select = this.LockSelect(this.VisitSequence(sequence));
if (select.Selection.NodeType != SqlNodeType.AliasRef || select.OrderBy.Count > 0) {
SqlAlias alias = new SqlAlias(select);
SqlAliasRef aref = new SqlAliasRef(alias);
select = new SqlSelect(aref, alias, this.dominatingExpression);
}
this.map[expression.Parameters[0]] = (SqlAliasRef)select.Selection;
SqlExpression expr = this.VisitExpression(expression.Body);
select.OrderBy.Add(new SqlOrderExpression(orderType, expr));
return select;
}
/// <summary>
/// 初始化新的Sql语句排序类
/// </summary>
/// <param name="baseCommand">选择语句</param>
/// <param name="columnName">字段名</param>
/// <param name="orderType">排序方式</param>
private SqlOrder(SelectCommand baseCommand, String columnName, SqlOrderType orderType)
{
this._columnName = columnName;
this._orderType = orderType;
}
// Methods
internal SqlOrderExpression(SqlOrderType type, SqlExpression expr)
{
this.OrderType = type;
this.Expression = expr;
}
/// <summary>
/// 创建新的Sql语句排序类
/// </summary>
/// <param name="cmd">选择语句</param>
/// <param name="tableName">表格名称</param>
/// <param name="function">合计函数</param>
/// <param name="columnName">字段名称</param>
/// <param name="orderType">排序方式</param>
internal static SqlOrder InternalCreateFromAggregateFunction(SelectCommand cmd, String tableName, SqlAggregateFunction function, String columnName, SqlOrderType orderType)
{
return new SqlOrder(cmd, tableName, function, columnName, false, orderType);
}
