-

OrmTest/ExpressionTest/Select.cs

@@ -36,7 +36,7 @@ namespace OrmTest.ExpressionTest
         }
         private static void MultipleDynamic()
         {
-            Expression<Func<Student, School, object>> exp = (it, school) => new{ Name = "a", Id = it.Id, SchoolId = school.Id };
+            Expression<Func<Student, School, object>> exp = (it, school) => new{ Name = "a", Id = it.Id/2, SchoolId = school.Id };
             ExpressionContext expContext = new ExpressionContext(exp, ResolveExpressType.SelectMultiple);
             expContext.Resolve();
             var selectorValue = expContext.Result.GetString();

SqlSugar/ExpressionsToSql/Common/ExpressionParameter.cs

@@ -17,5 +17,6 @@ namespace SqlSugar
         public object TempDate { get; set; }
         public ExpressionParameter BaseParameter { get; set; }
         public int SwitchCaseNumber { get; set; }
+        public bool IsOnlyAddTempDate { get; set; }
     }
 }

SqlSugar/ExpressionsToSql/Common/ExpressionResult.cs

@@ -81,14 +81,14 @@ namespace SqlSugar
         {
             switch (this._ResolveExpressType)
             {
+                case ResolveExpressType.SelectSingle:
+                case ResolveExpressType.SelectMultiple:
+                    parameter = parameter + ",";
+                    break;
                 case ResolveExpressType.WhereSingle:
                     break;
                 case ResolveExpressType.WhereMultiple:
                     break;
-                case ResolveExpressType.SelectSingle:
-                    break;
-                case ResolveExpressType.SelectMultiple:
-                    break;
                 case ResolveExpressType.FieldSingle:
                     break;
                 case ResolveExpressType.FieldMultiple:

SqlSugar/ExpressionsToSql/ResolveItems/BinaryExpressionResolve.cs

@@ -9,37 +9,46 @@ namespace SqlSugar
     {
         public BinaryExpressionResolve(ExpressionParameter parameter) : base(parameter)
         {
-            parameter.BinaryExpressionInfoList =new List<KeyValuePair<string, BinaryExpressionInfo>>();
+            if (parameter.BaseParameter.TempDate != null && parameter.BaseParameter.TempDate.Equals("simple"))
-            var expression = this.Expression as BinaryExpression;
-            var operatorValue = ExpressionTool.GetOperator(expression.NodeType);
-            var isComparisonOperator =
-                                        expression.NodeType != ExpressionType.And &&
-                                        expression.NodeType != ExpressionType.AndAlso &&
-                                        expression.NodeType != ExpressionType.Or &&
-                                        expression.NodeType != ExpressionType.OrElse;
-            base.BaseExpression = expression;
-            base.IsLeft = true;
-            base.Expression = expression.Left;
-            base.Start();
-            base.IsLeft = false;
-            base.Expression = expression.Right;
-            base.Start();
-            base.IsLeft = null;
-            string leftString = GetLeftString(parameter);
-            string rightString = GetRightString(parameter);
-            string binarySql =string.Format(ExpressionConst.BinaryFormatString,leftString,operatorValue,rightString);
-            string sqlWhereString = base.Context.Result.GetResultString();
-            if (sqlWhereString.Contains(ExpressionConst.Format0))
             {
-                base.Context.Result.Replace(ExpressionConst.Format0, binarySql);
+                parameter.IsOnlyAddTempDate = true;
+                new SimpleBinaryExpressionResolve(parameter);
+                parameter.IsOnlyAddTempDate = false;
             }
             else
             {
-                base.Context.Result.Append(binarySql);
+                parameter.BinaryExpressionInfoList = new List<KeyValuePair<string, BinaryExpressionInfo>>();
-            }
+                var expression = this.Expression as BinaryExpression;
-            if (sqlWhereString.Contains(ExpressionConst.Format1))
+                var operatorValue = ExpressionTool.GetOperator(expression.NodeType);
-            {
+                var isComparisonOperator =
-                base.Context.Result.Replace(ExpressionConst.Format1, ExpressionConst.Format0);
+                                            expression.NodeType != ExpressionType.And &&
+                                            expression.NodeType != ExpressionType.AndAlso &&
+                                            expression.NodeType != ExpressionType.Or &&
+                                            expression.NodeType != ExpressionType.OrElse;
+                base.BaseExpression = expression;
+                base.IsLeft = true;
+                base.Expression = expression.Left;
+                base.Start();
+                base.IsLeft = false;
+                base.Expression = expression.Right;
+                base.Start();
+                base.IsLeft = null;
+                string leftString = GetLeftString(parameter);
+                string rightString = GetRightString(parameter);
+                string binarySql = string.Format(ExpressionConst.BinaryFormatString, leftString, operatorValue, rightString);
+                string sqlWhereString = base.Context.Result.GetResultString();
+                if (sqlWhereString.Contains(ExpressionConst.Format0))
+                {
+                    base.Context.Result.Replace(ExpressionConst.Format0, binarySql);
+                }
+                else
+                {
+                    base.Context.Result.Append(binarySql);
+                }
+                if (sqlWhereString.Contains(ExpressionConst.Format1))
+                {
+                    base.Context.Result.Replace(ExpressionConst.Format1, ExpressionConst.Format0);
+                }
             }
         }
 

SqlSugar/ExpressionsToSql/ResolveItems/MemberInitExpressionResolve.cs

@@ -53,11 +53,14 @@ namespace SqlSugar
                     parameter.Context.Result.Append(parameterName);
                     this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.TempDate));
                 }
-                else if(item is MemberExpression)
+                else if (item is MemberExpression)
                 {
-                    base.Expression= memberAssignment.Expression;
+                    base.Expression = memberAssignment.Expression;
                     base.Start();
                 }
+                else {
+                     Check.ThrowNotSupportedException(item.GetType().Name);
+                }
             }
         }
     }

SqlSugar/ExpressionsToSql/ResolveItems/NewExpressionResolve.cs

@@ -49,19 +49,21 @@ namespace SqlSugar
                         parameter.Context.Result.Append(parameterName);
                         this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.TempDate));
                     }
+                    else if (item is MemberExpression)
+                    {
+                        base.Expression = item;
+                        base.Start();
+                    }
+                    else if (item is BinaryExpression)
+                    {
+                        base.Expression = item;
+                        parameter.TempDate = "simple";
+                        base.Start();
+                        parameter.TempDate =null;
+                    }
                     else
                     {
-                        var memberExpression = (MemberExpression)item;
+                        Check.ThrowNotSupportedException(item.GetType().Name);
-                        var fieldNme = (memberExpression).Member.Name;
-                        if (isSingle)
-                        {
-                            parameter.Context.Result.Append(fieldNme);
-                        }
-                        else
-                        {
-                            var shortName = memberExpression.Expression.ToString();
-                            parameter.Context.Result.Append(shortName + "." + fieldNme);
-                        }
                     }
                 }
             }

SqlSugar/ExpressionsToSql/ResolveItems/SimpleBinaryExpressionResolve.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Linq.Expressions;
+namespace SqlSugar
+{
+    public class SimpleBinaryExpressionResolve : BaseResolve
+    {
+        public SimpleBinaryExpressionResolve(ExpressionParameter parameter) : base(parameter)
+        {
+            var expression = base.Expression as  BinaryExpression;
+            switch (parameter.Context.ResolveType)
+            {
+                case ResolveExpressType.SelectSingle:
+                case ResolveExpressType.SelectMultiple:
+
+                    base.Expression = expression.Right;
+                    base.Start();
+                    var rightValue = parameter.TempDate;
+                    base.Expression = expression.Left;
+                    base.Start();
+                    var leftValue = parameter.TempDate;
+                    break;
+                case ResolveExpressType.WhereSingle:
+                case ResolveExpressType.WhereMultiple:
+                case ResolveExpressType.FieldSingle:
+                case ResolveExpressType.FieldMultiple:
+                default:
+       
+                    break;
+            }
+        }
+    }
+}

SqlSugar/SqlSugar.csproj

@@ -126,6 +126,7 @@
     <Compile Include="ExpressionsToSql\ResolveItems\MemberExpressionResolve.cs" />
     <Compile Include="ExpressionsToSql\ResolveItems\MethodCallExpressionResolve.cs" />
     <Compile Include="ExpressionsToSql\ResolveItems\NewExpressionResolve.cs" />
+    <Compile Include="ExpressionsToSql\ResolveItems\SimpleBinaryExpressionResolve.cs" />
     <Compile Include="ExpressionsToSql\ResolveItems\UnaryExpressionResolve.cs" />
     <Compile Include="ExpressionsToSql\Common\ExpResolveAccessory.cs" />
     <Compile Include="ExpressionsToSql\ExpressionContext.cs" />