public Expression2SqlCore <T> Select <T2, T3, T4, T5, T6, T7, T8, T9, T10>(Expression <Func <T, T2, T3, T4, T5, T6, T7, T8, T9, T10, object> > expression = null)
{
PropertyInfoCache.InitCacheInfo <T2>();
PropertyInfoCache.InitCacheInfo <T3>();
PropertyInfoCache.InitCacheInfo <T4>();
PropertyInfoCache.InitCacheInfo <T5>();
PropertyInfoCache.InitCacheInfo <T6>();
PropertyInfoCache.InitCacheInfo <T7>();
PropertyInfoCache.InitCacheInfo <T8>();
PropertyInfoCache.InitCacheInfo <T9>();
PropertyInfoCache.InitCacheInfo <T10>();
string sql = SelectParser(typeof(T), typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8), typeof(T9), typeof(T10));
if (expression == null)
{
this._sqlPack.Sql.AppendFormat(sql, "*");
}
else
{
Expression2SqlProvider.Select(expression.Body, this._sqlPack);
this._sqlPack.Sql.AppendFormat(sql, this._sqlPack.SelectFieldsStr);
}
return(this);
}
private ExpressionToSql <T> SelectParser(Expression expression, Expression expressionBody, params Type[] ary)
{
this._sqlBuilder.Clear();
this._sqlBuilder.IsSingleTable = false;
foreach (var item in ary)
{
string tableName = item.Name;
this._sqlBuilder.SetTableAlias(tableName);
}
string sql = "select {0}\nfrom " + typeof(T).Name + " " + this._sqlBuilder.GetTableAlias(typeof(T).Name);
if (expression == null)
{
this._sqlBuilder.AppendFormat(sql, "*");
}
else
{
Expression2SqlProvider.Select(expressionBody, this._sqlBuilder);
this._sqlBuilder.AppendFormat(sql, this._sqlBuilder.SelectFieldsStr);
}
return(this);
}
private ExpressionToSql <T> SelectParser(Expression expression, Expression expressionBody, 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 (expression == null)
{
this._sqlBuilder.AppendFormat(sql, "*");
}
else
{
Expression2SqlProvider.Select(expressionBody, this._sqlBuilder);
this._sqlBuilder.AppendFormat(sql, this._sqlBuilder.SelectFieldsStr);
}
return(this);
}
public Expression2SqlCore <T> Sum(Expression <Func <T, object> > expression)
{
this._sqlPack.Clear();
this._sqlPack.IsSingleTable = true;
Expression2SqlProvider.Sum(expression.Body, this._sqlPack);
return(this);
}
public Expression2SqlCore <T> Update(Expression <Func <object> > expression = null)
{
this._sqlPack.Clear();
this._sqlPack.IsSingleTable = true;
this._sqlPack += "update " + ModelCache <T> ._TableName + " set ";
Expression2SqlProvider.Update(expression.Body, this._sqlPack);
return(this);
}
public ExpressionToSql <T> Insert(Expression <Func <object> > expression = null)
{
this._sqlBuilder.Clear();
this._sqlBuilder.IsSingleTable = true;
this._sqlBuilder += "insert into " + typeof(T).Name;
Expression2SqlProvider.Insert(expression.Body, this._sqlBuilder);
return(this);
}
protected override SqlPack OrderBy(NewExpression expression, SqlPack sqlPack)
{
foreach (Expression item in expression.Arguments)
{
Expression2SqlProvider.OrderBy(item, sqlPack);
}
return(sqlPack);
}
protected override SqlBuilder GroupBy(NewExpression expression, SqlBuilder sqlBuilder)
{
foreach (Expression item in expression.Arguments)
{
Expression2SqlProvider.GroupBy(item, sqlBuilder);
}
return(sqlBuilder);
}
public ExpressionToSql <T> Update(Expression <Func <object> > expression = null)
{
this._sqlBuilder.Clear();
this._sqlBuilder.IsSingleTable = true;
this._sqlBuilder += "update " + typeof(T).Name + " set ";
Expression2SqlProvider.Update(expression.Body, this._sqlBuilder);
return(this);
}
private Expression2SqlCore <T> JoinParser <T2>(Expression <Func <T, T2, bool> > expression, string leftOrRightJoin = "")
{
string joinTableName = typeof(T2).Name;
this._sqlPack.SetTableAlias(joinTableName);
this._sqlPack.Sql.AppendFormat("\n{0}join {1} on", leftOrRightJoin, joinTableName + " " + this._sqlPack.GetTableAlias(joinTableName));
Expression2SqlProvider.Join(expression.Body, this._sqlPack);
return(this);
}
private ExpressionToSql <T> JoinParser2 <T2, T3>(Expression <Func <T2, T3, bool> > expression, string leftOrRightJoin = "")
{
string joinTableName = typeof(T3).Name;
this._sqlBuilder.SetTableAlias(joinTableName);
this._sqlBuilder.AppendFormat("\n{0}join {1} on", leftOrRightJoin, joinTableName + " " + this._sqlBuilder.GetTableAlias(joinTableName));
Expression2SqlProvider.Join(expression.Body, this._sqlBuilder);
return(this);
}
private static void LikeLeft(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);
}
private static void LikeLeft(MethodCallExpression expression, SqlPack sqlPack)
{
if (expression.Object != null)
{
Expression2SqlProvider.Where(expression.Object, sqlPack);
}
Expression2SqlProvider.Where(expression.Arguments[0], sqlPack);
sqlPack += " LIKE '%' +";
Expression2SqlProvider.Where(expression.Arguments[1], sqlPack);
}
public ExpressionToSql <T> OrderBy(Expression <Func <T, object> > expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression", "Value cannot be null");
}
this._sqlBuilder += "\norder by ";
Expression2SqlProvider.OrderBy(expression.Body, this._sqlBuilder);
return(this);
}
public ExpressionToSql <T> Sum(Expression <Func <T, object> > expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression", "Value cannot be null");
}
this.Clear();
Expression2SqlProvider.Sum(expression.Body, this._sqlBuilder);
return(this);
}
private Expression2SqlCore <T> JoinParser2 <T2, T3>(Expression <Func <T2, T3, bool> > expression, string leftOrRightJoin = "")
{
PropertyInfoCache.InitCacheInfo <T2>();
PropertyInfoCache.InitCacheInfo <T3>();
string joinTableName = PropertyInfoCache.GetTableName(typeof(T3).FullName);// typeof(T3).Name;
this._sqlPack.SetTableAlias(joinTableName);
this._sqlPack.Sql.AppendFormat("\n{0}join {1} on", leftOrRightJoin, joinTableName + " " + this._sqlPack.GetTableAlias(joinTableName));
Expression2SqlProvider.Join(expression.Body, this._sqlPack);
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);
}
private ExpressionToSql <T> JoinParser2 <T2, T3>(Expression <Func <T2, T3, bool> > expression, string leftOrRightJoin = "")
{
if (expression == null)
{
throw new ArgumentNullException("expression", "Value cannot be null");
}
string joinTableName = typeof(T3).Name;
this._sqlBuilder.SetTableAlias(joinTableName);
this._sqlBuilder.AppendFormat("\n{0}join {1} on", leftOrRightJoin, joinTableName + " " + this._sqlBuilder.GetTableAlias(joinTableName));
Expression2SqlProvider.Join(expression.Body, this._sqlBuilder);
return(this);
}
public Expression2SqlCore <T> Count(Expression <Func <T, object> > expression = null)
{
this._sqlPack.Clear();
this._sqlPack.IsSingleTable = true;
if (expression == null)
{
this._sqlPack.Sql.AppendFormat("select count(*) from {0}", ModelCache <T> ._TableName);
}
else
{
Expression2SqlProvider.Count(expression.Body, this._sqlPack);
}
return(this);
}
public Expression2SqlCore <T> Select <T2, T3>(Expression <Func <T, T2, T3, object> > expression = null)
{
string sql = SelectParser(typeof(T), typeof(T2), typeof(T3));
if (expression == null)
{
this._sqlPack.Sql.AppendFormat(sql, "*");
}
else
{
Expression2SqlProvider.Select(expression.Body, this._sqlPack);
this._sqlPack.Sql.AppendFormat(sql, this._sqlPack.SelectFieldsStr);
}
return(this);
}
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 SqlPack In(NewArrayExpression expression, SqlPack sqlPack)
{
sqlPack += "(";
foreach (Expression expressionItem in expression.Expressions)
{
Expression2SqlProvider.In(expressionItem, sqlPack);
}
if (sqlPack.Sql[sqlPack.Sql.Length - 1] == ',')
{
sqlPack.Sql.Remove(sqlPack.Sql.Length - 1, 1);
}
sqlPack += ")";
return(sqlPack);
}
public Expression2SqlCore <T> Select(Expression <Func <T, object> > expression = null)
{
string sql = SelectParser(typeof(T));
if (expression == null)
{
//this._sqlPack.Sql.AppendFormat(sql, "*");
var fields = PropertyInfoCache.FieldNameAsPropertyName(typeof(T).FullName);
this._sqlPack.Sql.AppendFormat(sql, fields);
}
else
{
Expression2SqlProvider.Select(expression.Body, this._sqlPack);
this._sqlPack.Sql.AppendFormat(sql, this._sqlPack.SelectFieldsStr);
}
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 SqlPack Where(BinaryExpression expression, SqlPack sqlPack)
{
Expression2SqlProvider.Where(expression.Left, sqlPack);
int signIndex = sqlPack.Length;
Expression2SqlProvider.Where(expression.Right, sqlPack);
int sqlLength = sqlPack.Length;
if (sqlLength - signIndex == 5 && sqlPack.ToString().EndsWith("null", StringComparison.OrdinalIgnoreCase))
{
OperatorParser(expression.NodeType, signIndex, sqlPack, true);
}
else
{
OperatorParser(expression.NodeType, signIndex, sqlPack);
}
return(sqlPack);
}
protected override SqlPack Join(BinaryExpression expression, SqlPack sqlPack)
{
Expression2SqlProvider.Join(expression.Left, sqlPack);
int operatorIndex = sqlPack.Sql.Length;
Expression2SqlProvider.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);
}
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);
}
private static void InnerIn(MethodCallExpression expression, SqlBuilder sqlBuilder)
{
Expression2SqlProvider.Where(expression.Arguments[0], sqlBuilder);
sqlBuilder += " in";
Expression2SqlProvider.In(expression.Arguments[1], sqlBuilder);
}
