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); }