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