Update MongoDb

Src/Asp.NetCore2/MongoDbTest/OrmTest/OrmTest.cs

@@ -56,6 +56,18 @@ namespace MongoDbTest
                .ExecuteCommand();
 
 
+            var updateRow6 = db.Updateable<OrderInfo>()
+                .SetColumns(it => new OrderInfo { Name = it.Name, CreateTime = DateTime.Now })
+                .Where(it => it.Id == ids.Last())
+                .ExecuteCommand();
+
+
+            var updateRow7 = db.Updateable<OrderInfo>()
+             .SetColumns(it => new OrderInfo { Name = it.Name+"a", CreateTime = DateTime.Now })
+             .Where(it => it.Id == ids.Last())
+             .ExecuteCommand();
+
+
             var delrow = db.Deleteable(new OrderInfo() { Id = ids.Last() })
               .ExecuteCommand(); 
 

Src/Asp.NetCore2/SqlSugar.MongoDbCore/ExpToSql/VisitorItems/BinaryExpressionTranslator.cs

@@ -56,14 +56,29 @@ namespace SqlSugar.MongoDbCore
         }
 
         private BsonDocument FieldComparisonExpression(BinaryExpression expr)
+        {
+            BsonValue field, value;
+            bool leftIsMember, rightIsMember;
+            string op;
+            OutParameters(expr, out field, out value, out leftIsMember, out rightIsMember, out op);
+            if (op == null)
+            {
+                return GetCalculationOperation(field, expr.NodeType, value);
+            }
+            else
+            {
+                return GetComparisonOperation(expr, field, value, leftIsMember, rightIsMember, op);
+            }
+        }
+
+        private void OutParameters(BinaryExpression expr, out BsonValue field, out BsonValue value, out bool leftIsMember, out bool rightIsMember, out string op)
         {
             var left = new ExpressionVisitor(_context, new ExpressionVisitorContext());
             var right = new ExpressionVisitor(_context, new ExpressionVisitorContext());
-            BsonValue field = left.Visit(expr.Left);
+            field = left.Visit(expr.Left);
-            BsonValue value = right.Visit(expr.Right);
+            value = right.Visit(expr.Right);
-            bool leftIsMember = false;
+            leftIsMember = false;
-            bool rightIsMember = false;
+            rightIsMember = false;
-
             if (left?.visitorContext?.ExpType == typeof(MemberExpression))
             {
                 leftIsMember = true;
@@ -74,22 +89,23 @@ namespace SqlSugar.MongoDbCore
                 rightIsMember = true;
             }
 
-            string op = expr.NodeType switch
+            op = expr.NodeType switch
             {
-                ExpressionType.Equal =>    "$eq",
+                ExpressionType.Equal => "$eq",
-                ExpressionType.NotEqual =>   "$ne",
+                ExpressionType.NotEqual => "$ne",
                 ExpressionType.GreaterThan => "$gt",
                 ExpressionType.GreaterThanOrEqual => "$gte",
                 ExpressionType.LessThan => "$lt",
                 ExpressionType.LessThanOrEqual => "$lte",
-                _ => throw new NotSupportedException($"Unsupported binary op: {expr.NodeType}")
+                _ => null
             };
+        }
 
-
+        private BsonDocument GetComparisonOperation(BinaryExpression expr, BsonValue field, BsonValue value, bool leftIsMember, bool rightIsMember, string op)
-
+        {
             string leftValue = "";
             BsonValue rightValue = "";
-            if (IsLeftValue(leftIsMember, rightIsMember, op)|| IsRightValue(leftIsMember, rightIsMember, op))
+            if (IsLeftValue(leftIsMember, rightIsMember, op) || IsRightValue(leftIsMember, rightIsMember, op))
             {
                 MemberExpression expression;
                 if (IsLeftValue(leftIsMember, rightIsMember, op))
@@ -104,9 +120,9 @@ namespace SqlSugar.MongoDbCore
                     rightValue = field;
                     expression = expr.Right as MemberExpression;
                 }
-                if (expression != null) 
+                if (expression != null)
                 {
-                    if (expression.Expression is ParameterExpression parameter) 
+                    if (expression.Expression is ParameterExpression parameter)
                     {
                         if (_context?.context != null)
                         {
@@ -128,12 +144,30 @@ namespace SqlSugar.MongoDbCore
             else
             {
                 return new BsonDocument
-                {
+                    {
-                    { field.ToString(), new BsonDocument { { op, value } } }
+                        { field.ToString(), new BsonDocument { { op, value } } }
-                };
+                    };
             }
         }
 
+        private BsonDocument GetCalculationOperation(BsonValue field, ExpressionType nodeType, BsonValue value)
+        {
+            string operation = nodeType switch
+            {
+                ExpressionType.Add => "$add",
+                ExpressionType.Subtract => "$subtract",
+                ExpressionType.Multiply => "$multiply",
+                ExpressionType.Divide => "$divide",
+                ExpressionType.Modulo => "$mod",
+                _ => throw new NotSupportedException($"Unsupported calculation operation: {nodeType}")
+            };
+
+            return new BsonDocument
+    {
+        { field.ToString(), new BsonDocument { { operation, value } } }
+    };
+        }
+
         private static bool IsRightValue(bool leftIsMember, bool rightIsMember, string op)
         {
             return  rightIsMember && !leftIsMember;

Src/Asp.NetCore2/SqlSugar.MongoDbCore/ExpToSql/VisitorItems/MemberInitExpressionTractor.cs

@@ -26,7 +26,7 @@ namespace SqlSugar.MongoDbCore
             throw new Exception("");
         }
 
-        private static BsonValue Update(Expression expr)
+        private  BsonValue Update(Expression expr)
         {
             var exp = expr as MemberInitExpression;
             var setDocument = new BsonDocument();
@@ -34,9 +34,16 @@ namespace SqlSugar.MongoDbCore
             {
                 if (binding is MemberAssignment assignment)
                 {
-                    var fieldName = assignment.Member.Name;
+                    var fieldName = assignment.Member.Name; 
-                    var fieldValue = Expression.Lambda(assignment.Expression).Compile().DynamicInvoke();
+                    var fieldValue =new ExpressionVisitor(_context,_visitorContext).Visit(Expression.Lambda(assignment.Expression));
-                    setDocument[fieldName] = BsonValue.Create(fieldValue);
+                    if (assignment.Expression is MemberExpression && ExpressionTool.GetParameters(assignment.Expression).Count > 0)
+                    {
+                        setDocument[fieldName] = new BsonDocument("$getField", fieldValue); 
+                    }
+                    else
+                    {
+                        setDocument[fieldName] = BsonValue.Create(fieldValue);
+                    }
                 }
             }
             return new BsonDocument("$set", setDocument);