/// <summary>
/// Min
/// </summary>
/// <param name="expression">表达式树</param>
/// <param name="sqlWrapper">sql打包对象</param>
private static void SqlMin(MethodCallExpression expression, SqlWrapper sqlWrapper)
{
if (expression.Arguments?.Count > 0)
{
sqlWrapper += "MIN(";
SqlExpressionProvider.Having(expression.Arguments[0], sqlWrapper);
sqlWrapper += ")";
}
}
/// <summary>
/// Having
/// </summary>
/// <param name="expression">表达式树</param>
/// <param name="sqlWrapper">sql包装器</param>
/// <returns>SqlWrapper</returns>
public override SqlWrapper Having(UnaryExpression expression, SqlWrapper sqlWrapper)
{
var startIndex = sqlWrapper.Length;
if (new[] { ExpressionType.ArrayLength, ExpressionType.ArrayIndex }.Contains(expression.NodeType))
{
sqlWrapper.AddDbParameter(expression.ToObject());
}
else
{
SqlExpressionProvider.Having(expression.Operand, sqlWrapper);
//取非解析
ExpressionNotResolver(expression, sqlWrapper, startIndex);
}
return(sqlWrapper);
}
/// <summary>
/// Expression嵌套解析
/// </summary>
/// <param name="expression">表达式树</param>
/// <param name="sqlWrapper">sql包装器</param>
/// <param name="method">方法名，可选值：Join、Having、Where</param>
public static int ExpressionNestedResolver(BinaryExpression expression, SqlWrapper sqlWrapper, string method)
{
//左侧嵌套
var lExpr = expression.Left as BinaryExpression;
var llIsBinaryExpr = lExpr?.Left is BinaryExpression;
var llIsBoolMethod = typeof(bool) == (lExpr?.Left as MethodCallExpression)?.Method.ReturnType;
var lrIsBinaryExpr = lExpr?.Right is BinaryExpression;
var lrIsBoolMethod = typeof(bool) == (lExpr?.Right as MethodCallExpression)?.Method.ReturnType;
var lNested = (llIsBinaryExpr || llIsBoolMethod) && (lrIsBinaryExpr || lrIsBoolMethod);
if (lNested)
{
sqlWrapper.Append("(");
}
if (method.EqualIgnoreCase(nameof(Join)))
{
SqlExpressionProvider.Join(expression.Left, sqlWrapper);
}
else if (method.EqualIgnoreCase(nameof(Having)))
{
SqlExpressionProvider.Having(expression.Left, sqlWrapper);
}
else
{
SqlExpressionProvider.Where(expression.Left, sqlWrapper);
}
if (lNested)
{
sqlWrapper.Append(")");
}
var operatorIndex = sqlWrapper.Length;
//右侧嵌套
var rExpr = expression.Right as BinaryExpression;
var rlIsBinaryExpr = rExpr?.Left is BinaryExpression;
var rlIsBoolMethod = typeof(bool) == (rExpr?.Left as MethodCallExpression)?.Method.ReturnType;
var rrIsBinaryExpr = rExpr?.Right is BinaryExpression;
var rrIsBoolMethod = typeof(bool) == (rExpr?.Right as MethodCallExpression)?.Method.ReturnType;
var rNested = (rlIsBinaryExpr || rlIsBoolMethod) && (rrIsBinaryExpr || rrIsBoolMethod);
if (rNested)
{
sqlWrapper.Append("(");
}
if (method.EqualIgnoreCase(nameof(Having)))
{
SqlExpressionProvider.Having(expression.Right, sqlWrapper);
}
else
{
SqlExpressionProvider.Where(expression.Right, sqlWrapper);
}
if (rNested)
{
sqlWrapper.Append(")");
}
return(operatorIndex);
}
/// <summary>
/// Having
/// </summary>
/// <param name="expression">表达式树</param>
/// <param name="sqlWrapper">sql打包对象</param>
/// <returns>SqlWrapper</returns>
public override SqlWrapper Having(LambdaExpression expression, SqlWrapper sqlWrapper)
{
SqlExpressionProvider.Having(expression.Body, sqlWrapper);
return(sqlWrapper);
}
/// <summary>
/// Having
/// </summary>
/// <param name="expression">表达式树</param>
/// <param name="sqlWrapper">sql打包对象</param>
/// <returns>SqlWrapper</returns>
public override SqlWrapper Having(UnaryExpression expression, SqlWrapper sqlWrapper)
{
SqlExpressionProvider.Having(expression.Operand, sqlWrapper);
return(sqlWrapper);
}
