private ExpressionToSql <T> JoinParser2 <T2, T3>(Expression <Func <T2, T3, bool> > expression, bool blnWithNoLock = false, string leftOrRightJoin = "")
{
if (expression == null)
{
throw new ArgumentNullException("expression", "Value cannot be null");
}
string joinTableName = typeof(T3).Name;
this._sqlBuilder.SetTableAlias(joinTableName);
string strAlias = this._sqlBuilder.QueueEnglishWords.Dequeue();
this._sqlBuilder.JoinTables.Add(strAlias, joinTableName);
if (_sqlBuilder.JoinTables.Count(t => t.Value.Equals(joinTableName)) > 1)
{
this._sqlBuilder.AppendFormat("\n{0}join {1} on", leftOrRightJoin, joinTableName + " " + strAlias);
}
else
{
this._sqlBuilder.AppendFormat("\n{0}join {1} on", leftOrRightJoin,
joinTableName + " " + this._sqlBuilder.GetTableAlias(joinTableName));
}
if (blnWithNoLock)
{
this._sqlBuilder.AppendFormat(" {0} ", AsNoLock());
}
Expression2SqlProvider.Join(expression.Body, this._sqlBuilder);
return(this);
}
private ExpressionToSql <T> SelectParser(Expression expression, Expression expressionBody, bool blnAsNoLock = false, params Type[] ary)
{
this.Clear();
this._sqlBuilder.IsSingleTable = false;
if (expressionBody != null && expressionBody.Type == typeof(T))
{
throw new ArgumentException("cannot be parse expression", "expression");
}
foreach (var item in ary)
{
string tableName = item.Name;
this._sqlBuilder.SetTableAlias(tableName);
}
string sql = "select {0}\nfrom " + this._mainTableName + " " + this._sqlBuilder.GetTableAlias(this._mainTableName);
if (blnAsNoLock)
{
sql += AsNoLock();
}
if (expression == null)
{
this._sqlBuilder.AppendFormat(sql, "*");
}
else
{
Expression2SqlProvider.Select(expressionBody, this._sqlBuilder);
this._sqlBuilder.AppendFormat(sql, this._sqlBuilder.SelectFieldsStr);
}
return(this);
}
protected override SqlBuilder OrderBy(NewExpression expression, SqlBuilder sqlBuilder)
{
foreach (Expression item in expression.Arguments)
{
Expression2SqlProvider.OrderBy(item, sqlBuilder);
}
return(sqlBuilder);
}
private static void Equals(MethodCallExpression expression, SqlBuilder sqlBuilder)
{
if (expression.Object != null)
{
Expression2SqlProvider.Where(expression.Object, sqlBuilder);
}
sqlBuilder += " =";
Expression2SqlProvider.Where(expression.Arguments[0], sqlBuilder);
}
private static void Contains(MethodCallExpression expression, SqlBuilder sqlBuilder)
{
if (expression.Object != null)
{
Expression2SqlProvider.Where(expression.Object, sqlBuilder);
}
sqlBuilder += " like '%'+";
Expression2SqlProvider.Where(expression.Arguments[0], sqlBuilder);
sqlBuilder += " +'%'";
}
public ExpressionToSql <T> First(Expression <Func <T, object> > expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression", "Value cannot be null");
}
Expression2SqlProvider.First(expression.Body, this._sqlBuilder);
return(this);
}
public ExpressionToSql <T> GroupBy(Expression <Func <T, object> > expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression", "Value cannot be null");
}
this._sqlBuilder += "\ngroup by ";
Expression2SqlProvider.GroupBy(expression.Body, this._sqlBuilder);
return(this);
}
private static void EndsWith(MethodCallExpression expression, SqlBuilder sqlBuilder)
{
if (expression.Object != null)
{
Expression2SqlProvider.Where(expression.Object, sqlBuilder);
}
sqlBuilder.AllowAppendEmpty = false;
sqlBuilder += " like '%' +";
Expression2SqlProvider.Where(expression.Arguments[0], sqlBuilder);
sqlBuilder.AllowAppendEmpty = true;
}
private static void LikeRight(MethodCallExpression expression, SqlBuilder sqlBuilder)
{
if (expression.Object != null)
{
Expression2SqlProvider.Where(expression.Object, sqlBuilder);
}
Expression2SqlProvider.Where(expression.Arguments[0], sqlBuilder);
sqlBuilder += " like ";
Expression2SqlProvider.Where(expression.Arguments[1], sqlBuilder);
sqlBuilder += " + '%'";
}
public ExpressionToSql <T> OrderByDesc(Expression <Func <T, object> > expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression", "Value cannot be null");
}
this._sqlBuilder += "\norder by ";
Expression2SqlProvider.OrderByDesc(expression.Body, this._sqlBuilder);
this._sqlBuilder += " desc ";
return(this);
}
public ExpressionToSql <T> Update(Expression <Func <object> > expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression", "Value cannot be null");
}
this.Clear();
this._sqlBuilder.IsSingleTable = true;
this._sqlBuilder.AppendFormat("update {0} set ", this._mainTableName);
Expression2SqlProvider.Update(expression.Body, this._sqlBuilder);
return(this);
}
protected override SqlBuilder Select(NewExpression expression, SqlBuilder sqlBuilder)
{
foreach (Expression item in expression.Arguments)
{
Expression2SqlProvider.Select(item, sqlBuilder);
}
foreach (MemberInfo item in expression.Members)
{
sqlBuilder.SelectFieldsAlias.Add(item.Name);
}
return(sqlBuilder);
}
public ExpressionToSql <T> Where(Expression <Func <T, bool> > expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression", "Value cannot be null");
}
if (expression.Body != null && expression.Body.NodeType == ExpressionType.Constant)
{
throw new ArgumentException("Cannot be parse expression", "expression");
}
this._sqlBuilder += "\nwhere";
Expression2SqlProvider.Where(expression.Body, this._sqlBuilder);
return(this);
}
protected override SqlBuilder In(NewArrayExpression expression, SqlBuilder sqlBuilder)
{
sqlBuilder += "(";
foreach (Expression expressionItem in expression.Expressions)
{
Expression2SqlProvider.In(expressionItem, sqlBuilder);
}
if (sqlBuilder[sqlBuilder.Length - 1] == ',')
{
sqlBuilder.Remove(sqlBuilder.Length - 1, 1);
}
sqlBuilder += ")";
return(sqlBuilder);
}
protected override SqlBuilder Join(BinaryExpression expression, SqlBuilder sqlBuilder)
{
Expression2SqlProvider.Join(expression.Left, sqlBuilder);
int operatorIndex = sqlBuilder.Length;
Expression2SqlProvider.Join(expression.Right, sqlBuilder);
int sqlLength = sqlBuilder.Length;
if (sqlLength - operatorIndex == 5 && sqlBuilder.Sql.EndsWith("null"))
{
OperatorParser(expression.NodeType, operatorIndex, sqlBuilder, true);
}
else
{
OperatorParser(expression.NodeType, operatorIndex, sqlBuilder);
}
return(sqlBuilder);
}
public ExpressionToSql <T> Count(Expression <Func <T, object> > expression = null)
{
this.Clear();
if (expression == null)
{
string tableName = typeof(T).Name;
this._sqlBuilder.SetTableAlias(tableName);
string tableAlias = this._sqlBuilder.GetTableAlias(tableName);
if (!string.IsNullOrWhiteSpace(tableAlias))
{
tableName += " " + tableAlias;
}
this._sqlBuilder.AppendFormat("select count(*) from {0}", tableName);
}
else
{
Expression2SqlProvider.Count(expression.Body, this._sqlBuilder);
}
return(this);
}
protected override SqlBuilder Where(BinaryExpression expression, SqlBuilder sqlBuilder)
{
if (IsNeedsParentheses(expression, expression.Left))
{
sqlBuilder += "(";
Expression2SqlProvider.Where(expression.Left, sqlBuilder);
sqlBuilder += ")";
}
else
{
Expression2SqlProvider.Where(expression.Left, sqlBuilder);
}
int signIndex = sqlBuilder.Length;
if (IsNeedsParentheses(expression, expression.Right))
{
sqlBuilder += "(";
Expression2SqlProvider.Where(expression.Right, sqlBuilder);
sqlBuilder += ")";
}
else
{
Expression2SqlProvider.Where(expression.Right, sqlBuilder);
}
int sqlLength = sqlBuilder.Length;
if (sqlLength - signIndex == 5 && sqlBuilder.ToString().EndsWith("null"))
{
OperatorParser(expression.NodeType, signIndex, sqlBuilder, true);
}
else
{
OperatorParser(expression.NodeType, signIndex, sqlBuilder);
}
return(sqlBuilder);
}
protected override SqlBuilder Where(UnaryExpression expression, SqlBuilder sqlBuilder)
{
Expression2SqlProvider.Where(expression.Operand, sqlBuilder);
return(sqlBuilder);
}
protected override SqlBuilder ThenByDesc(UnaryExpression expression, SqlBuilder sqlBuilder)
{
Expression2SqlProvider.ThenByDesc(expression.Operand, sqlBuilder);
return(sqlBuilder);
}
protected override SqlBuilder GroupBy(UnaryExpression expression, SqlBuilder sqlBuilder)
{
Expression2SqlProvider.GroupBy(expression.Operand, sqlBuilder);
return(sqlBuilder);
}
private static void InnerIn(MethodCallExpression expression, SqlBuilder sqlBuilder)
{
Expression2SqlProvider.Where(expression.Arguments[0], sqlBuilder);
sqlBuilder += " in";
Expression2SqlProvider.In(expression.Arguments[1], sqlBuilder);
}
protected override SqlBuilder Avg(ParameterExpression expression, SqlBuilder sqlBuilder)
{
Expression2SqlProvider.Avg(expression, sqlBuilder);
return(sqlBuilder);
}
