public int Execute(Type elementType, IDictionary <MemberExpression, object> properties, Expression predicate)
        {
            SqlServerUpdateCommandBuilder updateBuilder = new SqlServerUpdateCommandBuilder(elementType.Name);

            foreach (var item in properties)
            {
                updateBuilder.AddColumn(item.Key.Member.Name, item.Value);
            }

            if (predicate != null)
            {
                SqlServerWherePartsCommandBuilder whereBuider = new SqlServerWherePartsCommandBuilder(updateBuilder.Parameters);

                Expression expression = PartialEvaluatingExpressionTreeVisitor.EvaluateIndependentSubtrees(predicate);

                SqlServerWhereClauseVisitor visitor = new SqlServerWhereClauseVisitor();

                visitor.Translate(expression, whereBuider);

                updateBuilder.WhereParts = whereBuider.WherePartsBuilder.ToString();
            }

            this.sessionProvider.ExecutedCommandBuilder = updateBuilder;

            return(this.sessionProvider.ExecuteNonQuery(updateBuilder));
        }
        /// <summary>
        /// 设置 where 过滤条件
        /// </summary>
        /// <param name="func"></param>
        /// <returns></returns>
        public IDeleteable <T> Where(Expression <Func <T, bool> > func)
        {
            Expression expression = PartialEvaluatingExpressionTreeVisitor.EvaluateIndependentSubtrees(func);

            SqlServerWhereClauseVisitor visitor = new SqlServerWhereClauseVisitor(this.parameters);

            string whereSqlParts = visitor.Translate(expression);

            if (this.deletePartsAggregator.Where.Length == 0)
            {
                this.deletePartsAggregator.Where.AppendFormat(" ( {0} )", whereSqlParts);
            }
            else
            {
                this.deletePartsAggregator.Where.AppendFormat(" AND ( {0} )", whereSqlParts);
            }

            return(this);
        }
        public int Execute(Type elementType, Expression predicate)
        {
            SqlServerDeleteCommandBuilder deleteBuilder = new SqlServerDeleteCommandBuilder(elementType.Name);

            if (predicate != null)
            {
                SqlServerWherePartsCommandBuilder whereBuilder = new SqlServerWherePartsCommandBuilder(deleteBuilder.Parameters);

                Expression expression = PartialEvaluatingExpressionTreeVisitor.EvaluateIndependentSubtrees(predicate);

                SqlServerWhereClauseVisitor visitor = new SqlServerWhereClauseVisitor();

                visitor.Translate(expression, whereBuilder);

                deleteBuilder.WhereParts = whereBuilder.WherePartsBuilder.ToString();
            }

            this.sessionProvider.ExecutedCommandBuilder = deleteBuilder;

            return(this.sessionProvider.ExecuteNonQuery(deleteBuilder));
        }
        /// <summary>
        /// 解析 Where 语句
        /// </summary>
        /// <param name="whereClause"></param>
        /// <param name="queryModel"></param>
        /// <param name="index"></param>
        public override void VisitWhereClause( WhereClause whereClause, QueryModel queryModel, int index )
        {
            SqlServerWhereClauseVisitor visitor = new SqlServerWhereClauseVisitor( this.parameters );

            string whereParts = visitor.Translate( whereClause.Predicate );

            queryPartsAggregator.WhereParts.Add( whereParts );

            base.VisitWhereClause( whereClause, queryModel, index );
        }