Update Core

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

@@ -59,7 +59,7 @@ namespace SqlSugar
         public virtual Action<string, SugarParameter[]> LogEventCompleted { get; set; }
         public virtual Func<string, SugarParameter[], KeyValuePair<string, SugarParameter[]>> ProcessingEventStartingSQL { get; set; }
         protected virtual Func<string,string> FormatSql { get; set; }
-        public virtual Action<Exception> ErrorEvent { get; set; }
+        public virtual Action<SqlSugarException> ErrorEvent { get; set; }
         public virtual Action<DiffLogModel> DiffLogEvent { get; set; }
         public virtual List<IDbConnection> SlaveConnections { get; set; }
         public virtual IDbConnection MasterConnection { get; set; }
@@ -300,7 +300,7 @@ namespace SqlSugar
             catch (Exception ex)
             {
                 if (ErrorEvent != null)
-                    ErrorEvent(ex);
+                    ExecuteErrorEvent(sql, parameters, ex);
                 throw ex;
             }
             finally
@@ -333,7 +333,7 @@ namespace SqlSugar
             catch (Exception ex)
             {
                 if (ErrorEvent != null)
-                    ErrorEvent(ex);
+                    ExecuteErrorEvent(sql, parameters, ex);
                 throw ex;
             }
         }
@@ -360,7 +360,7 @@ namespace SqlSugar
             catch (Exception ex)
             {
                 if (ErrorEvent != null)
-                    ErrorEvent(ex);
+                    ExecuteErrorEvent(sql, parameters, ex);
                 throw ex;
             }
             finally
@@ -390,7 +390,7 @@ namespace SqlSugar
             catch (Exception ex)
             {
                 if (ErrorEvent != null)
-                    ErrorEvent(ex);
+                    ExecuteErrorEvent(sql,parameters,ex);
                 throw ex;
             }
             finally
@@ -786,6 +786,11 @@ namespace SqlSugar
             var result = Regex.IsMatch(sqlLower, "[ ]*select[ ]") && !Regex.IsMatch(sqlLower, "[ ]*insert[ ]|[ ]*update[ ]|[ ]*delete[ ]");
             return result;
         }
+
+        private void ExecuteErrorEvent(string sql, SugarParameter[] parameters, Exception ex)
+        {
+            ErrorEvent(new SqlSugarException(this.Context,ex, sql, parameters));
+        }
         #endregion
     }
 }

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

@@ -15,7 +15,7 @@ namespace SqlSugar
         }
         private SqlSugarClient Context { get; set; }
         public Action<DiffLogModel> OnDiffLogEvent { set { this.Context.Ado.DiffLogEvent = value; } }
-        public Action<Exception> OnError { set { this.Context.Ado.ErrorEvent = value; } }
+        public Action<SqlSugarException> OnError { set { this.Context.Ado.ErrorEvent = value; } }
         public Action<string, SugarParameter[]> OnLogExecuting { set { this.Context.Ado.LogEventStarting = value; } }
         public Action<string, SugarParameter[]> OnLogExecuted { set { this.Context.Ado.LogEventCompleted = value; } }
         public Func<string, SugarParameter[], KeyValuePair<string, SugarParameter[]>> OnExecutingChangeSql { set { this.Context.Ado.ProcessingEventStartingSQL = value; } }

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

@@ -323,7 +323,7 @@ namespace SqlSugar
             var isAny = invalidTypes.Contains(bindProperyTypeName);
             if (isAny)
             {
-                throw new UtilExceptions(string.Format("{0} can't  convert {1} to {2}", propertyName, validPropertyType, bindProperyTypeName));
+                throw new SqlSugarException(string.Format("{0} can't  convert {1} to {2}", propertyName, validPropertyType, bindProperyTypeName));
             }
         }
         #endregion

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

@@ -609,8 +609,8 @@ namespace SqlSugar
         {
             _RestoreMapping = false;
             totalNumber = this.Count();
-            var result = ToDataTablePage(pageIndex, pageSize);
             _RestoreMapping = true;
+            var result = ToDataTablePage(pageIndex, pageSize);
             return result;
         }
 
@@ -640,6 +640,7 @@ namespace SqlSugar
             _RestoreMapping = false;
             List<T> result = null;
             int count = this.Count();
+            _RestoreMapping = true;
             QueryBuilder.IsDisabledGobalFilter = UtilMethods.GetOldValue(QueryBuilder.IsDisabledGobalFilter, () =>
             {
                 QueryBuilder.IsDisabledGobalFilter = true;
@@ -650,7 +651,6 @@ namespace SqlSugar
 
             });
             totalNumber = count;
-            _RestoreMapping = true;
             return result;
         }
 

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

@@ -126,6 +126,14 @@ namespace SqlSugar
             {
                 StringBuilder batchInsetrSql = new StringBuilder();
                 int pageSize = 200;
+                if (this.EntityInfo.Columns.Count > 30)
+                {
+                    pageSize = 50;
+                }
+                else if (this.EntityInfo.Columns.Count > 20)
+                {
+                    pageSize = 100;
+                }
                 int pageIndex = 1;
                 int totalRecord = groupList.Count;
                 int pageCount = (totalRecord + pageSize - 1) / pageSize;

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs

@@ -160,6 +160,22 @@ namespace SqlSugar
             }
             return this;
         }
+        public IUpdateable<T> WhereColumns(string columnName)
+        {
+            if (this.WhereColumnList == null) this.WhereColumnList = new List<string>();
+            this.WhereColumnList.Add(columnName);
+            return this;
+        }
+
+        public IUpdateable<T> WhereColumns(string [] columnNames)
+        {
+            if (this.WhereColumnList == null) this.WhereColumnList = new List<string>();
+            foreach (var columnName in columnNames)
+            {
+                this.WhereColumnList.Add(columnName);
+            }
+            return this;
+        }
 
         public IUpdateable<T> UpdateColumns(Expression<Func<T, object>> columns)
         {

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

@@ -35,6 +35,7 @@ namespace SqlSugar
                 _DbMehtods = value;
             }
         }
+        public int SubQueryIndex { get; set; }
         public int Index { get; set; }
         public int ParameterIndex { get; set; }
         public string SingleTableNameSubqueryShortName{ get;  set; }

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

@@ -32,10 +32,14 @@ namespace SqlSugar
             {
                 base.Context.Result.Replace(ExpressionConst.FormatSymbol, ExpressionConst.LeftParenthesis + ExpressionConst.FormatSymbol);
             }
-            if (leftExpression is UnaryExpression&& (leftExpression as UnaryExpression).Operand is UnaryExpression)
+            if (leftExpression is UnaryExpression && (leftExpression as UnaryExpression).Operand is UnaryExpression&& (leftExpression as UnaryExpression).NodeType != ExpressionType.Not)
             {
                 leftExpression = (leftExpression as UnaryExpression).Operand;
             }
+            if (rightExpression is UnaryExpression&& (rightExpression as UnaryExpression).Operand.Type==UtilConstants.BoolType&& (rightExpression as UnaryExpression).NodeType != ExpressionType.Not)
+            {
+                rightExpression = (rightExpression as UnaryExpression).Operand;
+            }
             parameter.LeftExpression = leftExpression;
             parameter.RightExpression = rightExpression;
             base.Expression = leftExpression;

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

@@ -242,7 +242,7 @@ namespace SqlSugar
                 model.Args.AddRange(appendArgs);
             }
             var methodValue = GetMethodValue(name, model);
-            if (parameter.BaseExpression is BinaryExpression && parameter.OppsiteExpression.Type == UtilConstants.BoolType&&name=="HasValue"&&!(parameter.OppsiteExpression is BinaryExpression)) {
+            if (parameter.BaseExpression is BinaryExpression && parameter.OppsiteExpression.Type == UtilConstants.BoolType&&name=="HasValue"&&!(parameter.OppsiteExpression is BinaryExpression)&& !(parameter.OppsiteExpression is MethodCallExpression && parameter.OppsiteExpression.Type == UtilConstants.BoolType)) {
                 methodValue = this.Context.DbMehtods.CaseWhen(new List<KeyValuePair<string, string>>() {
                     new KeyValuePair<string, string>("IF",methodValue.ObjToString()),
                     new KeyValuePair<string, string>("Return","1"),

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

@@ -42,7 +42,7 @@ namespace SqlSugar
             var argExp = exp.Arguments[0];
             var result = "AND " + SubTools.GetMethodValue(this.Context, argExp, ResolveExpressType.WhereMultiple);
             var selfParameterName = this.Context.GetTranslationColumnName((argExp as LambdaExpression).Parameters.First().Name) + UtilConstants.Dot;
-            result = result.Replace(selfParameterName, string.Empty);
+            result = result.Replace(selfParameterName, SubTools.GetSubReplace(this.Context));
             return result;
         }
     }

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

@@ -50,7 +50,11 @@ namespace SqlSugar
                 this.Context.InitMappingInfo(entityType);
                 this.Context.RefreshMapping();
             }
-            return "FROM "+this.Context.GetTranslationTableName(name, true);
+            var result= "FROM "+this.Context.GetTranslationTableName(name, true);
+            if (this.Context.SubQueryIndex > 0) {
+                result += " subTableIndex"+this.Context.SubQueryIndex;
+            }
+            return result;
         }
     }
 }

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

@@ -42,7 +42,7 @@ namespace SqlSugar
             var argExp = exp.Arguments[0];
             var result = "GROUP BY " + SubTools.GetMethodValue(this.Context, argExp, ResolveExpressType.FieldSingle);
             var selfParameterName = this.Context.GetTranslationColumnName((argExp as LambdaExpression).Parameters.First().Name) + UtilConstants.Dot;
-            result = result.Replace(selfParameterName, string.Empty);
+            result = result.Replace(selfParameterName, SubTools.GetSubReplace(this.Context));
             return result;
         }
     }

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

@@ -51,7 +51,7 @@ namespace SqlSugar
             }
             var result = "MAX(" + SubTools.GetMethodValue(Context, argExp, ResolveExpressType.WhereMultiple) + ")";
             var selfParameterName = Context.GetTranslationColumnName(parametres.First().Name) + UtilConstants.Dot;
-            result = result.Replace(selfParameterName, string.Empty);
+            result = result.Replace(selfParameterName, SubTools.GetSubReplace(this.Context));
             return result;
         }
     }

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

@@ -51,7 +51,7 @@ namespace SqlSugar
             }
             var result = "MIN(" + SubTools.GetMethodValue(Context, argExp, ResolveExpressType.WhereMultiple) + ")";
             var selfParameterName = Context.GetTranslationColumnName(parametres.First().Name) + UtilConstants.Dot;
-            result = result.Replace(selfParameterName, string.Empty);
+            result = result.Replace(selfParameterName, SubTools.GetSubReplace(this.Context));
             return result;
         }
     }

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

@@ -46,7 +46,7 @@ namespace SqlSugar
             var argExp = exp.Arguments[0];
             var result = "ORDER BY " + SubTools.GetMethodValue(this.Context, argExp, ResolveExpressType.FieldSingle);
             var selfParameterName = this.Context.GetTranslationColumnName((argExp as LambdaExpression).Parameters.First().Name) + UtilConstants.Dot;
-            result = result.Replace(selfParameterName, string.Empty);
+            result = result.Replace(selfParameterName, SubTools.GetSubReplace(this.Context));
             return result;
         }
     }

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

@@ -51,7 +51,7 @@ namespace SqlSugar
             }
             var result = "SUM(" + SubTools.GetMethodValue(Context, argExp, ResolveExpressType.WhereMultiple)+")";
             var selfParameterName = Context.GetTranslationColumnName(parametres.First().Name) + UtilConstants.Dot;
-            result = result.Replace(selfParameterName, string.Empty);
+            result = result.Replace(selfParameterName, SubTools.GetSubReplace(this.Context));
             return result;
         }
     }

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

@@ -42,7 +42,7 @@ namespace SqlSugar
             var argExp= exp.Arguments[0];
             var result= "WHERE "+SubTools.GetMethodValue(Context, argExp, ResolveExpressType.WhereMultiple);;
             var selfParameterName = Context.GetTranslationColumnName((argExp as LambdaExpression).Parameters.First().Name)+UtilConstants.Dot;
-            result = result.Replace(selfParameterName,string.Empty);
+            result = result.Replace(selfParameterName,SubTools.GetSubReplace(this.Context));
             return result;
         }
     }

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

@@ -55,7 +55,7 @@ namespace SqlSugar
             var argExp = exp.Arguments[1];
             var result = "WHERE " + SubTools.GetMethodValue(Context, argExp, ResolveExpressType.WhereMultiple); ;
             var selfParameterName = Context.GetTranslationColumnName((argExp as LambdaExpression).Parameters.First().Name) + UtilConstants.Dot;
-            result = result.Replace(selfParameterName, string.Empty);
+            result = result.Replace(selfParameterName, SubTools.GetSubReplace(this.Context));
             return result;
         }
     }

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

@@ -52,11 +52,15 @@ namespace SqlSugar
                     Check.Exception(true, "I'm sorry I can't parse the current expression");
                 }
             }
+            var subIndex = this.context.SubQueryIndex;
             while (currentExpression != null)
             {
                 var addItem = currentExpression.Object as MethodCallExpression;
                 if (addItem != null)
                     allMethods.Add(addItem);
+                if (subIndex==this.context.SubQueryIndex&&addItem !=null&&addItem.Arguments.HasValue()&&addItem.Arguments.Any(it=>it.ToString().Contains("Subqueryable()"))) {
+                    this.context.SubQueryIndex++;
+                }
                 currentExpression = addItem;
             }
         }

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

@@ -32,6 +32,14 @@ namespace SqlSugar
                                                 };
         }
 
+        public static string GetSubReplace(ExpressionContext context)
+        {
+            if (context.SubQueryIndex == 0)
+                return string.Empty;
+            else
+                return "subTableIndex"+context.SubQueryIndex+".";
+        }
+
         public static List<ISubOperation> SubItemsConst = SubItems(null);
 
         public static string GetMethodValue(ExpressionContext context, Expression item, ResolveExpressType type)

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

@@ -51,7 +51,7 @@ namespace SqlSugar
             }
         }
 
-        public static void PostgreSQL()
+        public static void TryPostgreSQL()
         {
             if (!IsTryPgSql)
             {

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

@@ -103,7 +103,8 @@ namespace SqlSugar
                 }
             }
             result = queryBuilder.GetSelectByItems(selectItems);
-            if (_context.CurrentConnectionConfig.DbType == DbType.PostgreSQL) {
+            if (_context.CurrentConnectionConfig.DbType == DbType.PostgreSQL)
+            {
                 result = result.ToLower();
             }
             return result;

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IAdo.cs

@@ -26,7 +26,7 @@ namespace SqlSugar
         Action<string, SugarParameter []> LogEventStarting { get; set; }
         Action<string, SugarParameter []> LogEventCompleted { get; set; }
         Func<string, SugarParameter[], KeyValuePair<string, SugarParameter[]>> ProcessingEventStartingSQL { get; set; }
-        Action<Exception> ErrorEvent { get; set; }
+        Action<SqlSugarException> ErrorEvent { get; set; }
         Action<DiffLogModel> DiffLogEvent { get; set; }
         bool IsClearParameters { get; set; }
         int CommandTimeOut { get; set; }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IUpdateable.cs

@@ -34,6 +34,8 @@ namespace SqlSugar
         /// <param name="columns"></param>
         /// <returns></returns>
         IUpdateable<T> WhereColumns(Expression<Func<T, object>> columns);
+        IUpdateable<T> WhereColumns(string columnName);
+        IUpdateable<T> WhereColumns(string [] columnNames);
         IUpdateable<T> UpdateColumns(Expression<Func<T, object>> columns);
         IUpdateable<T> UpdateColumns(Expression<Func<T, bool>> columns);
         IUpdateable<T> UpdateColumns(Func<string, bool> updateColumMethod);

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

@@ -6,6 +6,21 @@ namespace SqlSugar
 {
     public class OracleDbBind : DbBindProvider
     {
+        public override string GetDbTypeName(string csharpTypeName)
+        {
+            if (csharpTypeName == UtilConstants.ByteArrayType.Name)
+                return "blob";
+            if (csharpTypeName.ToLower() == "int32")
+                csharpTypeName = "int";
+            if (csharpTypeName.ToLower() == "int16")
+                csharpTypeName = "short";
+            if (csharpTypeName.ToLower() == "int64")
+                csharpTypeName = "long";
+            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";
+        }
         public override string GetPropertyTypeName(string dbTypeName)
         {
             dbTypeName = dbTypeName.ToLower();

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

@@ -60,20 +60,20 @@ namespace SqlSugar
             switch (type)
             {
                 case DateType.Year:
-                    return string.Format("(CAST(TO_CHAR({0},'yyyy') AS NUMBER)",parameter.MemberName);
+                    return string.Format("(CAST(TO_CHAR({0},'yyyy') AS NUMBER))", parameter.MemberName);
                 case DateType.Month:
-                    return string.Format("(CAST(TO_CHAR({0},'mm') AS NUMBER)", parameter.MemberName);
+                    return string.Format("(CAST(TO_CHAR({0},'mm') AS NUMBER))", parameter.MemberName);
                 case DateType.Hour:
-                    return string.Format("(CAST(TO_CHAR({0},'hh24') AS NUMBER)", parameter.MemberName);
+                    return string.Format("(CAST(TO_CHAR({0},'hh24') AS NUMBER))", parameter.MemberName);
                 case DateType.Second:
-                    return string.Format("(CAST(TO_CHAR({0},'ss') AS NUMBER)", parameter.MemberName);
+                    return string.Format("(CAST(TO_CHAR({0},'ss') AS NUMBER))", parameter.MemberName);
                 case DateType.Minute:
-                    return string.Format("(CAST(TO_CHAR({0},'mi') AS NUMBER)", parameter.MemberName);
+                    return string.Format("(CAST(TO_CHAR({0},'mi') AS NUMBER))", parameter.MemberName);
                 case DateType.Millisecond:
-                    return string.Format("(CAST(TO_CHAR({0},'ff3') AS NUMBER)", parameter.MemberName);
+                    return string.Format("(CAST(TO_CHAR({0},'ff3') AS NUMBER))", parameter.MemberName);
                 case DateType.Day:
                 default:
-                    return string.Format("(CAST(TO_CHAR({0},'dd') AS NUMBER)", parameter.MemberName);
+                    return string.Format("(CAST(TO_CHAR({0},'dd') AS NUMBER))", parameter.MemberName);
             }
         }
         public override string DateAddByType(MethodCallExpressionModel model)

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs

@@ -38,7 +38,7 @@ namespace SqlSugar
                     DependencyManagement.TryOracle();
                     break;
                 case DbType.PostgreSQL:
-                    DependencyManagement.PostgreSQL();
+                    DependencyManagement.TryPostgreSQL();
                     break;
                 default:
                     throw new Exception("ConnectionConfig.DbType is null");

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Utilities/Check.cs

@@ -9,25 +9,25 @@ namespace SqlSugar
         public static void ThrowNotSupportedException(string message)
         {
             message = message.IsNullOrEmpty() ? new NotSupportedException().Message : message;
-            throw new UtilExceptions("SqlSugarException.NotSupportedException：" + message);
+            throw new SqlSugarException("SqlSugarException.NotSupportedException：" + message);
         }
 
         public static void ArgumentNullException(object checkObj, string message)
         {
             if (checkObj == null)
-                throw new UtilExceptions("SqlSugarException.ArgumentNullException：" + message);
+                throw new SqlSugarException("SqlSugarException.ArgumentNullException：" + message);
         }
 
         public static void ArgumentNullException(object [] checkObj, string message)
         {
             if (checkObj == null|| checkObj.Length==0)
-                throw new UtilExceptions("SqlSugarException.ArgumentNullException：" + message);
+                throw new SqlSugarException("SqlSugarException.ArgumentNullException：" + message);
         }
 
         public static void Exception(bool isException, string message, params string[] args)
         {
             if (isException)
-                throw new UtilExceptions(string.Format(message, args));
+                throw new SqlSugarException(string.Format(message, args));
         }
     }
 }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Utilities/UtilExceptions.cs

@@ -1,58 +1,51 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using System.Text;
 using Newtonsoft.Json;
 namespace SqlSugar
 {
-    public class UtilExceptions : Exception
+    public class SqlSugarException : Exception
     {
-        public UtilExceptions(string message)
+        public  string Sql { get; set; }
+        public  object Parametres { get; set; }
+        public new Exception InnerException;
+        public new string  StackTrace;
+        public new MethodBase TargetSite;
+        public new string Source;
+
+        public SqlSugarException(string message)
             : base(message){}
 
-        public UtilExceptions(SqlSugarClient context,string message, string sql)
+        public SqlSugarException(SqlSugarClient context,string message, string sql)
-            : base(GetMessage(context, message, sql)) {}
+            : base(message) {
-
+            this.Sql = sql;
-        public UtilExceptions(SqlSugarClient context, string message, string sql, object pars)
-            : base(GetMessage(context,message, sql, pars)){}
-
-        public UtilExceptions(SqlSugarClient context, string message, object pars)
-            : base(GetMessage(context,message, pars)){}
-
-        private static string GetMessage(SqlSugarClient context, string message, object pars)
-        {
-            var parsStr = string.Empty; ;
-            if (pars != null)
-            {
-                parsStr = context.Utilities.SerializeObject(pars);
-            }
-            var reval = GetLineMessage("message", message) + GetLineMessage("function", parsStr);
-            return reval;
-
         }
-        private static string GetMessage(SqlSugarClient context, string message, string sql, object pars)
+
-        {
+        public SqlSugarException(SqlSugarClient context, string message, string sql, object pars)
-            if (pars == null)
+            : base(message) {
-            {
+            this.Sql = sql;
-                return GetMessage(context,message, sql);
+            this.Parametres = pars;
-            }
-            else
-            {
-                var reval = GetLineMessage("message         ", message) + GetLineMessage("ORM Sql", sql) + GetLineMessage("函数参数        ", JsonConvert.SerializeObject(pars));
-                return reval;
-            }
         }
-        private static string GetMessage(string message, string sql)
+
+        public SqlSugarException(SqlSugarClient context, Exception ex, string sql, object pars)
+            : base(ex.Message)
         {
-            var reval = GetLineMessage("message         ", message) + GetLineMessage("ORM Sql", sql);
+            this.Sql = sql;
-            return reval;
+            this.Parametres = pars;
+            this.InnerException = ex.InnerException;
+            this.StackTrace = ex.StackTrace;
+            this.TargetSite = ex.TargetSite;
+            this.Source = ex.Source;
         }
-        private static string GetLineMessage(string key, string value)
+
-        {
+        public SqlSugarException(SqlSugarClient context, string message, object pars)
-            return string.Format("{0} ： '{1}' \r\n", key, value);
+            : base(message) {
+            this.Parametres = pars;
         }
     }
-    public class VersionExceptions : UtilExceptions
+    public class VersionExceptions : SqlSugarException
     {
         public VersionExceptions(string message)
             : base(message){ }