/// <summary>
/// 别名处理
/// </summary>
/// <param name="tableAlias">表别名</param>
/// <returns>别名</returns>
private string AtkTableAlias(AtkAlias tableAlias)
{
if (tableAlias == AtkAlias.a99_empty)
{
return(string.Empty);
}
else
{
return("[" + tableAlias.ToString() + "].");
}
}
/// <summary>
/// 设置where语句
/// </summary>
/// <param name="atkExp">表达式</param>
/// <param name="atkUion">操作方法</param>
/// <param name="tableAlias">表别名</param>
private void SetWhere(System.Linq.Expressions.Expression atkExp, AtkExpUnion atkUion = AtkExpUnion.And, AtkAlias tableAlias = AtkAlias.a0)
{
var itemstr = AtkExpressionWriterSql.AtkWhereWriteToString(atkExp, AtkExpSqlType.atkWhere, tableAlias.ToString());
if (string.IsNullOrWhiteSpace(_atkWhereStr))
{
_atkWhereStr = itemstr;
}
else
{
if (atkUion == AtkExpUnion.Or)
{
_atkWhereStr = _atkWhereStr + " Or " + itemstr;
}
else
{
_atkWhereStr = _atkWhereStr + " And " + itemstr;
}
}
}
/// <summary>
/// 排序
/// </summary>
/// <param name="atkExp">表达式</param>
/// <param name="atkAsc">正序</param>
/// <param name="tableAlias">别名</param>
private void SetOrderBy(System.Linq.Expressions.Expression atkExp, bool atkAsc, AtkAlias tableAlias)
{
var itemstr = AtkExpressionWriterSql.AtkWhereWriteToString(atkExp, AtkExpSqlType.atkOrder, tableAlias.ToString());
if (!atkAsc)
{
itemstr = itemstr + " Desc";
}
if (string.IsNullOrWhiteSpace(_atkOrderByStr))
{
_atkOrderByStr = itemstr;
}
else
{
_atkOrderByStr = _atkOrderByStr + "," + itemstr;
}
}
private int _pageRows = 0; //每页行数
/// <summary>
/// 设置表达式条件
/// </summary>
/// <param name="atkExp">表达式</param>
/// <param name="atkUion">操作方法</param>
/// <param name="tableAlias">别名</param>
private void SetConditionStr(System.Linq.Expressions.Expression atkExp, AtkExpUnion atkUion = AtkExpUnion.And, AtkAlias tableAlias = AtkAlias.a0)
{
SetWhere(atkExp, atkUion, tableAlias);//Where条件句
SetOrderBy(atkExp, false, tableAlias);//Order by 语句
}
/// <summary>
/// 表达式中，生成更新表字段的方法
/// 当更只更新记录中部分记录时，可使用此方法
/// <para>atkexp.UpdateFields(s => new { s.Afield, s.Bfield }, AtkAlias.a2);</para>
/// </summary>
/// <typeparam name="F">多字段的一个New对象</typeparam>
/// <param name="atkFieldSelect">要更新的字段</param>
/// <param name="tableAlias">表的别名</param>
/// <returns>更改后的表达式</returns>
public AtkExpConditions <T> UpdateFields <F>(Expression <Func <T, F> > atkFieldSelect, AtkAlias tableAlias = AtkAlias.a0)
{
var fieldSelects = Reflect <T> .GetPropertys <F>(atkFieldSelect);
foreach (var fieldSelect in fieldSelects)
{
_atkUpdateListField.Add(AtkTableAlias(tableAlias) + "[" + fieldSelect.Name + "]", fieldSelect.Name);
}
return(this);
}
/// <summary>
/// 如果条件满足时,将添加前一个OrderBy语句，否则添加后一个
/// </summary>
/// <typeparam name="D">OrderBy的数据字段类型</typeparam>
/// <param name="atkCondition">Lambda条件</param>
/// <param name="atkExpWhenTrue">条件为真时</param>
/// <param name="atkExpWhenFalse">条件为假时</param>
/// <param name="atkAsc">排序方式</param>
/// <param name="tableAlias">表的别名</param>
/// <returns>更改后的表达式</returns>
public AtkExpConditions <T> AddOrderBy <D>(Func <bool> atkCondition, Expression <Func <T, D> > atkExpWhenTrue, Expression <Func <T, D> > atkExpWhenFalse,
bool atkAsc = true, AtkAlias tableAlias = AtkAlias.a0)
{
return(AddOrderBy <D>(atkCondition(), atkExpWhenTrue, atkExpWhenFalse, atkAsc, tableAlias));
}
/// <summary>
/// 如果条件满足时,将添加前一个OrderBy语句，否则添加后一个
/// </summary>
/// <typeparam name="D">OrderBy的数据字段类型</typeparam>
/// <param name="atkCondition">条件</param>
/// <param name="atkExpWhenTrue">条件为真时</param>
/// <param name="atkExpWhenFalse">条件为假时</param>
/// <param name="atkAsc">排序方式</param>
/// <param name="tableAlias">表的别名</param>
/// <returns>更改后的表达式</returns>
public AtkExpConditions <T> AddOrderBy <D>(bool atkCondition, Expression <Func <T, D> > atkExpWhenTrue, Expression <Func <T, D> > atkExpWhenFalse, bool atkAsc = true, AtkAlias tableAlias = AtkAlias.a0)
{
if (atkCondition)
{
SetOrderBy(atkExpWhenTrue, atkAsc, tableAlias);
}
else
{
SetOrderBy(atkExpWhenFalse, atkAsc, tableAlias);
}
return(this);
}
/// <summary>
/// 如果条件满足时,添加一个OrderBy语句
/// </summary>
/// <typeparam name="D">OrderBy的数据字段类型</typeparam>
/// <param name="atkCondition">Lambda条件</param>
/// <param name="atkExp">OrderBy条件表达式</param>
/// <param name="tableAlias">表的别名</param>
/// <returns>更改后的表达式</returns>
public AtkExpConditions <T> AddOrderBy <D>(Func <bool> atkCondition, Expression <Func <T, D> > atkExp, AtkAlias tableAlias = AtkAlias.a0)
{
AddOrderBy <D>(atkCondition(), atkExp, true, tableAlias);
return(this);
}
/// <summary>
/// 添加一个OrderBy语句
/// </summary>
/// <typeparam name="D">OrderBy的字段数据类型</typeparam>
/// <param name="atkExp">OrderBy条件表达式</param>
/// <param name="atkAsc">排序方式</param>
/// <param name="tableAlias">表的别名</param>
/// <returns>更改后的表达式</returns>
public AtkExpConditions <T> AddOrderBy <D>(Expression <Func <T, D> > atkExp, bool atkAsc = true, AtkAlias tableAlias = AtkAlias.a0)
{
SetOrderBy(atkExp, atkAsc, tableAlias);
return(this);
}
/// <summary>
/// 增加多条件 in 的操作方法
/// <example>
/// SELECT DishesID, DishesName, DishesUnit
/// FROM dbo.Aidb_DishesItems As [a0]
/// Where DishesTypeID in (1,2,3,6)
/// 中的 “iin (1,2,3,6）”就是本属性可以的一种形式
/// </example>
/// </summary>
/// <typeparam name="F">字段的类型</typeparam>
/// <param name="atkFieldSelect">要查询的字段（DishesTypeID）</param>
/// <param name="inConditon">要查询的值（DishesTypeID的可能值）</param>
/// <param name="tableAlias">表的别名</param>
/// <returns>条件 in 的操作方法</returns>
public AtkExpConditions <T> AddMutiInWhere <F>(Expression <Func <T, F> > atkFieldSelect, IList <int> inConditon, AtkAlias tableAlias = AtkAlias.a0)
{
if (inConditon.Count == 0)
{
return(this);
}
var fieldSelect = AtkTableAlias(tableAlias) + Reflect <T> .GetProperty <F>(atkFieldSelect).Name;
string atkincdt = string.Empty;
foreach (var item in inConditon)
{
if (string.IsNullOrWhiteSpace(atkincdt))
{
atkincdt = item.ToString();
}
else
{
atkincdt = atkincdt + "," + item.ToString();
}
}
if (!string.IsNullOrWhiteSpace(atkincdt))
{
SetWhere(fieldSelect + " in (" + atkincdt + ")");
}
return(this);
}
/// <summary>
/// 如果条件满足时,将添加前一个条件语句（Where），否则添加后一个,以 Or 相联接
/// </summary>
/// <param name="atkCondition">Lambda条件</param>
/// <param name="atkExpWhenTrue">条件为真时</param>
/// <param name="atkExpWhenFalse">条件为假时</param>
/// <param name="tableAlias">表别名</param>
/// <returns>更改后的表达式</returns>
public AtkExpConditions <T> AddOrWhere(Func <bool> atkCondition, Expression <Func <T, bool> > atkExpWhenTrue, Expression <Func <T, bool> > atkExpWhenFalse, AtkAlias tableAlias = AtkAlias.a0)
{
return(AddOrWhere(atkCondition(), atkExpWhenTrue, atkExpWhenFalse));
}
/// <summary>
/// 如果条件满足时,将添加前一个条件语句（Where），否则添加后一个,以 Or 相联接
/// </summary>
/// <param name="atkCondition">条件</param>
/// <param name="atkExpWhenTrue">条件为真时</param>
/// <param name="atkExpWhenFalse">条件为假时</param>
/// <param name="tableAlias">表别名</param>
/// <returns>更改后的表达式</returns>
public AtkExpConditions <T> AddOrWhere(bool atkCondition, Expression <Func <T, bool> > atkExpWhenTrue, Expression <Func <T, bool> > atkExpWhenFalse, AtkAlias tableAlias = AtkAlias.a0)
{
if (atkCondition)
{
SetWhere(atkExpWhenTrue, AtkExpUnion.Or, tableAlias);
}
else
{
SetWhere(atkExpWhenFalse, AtkExpUnion.Or, tableAlias);
}
return(this);
}
/// <summary>
/// 添加一个Where条件语句，如果语句存在，则以 Or 相联接
/// </summary>
/// <param name="atkExp">Where条件表达式</param>
/// <param name="tableAlias">表别名</param>
/// <returns>更改后的表达式</returns>
public AtkExpConditions <T> AddOrWhere(Expression <Func <T, bool> > atkExp, AtkAlias tableAlias = AtkAlias.a0)
{
SetWhere(atkExp, AtkExpUnion.Or, tableAlias);
return(this);
}
/// <summary>
/// 当给定lambda表达式条件满足时,添加一个Where条件语句，如果语句存在，则以 And 相联接
/// </summary>
/// <param name="atkCondition">给定lambda表达式条件</param>
/// <param name="atkExp">条件表达式</param>
/// <param name="tableAlias">表别名</param>
/// <returns>更改后的表达式</returns>
public AtkExpConditions <T> AddAndWhere(Func <bool> atkCondition, Expression <Func <T, bool> > atkExp, AtkAlias tableAlias = AtkAlias.a0)
{
return(AddAndWhere(atkCondition(), atkExp, tableAlias));
}
/// <summary>
/// 当给定条件满足时,添加一个Where条件语句，如果语句存在，则以 And 相联接
/// </summary>
/// <param name="atkCondition">给定条件</param>
/// <param name="atkExp">Where条件表达式</param>
/// <param name="tableAlias">表别名</param>
/// <returns>更改后的表达式</returns>
public AtkExpConditions <T> AddAndWhere(bool atkCondition, Expression <Func <T, bool> > atkExp, AtkAlias tableAlias = AtkAlias.a0)
{
if (atkCondition)
{
SetWhere(atkExp, AtkExpUnion.And, tableAlias);
}
return(this);
}
