Update Core

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs

@@ -18,16 +18,14 @@ namespace SqlSugar
         public virtual string GetDbTypeName(string csharpTypeName)
         {
             if (csharpTypeName == UtilConstants.ByteArrayType.Name)
-            {
                 return "varbinary";
-            }
+            if (csharpTypeName.ToLower() == "int32")
-            if (csharpTypeName == "Int32")
                 csharpTypeName = "int";
-            if (csharpTypeName == "Int16")
+            if (csharpTypeName.ToLower() == "int16")
                 csharpTypeName = "short";
-            if (csharpTypeName == "Int64")
+            if (csharpTypeName.ToLower() == "int64")
                 csharpTypeName = "long";
-            if (csharpTypeName == "Boolean")
+            if (csharpTypeName.ToLower().IsIn("boolean", "bool"))
                 csharpTypeName = "bool";
             var mappings = this.MappingTypes.Where(it => it.Value.ToString().Equals(csharpTypeName, StringComparison.CurrentCultureIgnoreCase));
             return mappings.HasValue() ? mappings.First().Key : "varchar";

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/IDataReaderEntityBuilder.cs

@@ -222,7 +222,7 @@ namespace SqlSugar
                     if (bindProperyTypeName.IsContainsIn("int", "int32"))
                         method = isNullableType ? getConvertInt32 : getInt32;
                     if (bindProperyTypeName.IsContainsIn("int64"))
-                        method = isNullableType ? getConvertInt64 : getInt64;
+                        method = isNullableType ? getConvertInt32 : getInt32;
                     if (bindProperyTypeName.IsContainsIn("byte"))
                         method = isNullableType ? getConvertByte : getByte;
                     if (bindProperyTypeName.IsContainsIn("int16"))

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/InsertBuilder.cs

@@ -166,6 +166,11 @@ namespace SqlSugar
                     }
                     return "'" + date.ToString("yyyy-MM-dd HH:mm:ss.fff") + "'";
                 }
+                else if (type == UtilConstants.ByteArrayType)
+                {
+                    string bytesString = "0x" + BitConverter.ToString((byte[])value);
+                    return bytesString;
+                }
                 else if (type.IsEnum())
                 {
                     return Convert.ToInt64(value);

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/UpdateBuilder.cs

@@ -175,7 +175,7 @@ namespace SqlSugar
                     {
                         updateTable.Append(SqlTemplateBatchUnion);
                     }
-                    updateTable.Append("\r\n SELECT " + string.Join(",", columns.Select(it => string.Format(SqlTemplateBatchSelect, FormatValue(it.Value),Builder.GetTranslationColumnName(it.DbColumnName)))));
+                    updateTable.Append("\r\n SELECT " + string.Join(",", columns.Select(it => string.Format(SqlTemplateBatchSelect, FormatValue(it.Value), Builder.GetTranslationColumnName(it.DbColumnName)))));
                     ++i;
                 }
                 pageIndex++;
@@ -210,7 +210,7 @@ namespace SqlSugar
             {
                 if (SetValues.IsValuable())
                 {
-                    var setValue = SetValues.Where(sv => it.IsPrimarykey == false && (it.IsIdentity == false || (IsOffIdentity && it.IsIdentity))).Where(sv => sv.Key == Builder.GetTranslationColumnName(it.DbColumnName)|| sv.Key==Builder.GetTranslationColumnName(it.PropertyName));
+                    var setValue = SetValues.Where(sv => it.IsPrimarykey == false && (it.IsIdentity == false || (IsOffIdentity && it.IsIdentity))).Where(sv => sv.Key == Builder.GetTranslationColumnName(it.DbColumnName) || sv.Key == Builder.GetTranslationColumnName(it.PropertyName));
                     if (setValue != null && setValue.Any())
                     {
                         return setValue.First().Value;
@@ -259,6 +259,11 @@ namespace SqlSugar
                     }
                     return "'" + date.ToString("yyyy-MM-dd HH:mm:ss.fff") + "'";
                 }
+                else if (type == UtilConstants.ByteArrayType)
+                {
+                    string bytesString = "0x" + BitConverter.ToString((byte[])value);
+                    return bytesString;
+                }
                 else if (type.IsEnum())
                 {
                     return Convert.ToInt64(value);

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Enum/ConditionalType.cs

@@ -12,6 +12,12 @@ namespace SqlSugar
         GreaterThan =2,
         GreaterThanOrEqual = 3,
         LessThan=4,
-        LessThanOrEqual = 5
+        LessThanOrEqual = 5,
+        In=6,
+        NotIn=7,
+        LikeLeft=8,
+        LikeRight=9,
+        NoEqual=10,
+        IsNullOrEmpty=11
     }
 }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/CaseWhen/CaseWhen.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+
+namespace SqlSugar
+{
+    public class CaseWhen
+    {
+        public CaseThen ElseIF(bool condition)
+        {
+            return null;
+        }
+        public T End<T>(T defaultValue)
+        {
+            return default(T);
+        }
+    }
+    public class CaseThen
+    {
+
+        public CaseWhen Return<T>(T result)
+        {
+            return null;
+        }
+    }
+}

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/CaseWhen/CaseWhenResolve.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+
+namespace SqlSugar
+{
+
+    public class CaseWhenResolve
+    {
+        List<MethodCallExpression> allMethods = new List<MethodCallExpression>();
+        private ExpressionContext context = null;
+        public CaseWhenResolve(MethodCallExpression expression, ExpressionContext context, Expression oppsiteExpression)
+        {
+            this.context = context;
+            var currentExpression = expression;
+            allMethods.Add(currentExpression);
+            if (context.IsSingle && oppsiteExpression != null&& oppsiteExpression is MemberExpression)
+            {
+                var childExpression = (oppsiteExpression as MemberExpression).Expression;
+                this.context.SingleTableNameSubqueryShortName = (childExpression as ParameterExpression).Name;
+            }
+            else if (context.IsSingle)
+            {
+                this.context.SingleTableNameSubqueryShortName = (context.Expression as LambdaExpression).Parameters.First().Name;
+            }
+            while (currentExpression != null)
+            {
+                var addItem = currentExpression.Object as MethodCallExpression;
+                if (addItem != null)
+                    allMethods.Add(addItem);
+                currentExpression = addItem;
+            }
+        }
+
+        public string GetSql()
+        {
+            allMethods.Reverse();
+            List<KeyValuePair<string, string>> sqls = new List<KeyValuePair<string, string>>();
+            foreach (var methodExp in allMethods)
+            {
+                var isFirst = allMethods.First() == methodExp;
+                var isLast= allMethods.Last() == methodExp;
+                var sql= SubTools.GetMethodValue(this.context, methodExp.Arguments[0],this.context.IsSingle?ResolveExpressType.WhereSingle:ResolveExpressType.WhereMultiple);
+                sqls.Add(new KeyValuePair<string, string>(methodExp.Method.Name, sql));
+            }
+            var result= this.context.DbMehtods.CaseWhen(sqls);
+            return result;
+        }
+    }
+}

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/ErrorMessage.cs

@@ -34,7 +34,7 @@ namespace SqlSugar
         {
             get
             {
-                return ErrorMessage.GetThrowMessage("Connection open error . {0}", " 连接字符串出错了，实在找不到原因请先Google错误{0}.");
+                return ErrorMessage.GetThrowMessage("Connection open error . {0}", " 连接数据库过程中发生错误，检查服务器是否正常连接字符串是否正确，实在找不到原因请先Google错误信息：{0}.");
             }
         }
     }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/ExpressionTool.cs

@@ -41,6 +41,8 @@ namespace SqlSugar
                 case ExpressionType.Multiply:
                 case ExpressionType.MultiplyChecked:
                     return "*";
+                case ExpressionType.Coalesce:
+                    throw new Exception("Expression no support ?? ,Use SqlFunc.IsNull");
                 default:
                     Check.ThrowNotSupportedException(string.Format(ErrorMessage.OperatorError, expressiontype.ToString()));
                     return null;

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/DefaultDbMethod.cs

@@ -271,6 +271,13 @@ namespace SqlSugar
             return string.Format("{0}", parameter1.MemberValue);
         }
 
+        public virtual string IsNull(MethodCallExpressionModel model)
+        {
+            var parameter = model.Args[0];
+            var parameter1 = model.Args[1];
+            return string.Format("ISNULL({0},{1})", parameter.MemberName, parameter1.MemberName);
+        }
+
         public virtual string True()
         {
             return "( 1 = 1 ) ";
@@ -295,7 +302,7 @@ namespace SqlSugar
 
         public virtual string MergeString(params string[] strings)
         {
-            return string.Join("", strings);
+            return string.Join("+", strings);
         }
 
         public virtual string Pack(string sql)
@@ -312,5 +319,34 @@ namespace SqlSugar
         {
             return "NULL";
         }
+
+        public virtual string GetDate()
+        {
+            return "GETDATE()";
+        }
+
+        public virtual string CaseWhen(List<KeyValuePair<string, string>> sqls)
+        {
+            StringBuilder reslut = new StringBuilder();
+            foreach (var item in sqls)
+            {
+                if (item.Key == "IF")
+                {
+                    reslut.AppendFormat(" ( CASE  WHEN {0} ", item.Value);
+                }
+                else if (item.Key == "End")
+                {
+                    reslut.AppendFormat("ELSE {0} END )", item.Value);
+                }
+                else if (item.Key == "Return")
+                {
+                    reslut.AppendFormat(" THEN {0} ", item.Value);
+                }
+                else {
+                    reslut.AppendFormat(" WHEN {0} ", item.Value);
+                }
+            }
+            return reslut.ToString();
+        }
     }
 }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/IDbMethods.cs

@@ -36,6 +36,7 @@ namespace SqlSugar
         string ToGuid(MethodCallExpressionModel model);
         string ToDouble(MethodCallExpressionModel model);
         string ToBool(MethodCallExpressionModel model);
+        string CaseWhen(List<KeyValuePair<string,string>> sqls);
         string Substring(MethodCallExpressionModel model);
         string ToDate(MethodCallExpressionModel model);
         string ToTime(MethodCallExpressionModel model);
@@ -48,6 +49,7 @@ namespace SqlSugar
         string AggregateMax(MethodCallExpressionModel model);
         string AggregateCount(MethodCallExpressionModel model);
         string MappingColumn(MethodCallExpressionModel model);
+        string IsNull(MethodCallExpressionModel model);
         string GetSelfAndAutoFill(string shortName,bool isSingle);
         string True();
         string False();
@@ -56,5 +58,6 @@ namespace SqlSugar
         string EqualTrue(string value);
         string Pack(string sql);
         string Null();
+        string GetDate();
     }
 }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/SqlFunc.cs

@@ -67,6 +67,13 @@ namespace SqlSugar
         public static int DateValue(DateTime date, DateType dataType) { throw new NotSupportedException("Can only be used in expressions"); }
         public static bool Between(object value, object start, object end) { throw new NotSupportedException("Can only be used in expressions"); }
         public static TResult IIF<TResult>(bool Expression, TResult thenValue, TResult elseValue) { throw new NotSupportedException("Can only be used in expressions"); }
+        public static TResult IsNull<TResult>(TResult thisValue, TResult ifNullValue) { throw new NotSupportedException("Can only be used in expressions"); }
+        public static string MergeString(string value1,string value2) { throw new NotSupportedException("Can only be used in expressions"); }
+        public static string MergeString(string value1, string value2,string value3) { throw new NotSupportedException("Can only be used in expressions"); }
+        public static string MergeString(string value1, string value2,string value3,string value4) { throw new NotSupportedException("Can only be used in expressions"); }
+        public static string MergeString(string value1, string value2, string value3, string value4,string value5) { throw new NotSupportedException("Can only be used in expressions"); }
+        public static string MergeString(string value1, string value2, string value3, string value4, string value5,string value6) { throw new NotSupportedException("Can only be used in expressions"); }
+        public static string MergeString(string value1, string value2, string value3, string value4, string value5, string value6,string value7) { throw new NotSupportedException("Can only be used in expressions"); }
         public static int ToInt32(object value) { return value.ObjToInt(); }
         public static long ToInt64(object value) { return Convert.ToInt64(value); }
         /// <summary>
@@ -102,11 +109,13 @@ namespace SqlSugar
         /// <param name="value"></param>
         /// <returns></returns>
         public static TResult GetSelfAndAutoFill<TResult>(TResult value) { throw new NotSupportedException("Can only be used in expressions"); }
+        public static DateTime GetDate() { throw new NotSupportedException("Can only be used in expressions"); }
         /// <summary>
         /// Subquery
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <returns></returns>
         public static Subqueryable<T> Subqueryable<T>() where T:class,new(){ throw new NotSupportedException("Can only be used in expressions");}
+        public static CaseThen  IF(bool condition) { throw new NotSupportedException("Can only be used in expressions"); }
     }
 }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/LambdaExpressionResolve.cs

@@ -12,6 +12,9 @@ namespace SqlSugar
             LambdaExpression lambda = base.Expression as LambdaExpression;
             var expression = lambda.Body;
             base.Expression = expression;
+            if (parameter.Context.ResolveType.IsIn(ResolveExpressType.FieldMultiple, ResolveExpressType.FieldSingle)) {
+                parameter.CommonTempData = CommonTempDataType.Append;
+            }
             base.Start();
         }
     }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MemberExpressionResolve.cs

@@ -10,24 +10,11 @@ namespace SqlSugar
         public ExpressionParameter Parameter { get; set; }
         public MemberExpressionResolve(ExpressionParameter parameter) : base(parameter)
         {
-            var baseParameter = parameter.BaseParameter;
+            ExpressionParameter baseParameter;
-            var expression = base.Expression as MemberExpression;
+            MemberExpression expression;
-            var childExpression = expression.Expression as MemberExpression;
+            bool? isLeft;
-            var memberName = expression.Member.Name;
+            bool isSetTempData, isValue, isValueBool, isLength, isDateValue, isHasValue, isDateDate, isMemberValue, isSingle, fieldIsBool, isSelectField, isField;
-            var childIsMember = childExpression != null;
+            SettingParameters(parameter, out baseParameter, out expression, out isLeft, out isSetTempData, out isValue, out isValueBool, out isLength, out isDateValue, out isHasValue, out isDateDate, out isMemberValue, out isSingle, out fieldIsBool, out isSelectField, out isField);
-            var isLeft = parameter.IsLeft;
-            var isSetTempData = parameter.IsSetTempData;
-            var isValue = memberName == "Value" && expression.Member.DeclaringType.Name == "Nullable`1";
-            var isBool = expression.Type == UtilConstants.BoolType;
-            var isValueBool = isValue && isBool && parameter.BaseExpression == null;
-            var isLength = memberName == "Length" && childIsMember && childExpression.Type == UtilConstants.StringType;
-            var isDateValue = memberName.IsIn(Enum.GetNames(typeof(DateType))) && (childIsMember && childExpression.Type == UtilConstants.DateType);
-            var isLogicOperator = ExpressionTool.IsLogicOperator(baseParameter.OperatorValue) || baseParameter.OperatorValue.IsNullOrEmpty();
-            var isHasValue = isLogicOperator && memberName == "HasValue" && expression.Expression != null && expression.NodeType == ExpressionType.MemberAccess;
-            var isDateDate = memberName == "Date" && expression.Expression.Type == UtilConstants.DateType;
-            var isMemberValue = expression.Expression != null && expression.Expression.NodeType != ExpressionType.Parameter && !isValueBool;
-            var isSingle = parameter.Context.ResolveType == ResolveExpressType.WhereSingle;
-            var fieldIsBool = isBool && isLogicOperator&&(parameter.BaseParameter==null||!(parameter.BaseParameter.CurrentExpression is MemberInitExpression|| parameter.BaseParameter.CurrentExpression is NewExpression));
             baseParameter.ChildExpression = expression;
             if (isLength)
             {
@@ -57,11 +44,18 @@ namespace SqlSugar
             {
                 ResolveMemberValue(parameter, baseParameter, isLeft, isSetTempData, expression);
             }
-            else if (fieldIsBool&& !this.Context.ResolveType.IsIn(ResolveExpressType.FieldSingle, ResolveExpressType.FieldMultiple))
+            else if (fieldIsBool && !isField && !isSelectField)
             {
                 ResolvefieldIsBool(parameter, baseParameter, isLeft, isSetTempData, expression, isSingle);
             }
             else
+            {
+                ResolveDefault(parameter, baseParameter, expression, isLeft, isSetTempData, isSingle);
+            }
+        }
+
+        #region Resolve default
+        private void ResolveDefault(ExpressionParameter parameter, ExpressionParameter baseParameter, MemberExpression expression, bool? isLeft, bool isSetTempData, bool isSingle)
         {
             string fieldName = string.Empty;
             switch (parameter.Context.ResolveType)
@@ -101,7 +95,8 @@ namespace SqlSugar
                     break;
             }
         }
-        }
+
+        #endregion
 
         #region Resolve Where
         private void ResolveWhereLogic(ExpressionParameter parameter, ExpressionParameter baseParameter, MemberExpression expression, bool? isLeft, bool isSetTempData, bool isSingle)
@@ -112,7 +107,7 @@ namespace SqlSugar
                 if (ExpressionTool.IsConstExpression(expression))
                 {
                     var value = ExpressionTool.GetMemberValue(expression.Member, expression);
-                    base.AppendValue(parameter, isLeft, value);
+                    baseParameter.CommonTempData = value;
                 }
                 else
                 {
@@ -204,9 +199,9 @@ namespace SqlSugar
                 };
                 AppendMember(parameter, isLeft, GetToDate(this.Context.DbMehtods.MergeString(
                     this.GetDateValue(parameter.CommonTempData, DateType.Year),
-                    "+'-'+",
+                    "'-'",
                     this.GetDateValue(parameter.CommonTempData, DateType.Month),
-                    "+'-'+",
+                    "'-'",
                     this.GetDateValue(parameter.CommonTempData, DateType.Day))));
             }
             parameter.CommonTempData = oldCommonTempDate;
@@ -344,6 +339,33 @@ namespace SqlSugar
             };
             return this.Context.DbMehtods.ToDate(pars);
         }
+
+        private void SettingParameters(ExpressionParameter parameter, out ExpressionParameter baseParameter, out MemberExpression expression, out bool? isLeft, out bool isSetTempData, out bool isValue, out bool isValueBool, out bool isLength, out bool isDateValue, out bool isHasValue, out bool isDateDate, out bool isMemberValue, out bool isSingle, out bool fieldIsBool, out bool isSelectField, out bool isField)
+        {
+            baseParameter = parameter.BaseParameter;
+            expression = base.Expression as MemberExpression;
+            var childExpression = expression.Expression as MemberExpression;
+            var memberName = expression.Member.Name;
+            var childIsMember = childExpression != null;
+            var isRoot = parameter.BaseExpression == null;
+            isLeft = parameter.IsLeft;
+            isSetTempData = parameter.IsSetTempData;
+            isValue = memberName == "Value" && expression.Member.DeclaringType.Name == "Nullable`1";
+            var isBool = expression.Type == UtilConstants.BoolType;
+            isValueBool = isValue && isBool && isRoot;
+            isLength = memberName == "Length" && childIsMember && childExpression.Type == UtilConstants.StringType;
+            isDateValue = memberName.IsIn(Enum.GetNames(typeof(DateType))) && (childIsMember && childExpression.Type == UtilConstants.DateType);
+            var isLogicOperator = ExpressionTool.IsLogicOperator(baseParameter.OperatorValue) || baseParameter.OperatorValue.IsNullOrEmpty();
+            isHasValue = isLogicOperator && memberName == "HasValue" && expression.Expression != null && expression.NodeType == ExpressionType.MemberAccess;
+            isDateDate = memberName == "Date" && expression.Expression.Type == UtilConstants.DateType;
+            isMemberValue = expression.Expression != null && expression.Expression.NodeType != ExpressionType.Parameter && !isValueBool;
+            isSingle = parameter.Context.ResolveType == ResolveExpressType.WhereSingle;
+            fieldIsBool = isBool && isLogicOperator && (parameter.BaseParameter == null || !(parameter.BaseParameter.CurrentExpression is MemberInitExpression || parameter.BaseParameter.CurrentExpression is NewExpression));
+            var isSelect = this.Context.ResolveType.IsIn(ResolveExpressType.SelectSingle, ResolveExpressType.SelectMultiple);
+            isSelectField = isSelect && isRoot;
+            isField = this.Context.ResolveType.IsIn(ResolveExpressType.FieldSingle, ResolveExpressType.FieldMultiple);
+        }
+
         #endregion
     }
 }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs

@@ -45,7 +45,20 @@ namespace SqlSugar
                 //Check.Exception(!(parameter.BaseExpression is BinaryExpression), "Current expressions are not supported");
                 SubResolve subResolve = new SubResolve(express, this.Context, parameter.OppsiteExpression);
                 var appendSql = subResolve.GetSql();
-                if (this.Context.ResolveType.IsIn(ResolveExpressType.SelectMultiple,ResolveExpressType.SelectSingle))
+                if (this.Context.ResolveType.IsIn(ResolveExpressType.SelectMultiple, ResolveExpressType.SelectSingle))
+                {
+                    parameter.BaseParameter.CommonTempData = appendSql;
+                }
+                else
+                {
+                    base.AppendValue(parameter, isLeft, appendSql);
+                }
+                return;
+            }
+            else if (IsIfElse(express, methodName)) {
+                CaseWhenResolve caseResole = new CaseWhenResolve(express, this.Context, parameter.OppsiteExpression);
+                var appendSql = caseResole.GetSql();
+                if (this.Context.ResolveType.IsIn(ResolveExpressType.SelectMultiple, ResolveExpressType.SelectSingle))
                 {
                     parameter.BaseParameter.CommonTempData = appendSql;
                 }
@@ -70,6 +83,14 @@ namespace SqlSugar
             }
         }
 
+        private bool IsIfElse(MethodCallExpression express, string methodName)
+        {
+            if (methodName == "End"&& express.Object.Type==typeof(CaseWhen))
+                return true;
+            else
+                return false;
+        }
+
         private void SqlFuncMethod(ExpressionParameter parameter, MethodCallExpression express, bool? isLeft)
         {
             CheckMethod(express);
@@ -176,6 +197,13 @@ namespace SqlSugar
                 model.Args.AddRange(appendArgs);
             }
             var methodValue = GetMdthodValue(name, model);
+            if (parameter.BaseExpression is BinaryExpression && parameter.OppsiteExpression.Type == UtilConstants.BoolType&&name=="HasValue") {
+                methodValue = this.Context.DbMehtods.CaseWhen(new List<KeyValuePair<string, string>>() {
+                    new KeyValuePair<string, string>("IF",methodValue.ObjToString()),
+                    new KeyValuePair<string, string>("Return","1"),
+                    new KeyValuePair<string, string>("End","0")
+                 });
+            }
             base.AppendValue(parameter, isLeft, methodValue);
         }
 
@@ -284,7 +312,7 @@ namespace SqlSugar
             base.Start();
             var methodCallExpressionArgs = new MethodCallExpressionArgs()
             {
-                IsMember = parameter.ChildExpression is MemberExpression&&!ExpressionTool.IsConstExpression(parameter.ChildExpression as MemberExpression),
+                IsMember = parameter.ChildExpression is MemberExpression && !ExpressionTool.IsConstExpression(parameter.ChildExpression as MemberExpression),
                 MemberName = parameter.CommonTempData
             };
             if (methodCallExpressionArgs.IsMember && parameter.ChildExpression != null && parameter.ChildExpression.ToString() == "DateTime.Now")
@@ -407,9 +435,15 @@ namespace SqlSugar
                     Check.Exception(!isValid, "SqlFunc.MappingColumn parameters error, The property name on the left, string value on the right");
                     this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[1].MemberName.ObjToString());
                     return mappingColumnResult;
+                case "IsNull":
+                    return this.Context.DbMehtods.IsNull(model);
+                case "MergeString":
+                        return this.Context.DbMehtods.MergeString(model.Args.Select(it=>it.MemberName.ObjToString()).ToArray());
                 case "GetSelfAndAutoFill":
                     this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[0].MemberName.ObjToString());
                     return this.Context.DbMehtods.GetSelfAndAutoFill(model.Args[0].MemberValue.ObjToString(), this.Context.IsSingle);
+                case "GetDate":
+                    return this.Context.DbMehtods.GetDate();
                 default:
                     break;
             }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/NewExpressionResolve.cs

@@ -13,6 +13,7 @@ namespace SqlSugar
         public NewExpressionResolve(ExpressionParameter parameter) : base(parameter)
         {
             var expression = base.Expression as NewExpression;
+            Check.Exception(expression.Type == UtilConstants.GuidType, "Not Support new Guid(), Use Guid.New()");
             switch (parameter.Context.ResolveType)
             {
                 case ResolveExpressType.WhereSingle:

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/Items/SubAvg.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+
+namespace SqlSugar
+{
+    public class SubAvg: ISubOperation
+    {
+        public string Name
+        {
+            get
+            {
+                return "Avg";
+            }
+        }
+
+        public Expression Expression
+        {
+            get; set;
+        }
+
+
+        public int Sort
+        {
+            get
+            {
+                return 200;
+            }
+        }
+
+        public ExpressionContext Context
+        {
+            get; set;
+        }
+
+        public string GetValue(Expression expression = null)
+        {
+            var exp = expression as MethodCallExpression;
+            return "AVG(" + SubTools.GetMethodValue(this.Context, exp.Arguments[0], ResolveExpressType.FieldSingle) + ")";
+        }
+    }
+}

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/Items/SubSum.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+
+namespace SqlSugar
+{
+    public class SubSum:ISubOperation
+    {
+        public string Name
+        {
+            get
+            {
+                return "Sum";
+            }
+        }
+
+        public Expression Expression
+        {
+            get; set;
+        }
+
+
+        public int Sort
+        {
+            get
+            {
+                return 200;
+            }
+        }
+
+        public ExpressionContext Context
+        {
+            get; set;
+        }
+
+        public string GetValue(Expression expression = null)
+        {
+            var exp = expression as MethodCallExpression;
+            return "SUM("+SubTools.GetMethodValue(this.Context, exp.Arguments[0], ResolveExpressType.FieldSingle)+")";
+        }
+    }
+}

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/SubTools.cs

@@ -23,6 +23,8 @@ namespace SqlSugar
                                                     new SubCount(){ Context=Context },
                                                     new SubMax(){ Context=Context },
                                                     new SubMin(){ Context=Context },
+                                                    new SubSum(){ Context=Context },
+                                                    new SubAvg(){ Context=Context },
                                                     new SubOrderBy(){ Context=Context },
                                                     new SubOrderByDesc(){ Context=Context }
                                                 };

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/Subquerable.cs

@@ -21,10 +21,15 @@ namespace SqlSugar
         {
             return this;
         }
+
         public TResult Select<TResult>(Func<T, TResult> expression) where TResult :struct
         {
             return default(TResult);
         }
+        public Byte[] Select(Func<T, Byte[]> expression) 
+        {
+            return null;
+        }
         public string Select(Func<T, string> expression) 
         {
             return default(string);
@@ -34,19 +39,54 @@ namespace SqlSugar
         {
             return default(TResult);
         }
-
+        public Byte[] Max(Func<T, Byte[]> expression)
-        public TResult Min<TResult>(Func<T, TResult> expression) where TResult : struct
         {
-            return default(TResult);
+            return null;
         }
         public string Max(Func<T, string> expression)
         {
             return default(string);
         }
+
         public string Min(Func<T, string> expression)
         {
             return default(string);
         }
+        public TResult Min<TResult>(Func<T, TResult> expression) where TResult : struct
+        {
+            return default(TResult);
+        }
+        public Byte[] Min(Func<T, Byte[]> expression)
+        {
+            return null;
+        }
+
+
+        public string Sum(Func<T, string> expression)
+        {
+            return default(string);
+        }
+        public TResult Sum<TResult>(Func<T, TResult> expression) where TResult : struct
+        {
+            return default(TResult);
+        }
+        public Byte[] Sum(Func<T, Byte[]> expression)
+        {
+            return null;
+        }
+
+        public string Avg(Func<T, string> expression)
+        {
+            return default(string);
+        }
+        public TResult Avg<TResult>(Func<T, TResult> expression) where TResult : struct
+        {
+            return default(TResult);
+        }
+        public Byte[] Avg(Func<T, Byte[]> expression)
+        {
+            return null;
+        }
 
         public bool Any()
         {

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs

@@ -140,13 +140,10 @@ namespace SqlSugar
                                             addValue = null;
                                         }
                                     }
-                                    else
+                                    else if (item.PropertyType == UtilConstants.IntType)
-                                    {
-                                        if (item.PropertyType == UtilConstants.IntType)
                                     {
                                         addValue = Convert.ToInt32(addValue);
                                     }
-                                    }
                                     result.Add(name, addValue);
                                 }
                             }
@@ -330,6 +327,34 @@ namespace SqlSugar
                         builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), "<=", parameterName);
                         parameters.Add(new SugarParameter(parameterName, item.FieldValue));
                         break;
+                    case ConditionalType.In:
+                        if (item.FieldValue == null) item.FieldValue = string.Empty;
+                        var inValue1 = ("(" + item.FieldValue.Split(',').ToJoinSqlInVals() + ")");
+                        builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), "IN", inValue1);
+                        parameters.Add(new SugarParameter(parameterName, item.FieldValue));
+                        break;
+                    case ConditionalType.NotIn:
+                        if (item.FieldValue == null) item.FieldValue = string.Empty;
+                        var inValue2 = ("(" + item.FieldValue.Split(',').ToJoinSqlInVals() + ")");
+                        builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), "NOT IN", inValue2);
+                        parameters.Add(new SugarParameter(parameterName, item.FieldValue));
+                        break;
+                    case ConditionalType.LikeLeft:
+                        builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), "LIKE", parameterName);
+                        parameters.Add(new SugarParameter(parameterName, item.FieldValue + "%"));
+                        break;
+                    case ConditionalType.LikeRight:
+                        builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), "LIKE", parameterName);
+                        parameters.Add(new SugarParameter(parameterName, "%" + item.FieldValue));
+                        break;
+                    case ConditionalType.NoEqual:
+                        builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), "<>", parameterName);
+                        parameters.Add(new SugarParameter(parameterName, item.FieldValue));
+                        break;
+                    case ConditionalType.IsNullOrEmpty:
+                        builder.AppendFormat("{0} ({1}) OR ({2}) ", type, item.FieldName.ToSqlFilter() + " IS NULL ", item.FieldName.ToSqlFilter() + " = '' ");
+                        parameters.Add(new SugarParameter(parameterName, item.FieldValue));
+                        break;
                     default:
                         break;
                 }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/DependencyManagement.cs

@@ -84,7 +84,7 @@ namespace SqlSugar
                 {
                     var message = ErrorMessage.GetThrowMessage(
                      "You need to refer to Microsoft.Data.Sqlite." + ex.Message,
-                    "你需要引用System.Data.SQLite.dll,如果有版本兼容问题请先删除原有引用");
+                    "你需要引用Microsoft.Data.Sqlite,如果有版本兼容问题请先删除原有引用");
                     throw new Exception(message);
                 }
             }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/SqlBuilder/MySqlExpressionContext.cs

@@ -123,5 +123,15 @@ namespace SqlSugar
         {
             return " concat("+string.Join(",", strings).Replace("+", "") + ") ";
         }
+        public override string IsNull(MethodCallExpressionModel model)
+        {
+            var parameter = model.Args[0];
+            var parameter1 = model.Args[1];
+            return string.Format("IFNULL({0},{1})", parameter.MemberName, parameter1.MemberName);
+        }
+        public override string GetDate()
+        {
+            return "NOW()";
+        }
     }
 }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/DbBind/OracleDbBind.cs

@@ -9,7 +9,7 @@ namespace SqlSugar
         public override string GetPropertyTypeName(string dbTypeName)
         {
             dbTypeName = dbTypeName.ToLower();
-            var propertyTypes = MappingTypes.Where(it => it.Value.ToString().ToLower() == dbTypeName||it.Key.ToLower()== dbTypeName);
+            var propertyTypes = MappingTypes.Where(it => it.Value.ToString().ToLower() == dbTypeName || it.Key.ToLower() == dbTypeName);
             if (dbTypeName == "int32")
             {
                 return "int";
@@ -30,6 +30,10 @@ namespace SqlSugar
             {
                 return "string";
             }
+            if (dbTypeName == "byte[]")
+            {
+                return "byte[]";
+            }
             else if (propertyTypes == null || propertyTypes.Count() == 0)
             {
                 Check.ThrowNotSupportedException(string.Format(" \"{0}\" Type NotSupported, DbBindProvider.GetPropertyTypeName error.", dbTypeName));

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleExpressionContext.cs

@@ -156,5 +156,22 @@ namespace SqlSugar
             var parameter = model.Args[0];
             return string.Format(" LENGTH({0}) ", parameter.MemberName);
         }
+
+        public override string IsNull(MethodCallExpressionModel model)
+        {
+            var parameter = model.Args[0];
+            var parameter1 = model.Args[1];
+            return string.Format("NVL({0},{1})", parameter.MemberName, parameter1.MemberName);
+        }
+
+        public override string MergeString(params string[] strings)
+        {
+            return string.Join("||", strings).Replace("+", "");
+        }
+
+        public override string GetDate()
+        {
+            return "sysdate";
+        }
     }
 }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleInsertBuilder.cs

@@ -109,6 +109,11 @@ namespace SqlSugar
                 {
                     return Convert.ToInt64(value);
                 }
+                else if (type == UtilConstants.ByteArrayType)
+                {
+                    string bytesString = "0x" + BitConverter.ToString((byte[])value);
+                    return bytesString;
+                }
                 else if (type == UtilConstants.BoolType)
                 {
                     return value.ObjToBool() ? "1" : "0";

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleUpdateBuilder.cs

@@ -10,8 +10,32 @@ namespace SqlSugar
     {
         protected override string TomultipleSqlString(List<IGrouping<int, DbColumnInfo>> groupList)
         {
-            throw new NotSupportedException("Oracle Waiting for updates updateable(List<T>)");
+            StringBuilder sb = new StringBuilder();
+            sb.AppendLine("Begin");
+            sb.AppendLine(string.Join("\r\n", groupList.Select(t =>
+            {
+                var updateTable = string.Format("UPDATE {0} SET", base.GetTableNameStringNoWith);
+                var setValues = string.Join(",", t.Where(s => !s.IsPrimarykey).Select(m => GetOracleUpdateColums(m)).ToArray());
+                var pkList = t.Where(s => s.IsPrimarykey).ToList();
+                List<string> whereList = new List<string>();
+                foreach (var item in pkList)
+                {
+                    var isFirst = pkList.First() == item;
+                    var whereString = isFirst ? " " : " AND ";
+                    whereString += GetOracleUpdateColums(item);
+                    whereList.Add(whereString);
                 }
+                return string.Format("{0} {1} WHERE {2};", updateTable, setValues, string.Join("AND",whereList));
+            }).ToArray()));
+            sb.AppendLine("End;");
+            return sb.ToString();
+        }
+
+        private string GetOracleUpdateColums(DbColumnInfo m)
+        {
+            return string.Format("\"{0}\"={1}", m.DbColumnName.ToUpper(), FormatValue(m.Value));
+        }
+
         public override object FormatValue(object value)
         {
             if (value == null)
@@ -34,6 +58,11 @@ namespace SqlSugar
                 {
                     return Convert.ToInt64(value);
                 }
+                else if (type == UtilConstants.ByteArrayType)
+                {
+                    string bytesString = "0x" + BitConverter.ToString((byte[])value);
+                    return bytesString;
+                }
                 else if (type == UtilConstants.BoolType)
                 {
                     return value.ObjToBool() ? "1" : "0";

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/Updateable/OracleUpdateable.cs

@@ -11,5 +11,10 @@ namespace SqlSugar
         {
             return this.EntityInfo.Columns.Where(it => it.OracleSequenceName.HasValue()).Select(it => it.DbColumnName).ToList();
         }
+        public override int ExecuteCommand()
+        {
+            base.ExecuteCommand();
+            return base.UpdateObjs.Count();
+        }
     }
 }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteExpressionContext.cs

@@ -196,5 +196,17 @@ namespace SqlSugar
         {
             return  string.Join("||", strings).Replace("+","");
         }
+
+        public override string IsNull(MethodCallExpressionModel model)
+        {
+            var parameter = model.Args[0];
+            var parameter1 = model.Args[1];
+            return string.Format("IFNULL({0},{1})", parameter.MemberName, parameter1.MemberName);
+        }
+
+        public override string GetDate()
+        {
+            return "DATETIME('now')";
+        }
     }
 }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteInsertBuilder.cs

@@ -56,6 +56,11 @@ namespace SqlSugar
                 {
                     return Convert.ToInt64(value);
                 }
+                else if (type == UtilConstants.ByteArrayType)
+                {
+                    string bytesString = "0x" + BitConverter.ToString((byte[])value);
+                    return bytesString;
+                }
                 else if (type == UtilConstants.BoolType)
                 {
                     return value.ObjToBool() ? "1" : "0";

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteUpdateBuilder.cs

@@ -54,6 +54,11 @@ namespace SqlSugar
                 {
                     return Convert.ToInt64(value);
                 }
+                else if (type == UtilConstants.ByteArrayType)
+                {
+                    string bytesString = "0x" + BitConverter.ToString((byte[])value);
+                    return bytesString;
+                }
                 else if (type == UtilConstants.BoolType)
                 {
                     return value.ObjToBool() ? "1" : "0";