-

OrmTest/UnitTest/UnitTestBase.cs

@@ -37,7 +37,7 @@ namespace OrmTest.UnitTest
                 {
                     foreach (var item in pars)
                     {
-                        if (!validPars.Any(it => it.ParameterName.Equals(item.ParameterName) && it.Value.Equals(item.Value)))
+                        if (!validPars.Any(it => it.ParameterName.Equals(item.ParameterName) && it.Value.ObjToString().Equals(item.Value.ObjToString())))
                         {
                             throw new Exception(errorMessage);
                         }

OrmTest/UnitTest/Update.cs

@@ -98,8 +98,7 @@ UNION ALL
                            new SugarParameter("@Id",1),
                            new SugarParameter("@TestId",0),
                            new SugarParameter("@CreateTime", Convert.ToDateTime("2017-05-21 09:56:12.610")),
-                           new SugarParameter("@Const0", 1),
-                           new SugarParameter("@Name", "jack")
+                           new SugarParameter("@Const0", 1)
             }, t8.Key, t8.Value, "Update t8 error"
            );
 
@@ -116,7 +115,18 @@ UNION ALL
                            new SugarParameter("@CreateTime", Convert.ToDateTime("2017-05-21 09:56:12.610")),
                            new SugarParameter("@Name", "jack") },t9.Key,t9.Value,"Upate t9 error"
            );
-
+            updateObj.SchoolId = 18;
+            string name = "x";
+            var t10 = db.Updateable<Student>().UpdateColumns(it => new Student() { Name =name, SchoolId=updateObj.SchoolId }).Where(it=>it.Id==11).ToSql();
+            base.Check(@"UPDATE [Student]  SET
+            [SchoolId] = [@Const0] , [Name] = [@constant1]   WHERE ( [Id] = @Id1 )", new List<SugarParameter>() {
+                           new SugarParameter("@constant1","x"),
+                           new SugarParameter("@Const0",18),
+                           new SugarParameter("@Id1",11)},
+                               t10.Key,
+                               t10.Value,
+                               "Update 10 error"
+            );
         }
 
         public SqlSugarClient GetInstance()

SqlSugar/Abstract/Core/SqlBuilder/SqlBuilderProvider.cs

@@ -18,6 +18,7 @@ namespace SqlSugar
         public abstract string GetTranslationTableName(string name);
         public abstract string GetTranslationColumnName(string entityName, string propertyName);
         public abstract string GetTranslationColumnName(string propertyName);
+        public abstract string GetNoTranslationColumnName(string name);
 
         public string AppendWhereOrAnd(bool isWhere, string sqlString)
         {

SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs

@@ -77,6 +77,20 @@ namespace SqlSugar
             this.UpdateBuilder.DbColumnInfoList = this.UpdateBuilder.DbColumnInfoList.Where(it => ignoreColumns.Contains(it.PropertyName) || it.IsPrimarykey == true).ToList();
             return this;
         }
+        public IUpdateable<T> UpdateColumns(Expression<Func<T, T>> columns)
+        {
+            var expResult = UpdateBuilder.GetExpressionValue(columns, ResolveExpressType.Update);
+            var resultArray=expResult.GetResultArray();
+            if (resultArray.IsValuable()) {
+                foreach (var item in resultArray)
+                {
+                    string key = SqlBuilder.GetNoTranslationColumnName(item);
+                    UpdateBuilder.SetValues.Add(new KeyValuePair<string, string>(SqlBuilder.GetTranslationColumnName(key), item));
+                }
+            }
+            this.UpdateBuilder.DbColumnInfoList = this.UpdateBuilder.DbColumnInfoList.Where(it => UpdateBuilder.SetValues.Any(v=> SqlBuilder.GetNoTranslationColumnName(v.Key) ==it.DbColumnName) || it.IsPrimarykey == true).ToList();
+            return this;
+        }
 
         public IUpdateable<T> Where(bool isUpdateNull, bool IsOffIdentity = false)
         {
@@ -174,7 +188,9 @@ namespace SqlSugar
                     }
                 });
             }
-
+            if (this.UpdateBuilder.Parameters.IsValuable()&&this.UpdateBuilder.SetValues.IsValuable()) {
+                this.UpdateBuilder.Parameters.RemoveAll(it => this.UpdateBuilder.SetValues.Any(v =>(SqlBuilder.SqlParameterKeyWord+SqlBuilder.GetNoTranslationColumnName(v.Key)) == it.ParameterName));
+            }
         }
         private string GetDbColumnName(string entityName)
         {

SqlSugar/ExpressionsToSql/Common/ExpressionResult.cs

@@ -103,6 +103,7 @@ namespace SqlSugar
                 case ResolveExpressType.Array:
                 case ResolveExpressType.SelectSingle:
                 case ResolveExpressType.SelectMultiple:
+                case ResolveExpressType.Update:
                     parameter = parameter + ",";
                     break;
                 case ResolveExpressType.WhereSingle:

SqlSugar/ExpressionsToSql/Common/ResolveExpressType.cs

@@ -14,7 +14,8 @@ namespace SqlSugar
         FieldSingle=5,
         FieldMultiple=7,
         Join=8,
-        Array=9
+        Array=9,
+        Update=10
 
     }
 }

SqlSugar/ExpressionsToSql/ExpressionContext.cs

@@ -149,6 +149,12 @@ namespace SqlSugar
         {
             return string.Format(" {0} {1} {2} ", GetTranslationTableName(fieldValue), "AS", GetTranslationColumnName(asName));
         }
+
+        public virtual string GetEqString(string asName, string fieldValue)
+        {
+            return string.Format(" {2} {1} {0} ", GetTranslationTableName(fieldValue), "=", GetTranslationColumnName(asName));
+        }
+
         public virtual string GetAsString(string asName, string fieldValue, string fieldShortName)
         {
             return string.Format(" {0} {1} {2} ", GetTranslationTableName(fieldShortName + "." + fieldValue), "AS", GetTranslationColumnName(asName));

SqlSugar/ExpressionsToSql/ResolveItems/ConstantExpressionResolve.cs

@@ -19,6 +19,7 @@ namespace SqlSugar
             switch (parameter.Context.ResolveType)
             {
                 case ResolveExpressType.SelectSingle:
+                case ResolveExpressType.Update:
                 case ResolveExpressType.SelectMultiple:
                     baseParameter.CommonTempData = value;
                     break;

SqlSugar/ExpressionsToSql/ResolveItems/MemberConstExpressionResolve.cs

@@ -18,6 +18,7 @@ namespace SqlSugar
             var isSetTempData = baseParameter.CommonTempData.IsValuable() && baseParameter.CommonTempData.Equals(CommonTempDataType.ChildNodeSet);
             switch (parameter.Context.ResolveType)
             {
+                case ResolveExpressType.Update:
                 case ResolveExpressType.SelectSingle:
                 case ResolveExpressType.SelectMultiple:
                     parameter.BaseParameter.CommonTempData = value;

SqlSugar/ExpressionsToSql/ResolveItems/MemberInitExpressionResolve.cs

@@ -28,11 +28,62 @@ namespace SqlSugar
                     break;
                 case ResolveExpressType.FieldMultiple:
                     break;
+                case ResolveExpressType.Update:
+                    Update(expression, parameter);
+                    break;
                 default:
                     break;
             }
         }
 
+        private void Update(MemberInitExpression expression, ExpressionParameter parameter)
+        {
+            int i = 0;
+            foreach (MemberBinding binding in expression.Bindings)
+            {
+                ++i;
+                if (binding.BindingType != MemberBindingType.Assignment)
+                {
+                    throw new NotSupportedException();
+                }
+                MemberAssignment memberAssignment = (MemberAssignment)binding;
+                var memberName = memberAssignment.Member.Name;
+                var item = memberAssignment.Expression;
+                if (item.NodeType == ExpressionType.Constant || (item is MemberExpression) && ((MemberExpression)item).Expression.NodeType == ExpressionType.Constant)
+                {
+                    base.Expression = item;
+                    base.Start();
+                    string parameterName = this.Context.SqlParameterKeyWord + "constant" + i;
+                    parameter.Context.Result.Append(base.Context.GetEqString(memberName, parameterName));
+                    this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.CommonTempData));
+                }
+                else if (item is MethodCallExpression)
+                {
+                    base.Expression = item;
+                    base.Start();
+                    parameter.Context.Result.Append(base.Context.GetEqString(memberName, parameter.CommonTempData.ObjToString()));
+                }
+                else if (item is MemberExpression || item is UnaryExpression)
+                {
+                    if (base.Context.Result.IsLockCurrentParameter == false)
+                    {
+                        base.Context.Result.CurrentParameter = parameter;
+                        base.Context.Result.IsLockCurrentParameter = true;
+                        parameter.IsAppendTempDate();
+                        base.Expression = item;
+                        base.Start();
+                        parameter.IsAppendResult();
+                        base.Context.Result.Append(base.Context.GetEqString(memberName, parameter.CommonTempData.ObjToString()));
+                        base.Context.Result.CurrentParameter = null;
+                    }
+                }
+                else if (item is BinaryExpression)
+                {
+                    Check.ThrowNotSupportedException(item.GetType().Name);
+                }
+            }
+        }
+ 
         public void Select(MemberInitExpression expression, ExpressionParameter parameter, bool isSingle)
         {
             int i = 0;

SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs

@@ -26,6 +26,7 @@ namespace SqlSugar
                     break;
                 case ResolveExpressType.SelectSingle:
                 case ResolveExpressType.SelectMultiple:
+                case ResolveExpressType.Update:
                     SelectMethod(parameter, isLeft, name, args, model);
                     break;
                 case ResolveExpressType.FieldSingle:

SqlSugar/ExpressionsToSql/ResolveItems/SimpleBinaryExpressionResolve.cs

@@ -15,6 +15,7 @@ namespace SqlSugar
             {
                 case ResolveExpressType.SelectSingle:
                 case ResolveExpressType.SelectMultiple:
+                case ResolveExpressType.Update:
 
                     base.Expression = expression.Right;
                     base.Start();

SqlSugar/ExpressionsToSql/ResolveItems/TypeParameterExpressionReolve.cs

@@ -20,6 +20,7 @@ namespace SqlSugar
                     break;
                 case ResolveExpressType.SelectSingle:
                 case ResolveExpressType.SelectMultiple:
+                case ResolveExpressType.Update:
                     parameter.BaseParameter.CommonTempData = expression.Name;
                     break;
                 case ResolveExpressType.FieldSingle:

SqlSugar/ExpressionsToSql/ResolveItems/UnaryExpressionResolve.cs

@@ -19,6 +19,7 @@ namespace SqlSugar
                 case ResolveExpressType.FieldMultiple:
                 case ResolveExpressType.SelectSingle:
                 case ResolveExpressType.SelectMultiple:
+                case ResolveExpressType.Update:
                     base.Expression = expression.Operand;
                     if (base.Expression is BinaryExpression||parameter.BaseExpression is BinaryExpression)
                     {

SqlSugar/Interface/ISqlBuilder/ISqlBuilder.cs

@@ -23,5 +23,6 @@ namespace SqlSugar
         string GetTranslationTableName(string name);
         string GetTranslationColumnName(string entityName, string propertyName);
         string GetTranslationColumnName(string propertyName);
+        string GetNoTranslationColumnName(string name);
     }
 }

SqlSugar/Interface/IUpdateable.cs

@@ -14,6 +14,7 @@ namespace SqlSugar
         IUpdateable<T> Where(bool isUpdateNull,bool IsOffIdentity = false);
         IUpdateable<T> Where(Expression<Func<T, bool>> expression);
         IUpdateable<T> UpdateColumns(Expression<Func<T, object>> columns);
+        IUpdateable<T> UpdateColumns(Expression<Func<T, T>> columns);
         IUpdateable<T> IgnoreColumns(Expression<Func<T, object>> columns);
         IUpdateable<T> IgnoreColumns(Func<string, bool> ignoreColumMethod);
         IUpdateable<T> ReSetValue(Expression<Func<T, bool>> setValueExpression);

SqlSugar/Realization/SqlServer/Core/SqlBuilder/SqlServerBuilder.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
 namespace SqlSugar
@@ -34,5 +35,10 @@ namespace SqlSugar
         {
             return "[" + propertyName + "]";
         }
+
+        public override string GetNoTranslationColumnName(string name)
+        {
+            return name == null ? string.Empty : Regex.Match(name, @"\[(.*?)\]").Groups[1].Value;
+        }
     }
 }