public OrderExpression <T> ThenByDescending <T2>(Expression <Func <T2, object> > expression)
{
SqlPack += " ,";
FluentExpressionSQLProvider.OrderBy(expression.Body, SqlPack);
SqlPack += " DESC";
return(this);
}
public OrderExpression <T> ThenBy(Expression <Func <T, object> > expression)
{
SqlPack += " ,";
FluentExpressionSQLProvider.OrderBy(expression.Body, SqlPack);
return(this);
}
protected override SqlPack Having(BinaryExpression expression, SqlPack sqlPack)
{
if (HasBeginInOwnLogic(expression, sqlPack))
{
sqlPack += " (";
}
FluentExpressionSQLProvider.Where(expression.Left, sqlPack);
int signIndex = sqlPack.Length;
FluentExpressionSQLProvider.Where(expression.Right, sqlPack);
int sqlLength = sqlPack.Length;
if (sqlLength - signIndex == 5 && sqlPack.ToString().EndsWith("null"))
{
OperatorParser(expression.NodeType, signIndex, sqlPack, true);
}
else
{
OperatorParser(expression.NodeType, signIndex, sqlPack);
}
if (HasEndInOwnLogic(expression, sqlPack))
{
sqlPack += ")";
}
return(sqlPack);
}
protected override SqlPack OrderBy(NewExpression expression, SqlPack sqlPack)
{
foreach (Expression item in expression.Arguments)
{
FluentExpressionSQLProvider.OrderBy(item, sqlPack);
}
return(sqlPack);
}
public GroupByExpression <T> Having <T2>(Expression <Func <T2, bool> > expression)
{
SqlPack += " HAVING ";
SqlPack.CurrentWhereExpression = expression.Body;
FluentExpressionSQLProvider.Having(expression.Body, SqlPack);
return(this);
}
private static void Contains(MethodCallExpression expression, SqlPack sqlPack)
{
MethodInfo method = expression.Method;
if (method.DeclaringType == typeof(String) || method.DeclaringType == typeof(string))
{
if (expression.Object != null)
{
FluentExpressionSQLProvider.Where(expression.Object, sqlPack);
}
string result = "";
var column = expression.Arguments[0].GetValueOrColumnName(sqlPack);
result = sqlPack.SqlDialectProvider.ConvertDbFunction(DbFunctionType.Contains, column);
sqlPack += " LIKE ";
sqlPack.CurrentDbFunctionResult = result;
}
else
{
var declaringType = method.DeclaringType;
// typeof(IList).IsAssignableFrom(declaringType) || typeof(IEnumerable).IsAssignableFrom(declaringType) || (declaringType.IsGenericType && typeof(ICollection<>).MakeGenericType(declaringType.GetGenericArguments()).IsAssignableFrom(declaringType))
if (declaringType.IsListType())
{
var memberExp = expression.Object;
FluentExpressionSQLProvider.Where(expression.Arguments[0], sqlPack);
sqlPack += " IN ";
FluentExpressionSQLProvider.In(memberExp, sqlPack);
}
else if (method.IsStatic && declaringType == typeof(System.Linq.Enumerable) && expression.Arguments.Count == 2)
{
FluentExpressionSQLProvider.Where(expression.Arguments[1], sqlPack);
sqlPack += " IN ";
FluentExpressionSQLProvider.In(expression.Arguments[0], sqlPack);
}
}
//sqlPack += " LIKE '%' +";
//FluentExpressionSQLProvider.Where(expression.Arguments[0], sqlPack);
//sqlPack += " + '%'";
}
private static void LikeLeftNot(MethodCallExpression expression, SqlPack sqlPack)
{
if (expression.Object != null)
{
FluentExpressionSQLProvider.Where(expression.Object, sqlPack);
}
FluentExpressionSQLProvider.Where(expression.Arguments[0], sqlPack);
//sqlPack += " LIKE '%' +";
//FluentExpressionSQLProvider.Where(expression.Arguments[1], sqlPack);
string result = "";
var column = expression.Arguments[1].GetValueOrColumnName(sqlPack);
result = sqlPack.SqlDialectProvider.ConvertDbFunction(DbFunctionType.LikeLeft, column);
sqlPack += " NOT LIKE ";
sqlPack.CurrentDbFunctionResult = result;
}
protected override SqlPack Join(BinaryExpression expression, SqlPack sqlPack)
{
FluentExpressionSQLProvider.Join(expression.Left, sqlPack);
int operatorIndex = sqlPack.Sql.Length;
FluentExpressionSQLProvider.Join(expression.Right, sqlPack);
int sqlLength = sqlPack.Sql.Length;
if (sqlLength - operatorIndex == 5 && sqlPack.ToString().EndsWith("null"))
{
OperatorParser(expression.NodeType, operatorIndex, sqlPack, true);
}
else
{
OperatorParser(expression.NodeType, operatorIndex, sqlPack);
}
return(sqlPack);
}
private void AppendSql(Expression exp, SqlPack sqlPack)
{
var expression = exp as BinaryExpression;
FluentExpressionSQLProvider.Where(expression.Left, sqlPack);
int signIndex = sqlPack.Length;
FluentExpressionSQLProvider.Where(expression.Right, sqlPack);
int sqlLength = sqlPack.Length;
if (sqlLength - signIndex == 5 && sqlPack.ToString().EndsWith("null", StringComparison.InvariantCultureIgnoreCase))
{
OperatorParser(expression.NodeType, signIndex, sqlPack, true);
}
else
{
OperatorParser(expression.NodeType, signIndex, sqlPack);
}
}
private static void StartsWith(MethodCallExpression expression, SqlPack sqlPack)
{
if (expression.Object != null)
{
FluentExpressionSQLProvider.Where(expression.Object, sqlPack);
}
string result = "";
var column = expression.Arguments[0].GetValueOrColumnName(sqlPack);
result = sqlPack.SqlDialectProvider.ConvertDbFunction(DbFunctionType.StartsWith, column);
sqlPack += " LIKE ";
sqlPack.CurrentDbFunctionResult = result;
//sqlPack += " LIKE ";
//FluentExpressionSQLProvider.Where(expression.Arguments[0], sqlPack);
//sqlPack += " + '%'";
}
protected override SqlPack Sum(UnaryExpression expression, SqlPack sqlPack)
{
FluentExpressionSQLProvider.Sum(expression.Operand, sqlPack);
return(sqlPack);
}
protected override SqlPack Select(NewExpression expression, SqlPack sqlPack)
{
//foreach (Expression item in expression.Arguments)
//{
// FluentExpressionSQLProvider.Select(item, sqlPack);
//}
var memberAliasExpList = expression.Members;
string tableAlias = "";
string colStr = "";
int i = 0;
foreach (Expression item in expression.Arguments)
{
var memberAliasExp = memberAliasExpList[i];
if (item is MemberExpression)
{
MemberExpression memberValueExp = item as MemberExpression;
if (memberValueExp != null)
{
if (memberValueExp.Member.DeclaringType == ResolveConstants.TypeOfDateTime)//日期转换
{
var value = memberValueExp.Expression.GetValueOfExpression(sqlPack);
var valueDatetime = sqlPack.SqlDialectProvider.ConvertDateTime(memberValueExp.Member, value);
if (memberAliasExp.Name.Equals(memberValueExp.Member.Name, System.StringComparison.InvariantCultureIgnoreCase))
{
colStr = valueDatetime.Text;
}
else
{
colStr = valueDatetime.Text + " " + sqlPack.ColumnAsAliasString + memberAliasExp.Name;
}
}
else if (memberValueExp.Member.Name == "Length" && memberValueExp.Member.DeclaringType == ResolveConstants.TypeOfString)//长度转换
{
MemberExpression memberEx = memberValueExp.Expression as MemberExpression;
string tableName = memberEx.GetTableNameByExpression(sqlPack);
sqlPack.SetTableAlias(tableName);
tableAlias = sqlPack.GetTableAlias(tableName);
if (!string.IsNullOrWhiteSpace(tableAlias))
{
tableAlias += ".";
}
string param = tableAlias + memberEx.Member.Name;
colStr = sqlPack.SqlDialectProvider.ConvertDbFunction(DbFunctionType.Length, param);
if (memberAliasExp.Name.Equals(memberEx.Member.Name, System.StringComparison.InvariantCultureIgnoreCase))
{
//colStr = tableAlias + memberEx.Member.Name;
}
else
{
colStr += " " + sqlPack.ColumnAsAliasString + " " + memberAliasExp.Name;
}
}
else if (memberValueExp.Member.MemberType == MemberTypes.Field) //局部变量
{
var value = memberValueExp.Expression.GetValueOfExpression(sqlPack);
var memberInfoType = memberValueExp.Member.GetPropertyOrFieldType();
var memberInfoValue = memberValueExp.Member.GetPropertyOrFieldValue(value);
memberInfoValue = sqlPack.SqlDialectProvider.FormatValue(memberInfoValue, true);//format
if (memberInfoType == ResolveConstants.TypeOfDateTime)
{
colStr = sqlPack.SqlDialectProvider.ConvertSqlValue(memberInfoValue, memberInfoType);
}
else
{
colStr = memberInfoValue.ToString();
}
if (!string.IsNullOrEmpty(memberAliasExp.Name) && !string.IsNullOrEmpty(colStr))
{
colStr += " " + sqlPack.ColumnAsAliasString + " " + memberAliasExp.Name;
}
}
else
{
string tableName = memberValueExp.GetTableNameByExpression(sqlPack);
sqlPack.SetTableAlias(tableName); //memberValueExp.Member.DeclaringType.Name
tableAlias = sqlPack.GetTableAlias(tableName); //memberValueExp.Member.DeclaringType.Name
if (!string.IsNullOrWhiteSpace(tableAlias))
{
tableAlias += ".";
}
if (memberAliasExp.Name.Equals(memberValueExp.Member.Name, System.StringComparison.InvariantCultureIgnoreCase))
{
colStr = tableAlias + memberValueExp.Member.Name;
}
else
{
colStr = tableAlias + memberValueExp.Member.Name + " " + sqlPack.ColumnAsAliasString + " " + memberAliasExp.Name;
}
}
sqlPack.SelectFields.Add(colStr);
}
}
else
{
sqlPack.CurrentColAlias = memberAliasExp.Name;
FluentExpressionSQLProvider.Select(item, sqlPack);
sqlPack.CurrentColAlias = null;
}
i++;
}
return(sqlPack);
}
private static void InNot(MethodCallExpression expression, SqlPack sqlPack)
{
FluentExpressionSQLProvider.Where(expression.Arguments[0], sqlPack);
sqlPack += " NOT IN ";
FluentExpressionSQLProvider.In(expression.Arguments[1], sqlPack);
}
public GroupByExpression <T> ThenGroupBy <T2>(Expression <Func <T2, object> > expression)
{
SqlPack += " ,";
FluentExpressionSQLProvider.GroupBy(expression.Body, SqlPack);
return(this);
}
protected override SqlPack Where(BinaryExpression expression, SqlPack sqlPack)
{
int signIndex = 0, sqlLength = 0;
if (expression.NodeType == ExpressionType.AndAlso)
{
// true && a.ID == 1 或者 a.ID == 1 && true
Expression left = expression.Left, right = expression.Right;
ConstantExpression c = right as ConstantExpression;
// DbExpression dbExp = null;
//a.ID == 1 && true
if (c != null)
{
if ((bool)c.Value == true)
{
// (a.ID==1)==true
//dbExp = new DbEqualExpression(this.Visit(exp.Left), new DbConstantExpression(true));
//dbExp = this.Visit(Expression.Equal(exp.Left, UtilConstants.Constant_True));
FluentExpressionSQLProvider.Where(expression.Left, sqlPack);
signIndex = sqlPack.Length;
sqlPack += " " + TrueLiteral;
sqlLength = sqlPack.Length;
if (sqlLength - signIndex == 5 && sqlPack.ToString().EndsWith("null"))
{
OperatorParser(expression.NodeType, signIndex, sqlPack, true);
}
else
{
OperatorParser(expression.NodeType, signIndex, sqlPack);
}
return(sqlPack);
}
else
{
sqlPack += " " + FalseLiteral;
return(sqlPack);
//dbExp = DbEqualExpression.False;
// return dbExp;
}
}
c = left as ConstantExpression;
// true && a.ID == 1
if (c != null)
{
if ((bool)c.Value == true)
{
// (a.ID==1)==true
sqlPack += " " + TrueLiteral;
signIndex = sqlPack.Length;
FluentExpressionSQLProvider.Where(expression.Right, sqlPack);
sqlLength = sqlPack.Length;
if (sqlLength - signIndex == 5 && sqlPack.ToString().EndsWith("null"))
{
OperatorParser(expression.NodeType, signIndex, sqlPack, true);
}
else
{
OperatorParser(expression.NodeType, signIndex, sqlPack);
}
return(sqlPack);
//dbExp = this.Visit(Expression.Equal(exp.Right, UtilConstants.Constant_True));
//return dbExp;
}
else
{
// 直接 (1=0)
sqlPack += " " + FalseLiteral;
return(sqlPack);
//dbExp = DbEqualExpression.False;
// return dbExp;
}
}
}
else if (expression.NodeType == ExpressionType.OrElse)
{
// true && a.ID == 1 或者 a.ID == 1 && true
Expression left = expression.Left, right = expression.Right;
ConstantExpression c = right as ConstantExpression;
//DbExpression dbExp = null;
//a.ID == 1 || true
if (c != null)
{
if ((bool)c.Value == false)
{
// (a.ID==1)==true
FluentExpressionSQLProvider.Where(expression.Left, sqlPack);
signIndex = sqlPack.Length;
sqlPack += " " + FalseLiteral;
sqlLength = sqlPack.Length;
if (sqlLength - signIndex == 5 && sqlPack.ToString().EndsWith("null"))
{
OperatorParser(expression.NodeType, signIndex, sqlPack, true);
}
else
{
OperatorParser(expression.NodeType, signIndex, sqlPack);
}
return(sqlPack);
//dbExp = this.Visit(Expression.Equal(exp.Left, UtilConstants.Constant_True));
//return dbExp;
}
else
{
sqlPack += " " + TrueLiteral;
return(sqlPack);
// dbExp = DbEqualExpression.True;
// return dbExp;
}
}
c = left as ConstantExpression;
// true || a.ID == 1
if (c != null)
{
if ((bool)c.Value == false)
{
// (a.ID==1)==true
sqlPack += " " + FalseLiteral;
signIndex = sqlPack.Length;
FluentExpressionSQLProvider.Where(expression.Right, sqlPack);
sqlLength = sqlPack.Length;
if (sqlLength - signIndex == 5 && sqlPack.ToString().EndsWith("null"))
{
OperatorParser(expression.NodeType, signIndex, sqlPack, true);
}
else
{
OperatorParser(expression.NodeType, signIndex, sqlPack);
}
return(sqlPack);
//dbExp = this.Visit(Expression.Equal(exp.Right, UtilConstants.Constant_True));
//return dbExp;
}
else
{
// 直接 (1=1)
sqlPack += " " + TrueLiteral;
return(sqlPack);
//dbExp = DbEqualExpression.True;
//return dbExp;
}
}
}
if (HasBeginInOwnLogic(expression, sqlPack))
{
sqlPack += " (";
}
//sqlPack.WhereConditionIndex = sqlPack.WhereConditionIndex + 1;
FluentExpressionSQLProvider.Where(expression.Left, sqlPack);
signIndex = sqlPack.Length;
FluentExpressionSQLProvider.Where(expression.Right, sqlPack);
sqlLength = sqlPack.Length;
if (sqlLength - signIndex == 5 && sqlPack.ToString().EndsWith("null"))
{
OperatorParser(expression.NodeType, signIndex, sqlPack, true);
}
else
{
OperatorParser(expression.NodeType, signIndex, sqlPack);
}
if (HasEndInOwnLogic(expression, sqlPack))
{
sqlPack += ")";
}
return(sqlPack);
}
