diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbMaintenanceProvider/Methods.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbMaintenanceProvider/Methods.cs index 61ebe2602..100c02c88 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbMaintenanceProvider/Methods.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbMaintenanceProvider/Methods.cs @@ -441,7 +441,7 @@ namespace SqlSugar #endregion #region Private - private List GetListOrCache(string cacheKey, string sql) + protected List GetListOrCache(string cacheKey, string sql) { return this.Context.Utilities.GetReflectionInoCacheInstance().GetOrCreate(cacheKey, () => diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DeleteProvider/DeleteableProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DeleteProvider/DeleteableProvider.cs index e72d5ec3c..f6c628745 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DeleteProvider/DeleteableProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DeleteProvider/DeleteableProvider.cs @@ -242,6 +242,10 @@ namespace SqlSugar } public IDeleteable Where(List conditionalModels) { + if (conditionalModels.Count == 0) + { + return Where("1=2"); + } var sql = this.Context.Queryable().SqlBuilder.ConditionalModelToSql(conditionalModels); var result = this; result.Where(sql.Key, sql.Value); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/FastestProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/FastestProvider.cs index a2edd1935..be9e61b2b 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/FastestProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/FastestProvider.cs @@ -8,7 +8,7 @@ namespace SqlSugar { public partial class FastestProvider:IFastest where T:class,new() { - private SqlSugarProvider context; + internal SqlSugarProvider context; private ISugarQueryable queryable; private EntityInfo entityInfo { get; set; } public bool isLog; @@ -116,7 +116,7 @@ namespace SqlSugar this.context.Ado.IsEnableLogEvent = isLog; if (this.context.CurrentConnectionConfig?.AopEvents?.OnLogExecuted != null) { - this.context.CurrentConnectionConfig?.AopEvents?.OnLogExecuted($"End {title} name:{entityInfo.DbTableName} ,count: {datas.Count},current time: {DateTime.Now}" , new SugarParameter[] { }); + this.context.CurrentConnectionConfig?.AopEvents?.OnLogExecuted($"End {title} name:{GetTableName()} ,count: {datas.Count},current time: {DateTime.Now}" , new SugarParameter[] { }); } } @@ -127,7 +127,7 @@ namespace SqlSugar this.context.Ado.IsEnableLogEvent = false; if (this.context.CurrentConnectionConfig?.AopEvents?.OnLogExecuting != null) { - this.context.CurrentConnectionConfig?.AopEvents?.OnLogExecuting($"Begin {title} name:{entityInfo.DbTableName} ,count: {datas.Count},current time: {DateTime.Now} ", new SugarParameter[] { }); + this.context.CurrentConnectionConfig?.AopEvents?.OnLogExecuting($"Begin {title} name:{GetTableName()} ,count: {datas.Count},current time: {DateTime.Now} ", new SugarParameter[] { }); } } #endregion diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/Private.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/Private.cs index d8795ec16..fd6048980 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/Private.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/Private.cs @@ -56,6 +56,7 @@ namespace SqlSugar } dt.TableName = GetTableName(); var columns = entityInfo.Columns; + var isMySql = this.context.CurrentConnectionConfig.DbType == DbType.MySql; foreach (var item in datas) { var dr = dt.NewRow(); @@ -71,6 +72,13 @@ namespace SqlSugar name = column.PropertyName; } var value = ValueConverter(column, PropertyCallAdapterProvider.GetInstance(column.PropertyName).InvokeGet(item)); + if (isMySql&& column.UnderType==UtilConstants.BoolType) + { + if (value.ObjToBool() == false) + { + value = DBNull.Value; + } + } dr[name] = value; } dt.Rows.Add(dr); @@ -86,7 +94,7 @@ namespace SqlSugar } else { - return queryable.SqlBuilder.GetTranslationTableName(entityInfo.DbTableName); + return queryable.SqlBuilder.GetTranslationTableName(this.context.EntityMaintenance.GetTableName()); } } private object ValueConverter(EntityColumnInfo columnInfo, object value) diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/Setting.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/Setting.cs index 73fde0872..aa4da1b10 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/Setting.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/Setting.cs @@ -21,5 +21,11 @@ namespace SqlSugar this.Size = size; return this; } + public SplitFastest SplitTable() + { + SplitFastest result = new SplitFastest(); + result.FastestProvider = this; + return result; + } } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/SplitFastest.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/SplitFastest.cs new file mode 100644 index 000000000..718e0f05a --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/SplitFastest.cs @@ -0,0 +1,132 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar +{ + public class SplitFastestwhere T:class,new() + { + public FastestProvider FastestProvider { get; set; } + public SqlSugarProvider Context { get { return this.FastestProvider.context; } } + public EntityInfo EntityInfo { get { return this.Context.EntityMaintenance.GetEntityInfo(); } } + public int BulkCopy(List datas) + { + List groupModels; + int result; + GroupDataList(datas, out groupModels, out result); + foreach (var item in groupModels.GroupBy(it => it.GroupName)) + { + CreateTable(item.Key); + var addList = item.Select(it => it.Item).ToList(); + result += FastestProvider.AS(item.Key).BulkCopy(addList); + this.Context.MappingTables.Add(EntityInfo.EntityName, EntityInfo.DbTableName); + } + return result; + } + public async Task BulkCopyAsync(List datas) + { + List groupModels; + int result; + GroupDataList(datas, out groupModels, out result); + foreach (var item in groupModels.GroupBy(it => it.GroupName)) + { + CreateTable(item.Key); + var addList = item.Select(it => it.Item).ToList(); + result +=await FastestProvider.AS(item.Key).BulkCopyAsync(addList); + this.Context.MappingTables.Add(EntityInfo.EntityName, EntityInfo.DbTableName); + } + return result; + } + + + public int BulkUpdate(List datas) + { + List groupModels; + int result; + GroupDataList(datas, out groupModels, out result); + foreach (var item in groupModels.GroupBy(it => it.GroupName)) + { + CreateTable(item.Key); + var addList = item.Select(it => it.Item).ToList(); + result += FastestProvider.AS(item.Key).BulkUpdate(addList); + this.Context.MappingTables.Add(EntityInfo.EntityName, EntityInfo.DbTableName); + } + return result; + } + public async Task BulkUpdateAsync(List datas) + { + List groupModels; + int result; + GroupDataList(datas, out groupModels, out result); + foreach (var item in groupModels.GroupBy(it => it.GroupName)) + { + CreateTable(item.Key); + var addList = item.Select(it => it.Item).ToList(); + result += await FastestProvider.AS(item.Key).BulkUpdateAsync(addList); + this.Context.MappingTables.Add(EntityInfo.EntityName, EntityInfo.DbTableName); + } + return result; + } + + + public int BulkUpdate(List datas,string [] wherColumns,string [] updateColumns) + { + List groupModels; + int result; + GroupDataList(datas, out groupModels, out result); + foreach (var item in groupModels.GroupBy(it => it.GroupName)) + { + var addList = item.Select(it => it.Item).ToList(); + result += FastestProvider.AS(item.Key).BulkUpdate(addList,wherColumns,updateColumns); ; + } + return result; + } + public async Task BulkUpdateAsync(List datas, string[] wherColumns, string[] updateColumns) + { + List groupModels; + int result; + GroupDataList(datas, out groupModels, out result); + foreach (var item in groupModels.GroupBy(it => it.GroupName)) + { + var addList = item.Select(it => it.Item).ToList(); + result += await FastestProvider.AS(item.Key).BulkUpdateAsync(addList, wherColumns, updateColumns); ; + } + return result; + } + private void CreateTable(string tableName) + { + var isLog = this.Context.Ado.IsEnableLogEvent; + this.Context.Ado.IsEnableLogEvent = false; + if (!this.Context.DbMaintenance.IsAnyTable(tableName, false)) + { + this.Context.MappingTables.Add(EntityInfo.EntityName, tableName); + this.Context.CodeFirst.InitTables(); + } + this.Context.Ado.IsEnableLogEvent = isLog; + } + + private void GroupDataList(List datas, out List groupModels, out int result) + { + var attribute = typeof(T).GetCustomAttribute() as SplitTableAttribute; + Check.Exception(attribute == null, $"{typeof(T).Name} need SplitTableAttribute"); + groupModels = new List(); + var db = FastestProvider.context; + foreach (var item in datas) + { + var value = db.SplitHelper().GetValue(attribute.SplitType, item); + var tableName = db.SplitHelper().GetTableName(attribute.SplitType,value); + groupModels.Add(new GroupModel() { GroupName = tableName, Item = item }); + } + result = 0; + } + internal class GroupModel + { + public string GroupName { get; set; } + public T Item { get; set; } + } + } + +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SaveableProvider/Storageable.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SaveableProvider/Storageable.cs index 16024daa1..a5ab8b68e 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SaveableProvider/Storageable.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SaveableProvider/Storageable.cs @@ -125,7 +125,7 @@ namespace SqlSugar var other = messageList.Where(it => it.StorageType == StorageType.Other).ToList(); StorageableResult result = new StorageableResult() { - _IsWhereColumn= this.whereExpression != null, + _WhereColumnList= wherecolumnList, _AsName =asname, _Context=this.Context, AsDeleteable = this.Context.Deleteable().AS(asname), diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SaveableProvider/StorageableDataTable.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SaveableProvider/StorageableDataTable.cs new file mode 100644 index 000000000..adab484de --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SaveableProvider/StorageableDataTable.cs @@ -0,0 +1,224 @@ +using System; +using System.Collections.Generic; +using System.Data; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar +{ + public class StorageableDataTable + { + internal DataTable DataTable { get; set; } + internal SqlSugarProvider Context { get; set; } + internal string[] Columns { get; set; } = new string[] { }; + internal string SugarGroupId = "SugarGroupId"; + internal string SugarUpdateRows = "SugarUpdateRows"; + internal string SugarColumns = "SugarColumns"; + internal string SugarErrorMessage = "SugarErrorMessage"; + internal List dbDataList = new List(); + List,string>> whereFuncs = new List,string>>(); + public StorageableDataTable WhereColumns(string name) + { + return WhereColumns(new string[] { name}); + } + public StorageableDataTable WhereColumns(string[] names) + { + this.Columns = names; + var queryable = this.Context.Queryable(); + Check.Exception(Columns==null|| Columns.Length==0,"need WhereColums"); + var tableName = queryable.SqlBuilder.GetTranslationTableName(DataTable.TableName); + this.Context.Utilities.PageEach(DataTable.Rows.Cast(), 200, itemList => + { + List conditList = new List(); + SetConditList(itemList, Columns, conditList); + var addItem = this.Context.Queryable().AS(tableName).Where(conditList).ToDataTable().Rows.Cast().ToList(); + this.dbDataList.AddRange(addItem); + }); + return this; + } + public StorageableDataTable WhereColumns(List names) + { + return WhereColumns(names.ToArray()); + } + public StorageableDataTable SplitInsert(Func conditions, string message = null) + { + whereFuncs.Add(new KeyValuePair, string>(StorageType.Insert, conditions,message)); + return this; + } + public StorageableDataTable SplitDelete(Func conditions, string message = null) + { + whereFuncs.Add(new KeyValuePair,string>(StorageType.Delete, conditions,message)); + return this; + } + public StorageableDataTable SplitUpdate(Func conditions, string message = null) + { + whereFuncs.Add(new KeyValuePair,string>(StorageType.Update, conditions,message)); + return this; + } + + public StorageableDataTable Saveable(string inserMessage = null, string updateMessage = null) + { + SplitUpdate(it => it.Any(), updateMessage); + SplitInsert(it => true, inserMessage); + return this; + } + public StorageableDataTable SplitError(Func conditions, string message = null) + { + whereFuncs.Add(new KeyValuePair, string>(StorageType.Error, conditions, message)); + return this; + } + public StorageableDataTable SplitIgnore(Func conditions, string message = null) + { + whereFuncs.Add(new KeyValuePair, string>(StorageType.Ignore, conditions, message)); + return this; + } + + public DataTableResult ToStorage() + { + if (whereFuncs == null || whereFuncs.Count == 0) + { + Saveable(); + } + foreach (DataRow row in DataTable.Rows) + { + foreach (var item in whereFuncs.OrderByDescending(it => (int)it.key)) + { + SplitMethod(item.value1,item.key,row,item.value2); + } + if (row[SugarGroupId] == null || row[SugarGroupId] == DBNull.Value) + { + row[SugarGroupId] = StorageType.Ignore; + } + } + DataTable.Columns.Remove(SugarUpdateRows); + DataTable.Columns.Remove(SugarColumns); + var Groups=DataTable.Rows.Cast() + .Where(it=> it[SugarGroupId]!=null&& it[SugarGroupId] != DBNull.Value) + .GroupBy(it => ((StorageType)it[SugarGroupId]).ToString()).Select(it=>new DataTableGroups{ Type=it.Key,DataTable= it.CopyToDataTable() }) + .ToList(); + DataTable.Columns.Remove(SugarGroupId); + DataTable.Columns.Remove(SugarErrorMessage); + var inserList = new List>(); + var updateList = new List>(); + var DeleteList=Groups.FirstOrDefault(it=>it.Type==StorageType.Delete.ToString()); + if (Groups.Any(it => it.Type == StorageType.Insert.ToString())) + { + foreach (var item in Groups) + { + if (item.Type == StorageType.Insert.ToString()) + { + item.DataTable.Columns.Remove(SugarGroupId); + item.DataTable.Columns.Remove(SugarErrorMessage); + inserList.AddRange(this.Context.Utilities.DataTableToDictionaryList(item.DataTable)); + } + } + } + if (Groups.Any(it => it.Type == StorageType.Update.ToString())) + { + foreach (var item in Groups) + { + if (item.Type == StorageType.Update.ToString()) + { + item.DataTable.Columns.Remove(SugarGroupId); + item.DataTable.Columns.Remove(SugarErrorMessage); + updateList.AddRange(this.Context.Utilities.DataTableToDictionaryList(item.DataTable)); + } + } + } + List conditionalModels = new List(); + if (DeleteList!=null) + { + SetConditList(DeleteList.DataTable.Rows.Cast().ToList(), Columns, conditionalModels); + } + var tableName = this.Context.Queryable().SqlBuilder.GetTranslationTableName(DataTable.TableName); + DataTableResult result = new DataTableResult() + { + DataTableGroups=Groups, + AsDeleteable=this.Context.Deleteable().AS(tableName).Where(conditionalModels), + AsUpdateable= this.Context.Updateable(updateList).AS(tableName).WhereColumns(Columns), + AsInsertable=this.Context.Insertable(inserList).AS(tableName) + }; + return result; + } + + private void SplitMethod(Func conditions, StorageType type,DataRow item,string message) + { + item[SugarColumns] = Columns; + item[SugarUpdateRows] = dbDataList; + if ((item[SugarGroupId]==null|| item[SugarGroupId] == DBNull.Value) && conditions(item)) + { + item[SugarGroupId] = type; + item[SugarErrorMessage] = message; + } + } + private void SetConditList(List itemList, string[] whereColumns, List conditList) + { + ; + foreach (var dataItem in itemList) + { + var condition = new ConditionalCollections() + { + ConditionalList = new List>() + }; + conditList.Add(condition); + int i = 0; + foreach (var name in whereColumns) + { + var value = dataItem[name]; + if (value != null && value.GetType().IsEnum()) + { + value = Convert.ToInt64(value); + } + condition.ConditionalList.Add(new KeyValuePair(i == 0 ? WhereType.Or : WhereType.And, new ConditionalModel() + { + FieldName = name, + ConditionalType = ConditionalType.Equal, + FieldValue = value + "", + FieldValueConvertFunc = this.Context.CurrentConnectionConfig.DbType == DbType.PostgreSQL ? + UtilMethods.GetTypeConvert(value) : null + })); + ++i; + } + } + } + } + + public class DataTableResult + { + public List DataTableGroups { get; set; } + public IUpdateable> AsUpdateable { get; set; } + public IDeleteable AsDeleteable { get; set; } + public IInsertable> AsInsertable { get; set; } + } + public class DataTableGroups + { + public string Type { get; set; } + public DataTable DataTable { get; set; } + } + public static class StorageableDataTableExtensions + { + public static bool Any(this DataRow row) + { + var list=row["SugarUpdateRows"] as List; + var columns = row["SugarColumns"] as string[]; + return list.Any(it => + { + var result = true; + foreach (var name in columns) + { + + if (result) + { + result = row[name].ObjToString() == it[name].ObjToString(); + if (result == false) + { + break; + } + } + } + return result; + }); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/SqlBuilderProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/SqlBuilderProvider.cs index 9d234e932..3c71ff0fb 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/SqlBuilderProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/SqlBuilderProvider.cs @@ -152,6 +152,8 @@ namespace SqlSugar { parameterName = parameterName.Replace(this.SqlTranslationLeft, "_"); } + string oldName = item.FieldName; + item.FieldName = GetTranslationColumnName(item.FieldName); switch (item.ConditionalType) { case ConditionalType.Equal: @@ -248,6 +250,7 @@ namespace SqlSugar default: break; } + item.FieldName = oldName; } else { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarCoreProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarCoreProvider.cs new file mode 100644 index 000000000..90829c47f --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarCoreProvider.cs @@ -0,0 +1,92 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar +{ + /// + /// Partial SqlSugarScope + /// + public partial class SqlSugarScope : ISqlSugarClient, ITenant + { + + private List _configs; + private Action _configAction; + + private SqlSugarClient GetContext() + { + SqlSugarClient result = null; + var key = _configs.GetHashCode().ToString(); + StackTrace st = new StackTrace(true); + var methods = st.GetFrames(); + var isAsync = UtilMethods.IsAnyAsyncMethod(methods); + if (isAsync) + { + result = GetAsyncContext(key); + } + else + { + result = GetThreadContext(key); + } + return result; + } + private SqlSugarClient GetAsyncContext(string key) + { + SqlSugarClient result = CallContextAsync.GetData(key); + if (result == null) + { + List configList = GetCopyConfigs(); + CallContextAsync.SetData(key, new SqlSugarClient(configList)); + result = CallContextAsync.GetData(key); + if (this._configAction != null) + { + this._configAction(result); + } + } + + return result; + } + private SqlSugarClient GetThreadContext(string key) + { + SqlSugarClient result = CallContextThread.GetData(key); + if (result == null) + { + List configList = GetCopyConfigs(); + CallContextThread.SetData(key, new SqlSugarClient(configList)); + result = CallContextThread.GetData(key); + if (this._configAction != null) + { + this._configAction(result); + } + } + return result; + } + private List GetCopyConfigs() + { + return _configs.Select(it => new ConnectionConfig() + { + AopEvents = it.AopEvents, + ConfigId = it.ConfigId, + ConfigureExternalServices = it.ConfigureExternalServices, + ConnectionString = it.ConnectionString, + DbType = it.DbType, + IndexSuffix = it.IndexSuffix, + InitKeyType = it.InitKeyType, + IsAutoCloseConnection = it.IsAutoCloseConnection, + LanguageType = it.LanguageType, + MoreSettings = it.MoreSettings == null ? null : new ConnMoreSettings() + { + DefaultCacheDurationInSeconds = it.MoreSettings.DefaultCacheDurationInSeconds, + DisableNvarchar = it.MoreSettings.DisableNvarchar, + PgSqlIsAutoToLower = it.MoreSettings.PgSqlIsAutoToLower, + IsAutoRemoveDataCache = it.MoreSettings.IsAutoRemoveDataCache, + IsWithNoLockQuery = it.MoreSettings.IsWithNoLockQuery + }, + SlaveConnectionConfigs = it.SlaveConnectionConfigs + }).ToList(); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs index 932492555..15c911db9 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs @@ -765,6 +765,18 @@ namespace SqlSugar { return Storageable(new List() { data }); } + public StorageableDataTable Storageable(DataTable data) + { + var result = new StorageableDataTable(); + Check.Exception(data.TableName.IsNullOrEmpty() || data.TableName == "Table",ErrorMessage.GetThrowMessage( "DataTable data.TableName is null", "参数DataTable没有设置TableName ，参数.TableName=表名")); + result.DataTable = data; + result.Context = this; + data.Columns.Add(new DataColumn("SugarGroupId", typeof(StorageType))); + data.Columns.Add(new DataColumn("SugarUpdateRows", typeof(List))); + data.Columns.Add(new DataColumn("SugarErrorMessage", typeof(string))); + data.Columns.Add(new DataColumn("SugarColumns", typeof(string[]))); + return result; + } #endregion #region Reportable diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs index b1e619175..985dac4f7 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs @@ -181,19 +181,20 @@ namespace SqlSugar } - public IUpdateable ReSetValue(Expression> setValueExpression) + public IUpdateable ReSetValue(Action setValueExpression) { - Check.Exception(!IsSingle, "Batch operation not supported ReSetValue"); - var expResult = UpdateBuilder.GetExpressionValue(setValueExpression, ResolveExpressType.WhereSingle); - var resultString = Regex.Match(expResult.GetResultString(), @"\((.+)\)").Groups[1].Value; - LambdaExpression lambda = setValueExpression as LambdaExpression; - var expression = lambda.Body; - Check.Exception(!(expression is BinaryExpression), "Expression format error"); - Check.Exception((expression as BinaryExpression).NodeType != ExpressionType.Equal, "Expression format error"); - var leftExpression = (expression as BinaryExpression).Left; - Check.Exception(!(leftExpression is MemberExpression), "Expression format error"); - var leftResultString = UpdateBuilder.GetExpressionValue(leftExpression, ResolveExpressType.FieldSingle).GetString(); - UpdateBuilder.SetValues.Add(new KeyValuePair(leftResultString, resultString)); + ThrowUpdateByExpression(); + if (this.UpdateObjs.HasValue()) + { + var oldColumns = this.UpdateBuilder.DbColumnInfoList.Select(it => it.PropertyName).ToList(); + foreach (var item in UpdateObjs) + { + setValueExpression(item); + } + this.UpdateBuilder.DbColumnInfoList = new List(); + Init(); + this.UpdateBuilder.DbColumnInfoList = this.UpdateBuilder.DbColumnInfoList.Where(it => oldColumns.Contains(it.PropertyName)).ToList(); + } return this; } @@ -355,6 +356,11 @@ namespace SqlSugar CheckTranscodeing(); } + if (columns.ToString().Contains("Subqueryable().")) + { + expResult= expResult.Replace(this.SqlBuilder.SqlTranslationLeft+ (binaryExp.Left as MemberExpression).Expression+this.SqlBuilder.SqlTranslationRight+".",this.UpdateBuilder.GetTableNameString.TrimEnd()+"."); + } + UpdateBuilder.SetValues.Add(new KeyValuePair(SqlBuilder.GetTranslationColumnName(key), expResult)); this.UpdateBuilder.DbColumnInfoList = this.UpdateBuilder.DbColumnInfoList.Where(it => (UpdateParameterIsNull == false && IsPrimaryKey(it)) || UpdateBuilder.SetValues.Any(v => SqlBuilder.GetNoTranslationColumnName(v.Key).Equals(it.DbColumnName, StringComparison.CurrentCultureIgnoreCase) || SqlBuilder.GetNoTranslationColumnName(v.Key).Equals(it.PropertyName, StringComparison.CurrentCultureIgnoreCase)) || it.IsPrimarykey == true).ToList(); AppendSets(); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs index ba2ed753b..63c9bde70 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs @@ -878,14 +878,26 @@ namespace SqlSugar public string GeDateFormat(string formatString, string value) { - if (IsOracle()||IsPg()) + if (IsOracle() || IsPg()) { return $"to_char({value},'{formatString}') "; } - else if (IsMySql()&& formatString == "yyyy-MM-dd") + else if (IsSqlite() && formatString == "yyyy-MM-dd") + { + return $"strftime('%Y-%m-%d', {value})"; + } + else if (IsSqlite() && formatString.Contains("%")) + { + return $"strftime('{formatString}', {value})"; + } + else if (IsMySql() && formatString == "yyyy-MM-dd") { return $"DATE_FORMAT({value}, '%Y-%m-%d')"; } + else if (IsMySql() && formatString.Contains("%")) + { + return $"DATE_FORMAT({value}, '{formatString}')"; + } else if (formatString == "yyyy-MM-dd" && IsSqlServer()) { return $"CONVERT(varchar(100),convert(datetime,{value}), 23)"; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs index 98be67fdd..219cbe93b 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs @@ -402,9 +402,24 @@ namespace SqlSugar if (suagrColumn != null && suagrColumn.IsJson) { var key = (typeName + "." + name).ToLower(); - if (readerValues.ContainsKey(key)&& readerValues[key]!=null) + if (readerValues.Any(it=>it.Key.EqualCase(key))) + { + var jsonString = readerValues.First(it => it.Key.EqualCase(key)).Value; + if (jsonString != null) + { + if (jsonString.ToString().First() == '{'&& jsonString.ToString().Last() == '}') + { + result.Add(name, this.DeserializeObject>(jsonString + "")); + } + else + { + result.Add(name, this.DeserializeObject>>(jsonString + "")); + + } + } + } + else { - result.Add(name,this.DeserializeObject>>(readerValues[key]+"")); } } else diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IFastest.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IFastest.cs index fc91ed6d1..9d8fb37a6 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IFastest.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IFastest.cs @@ -5,7 +5,7 @@ using System.Threading.Tasks; namespace SqlSugar { - public interface IFastest + public interface IFastest where T:class,new() { IFastest AS(string tableName); IFastest PageSize(int Size); @@ -16,5 +16,7 @@ namespace SqlSugar Task BulkUpdateAsync(List datas); int BulkUpdate(List datas, string[] whereColumns, string[] updateColumns); Task BulkUpdateAsync(List datas, string[] whereColumns, string[] updateColumns); + + SplitFastest SplitTable(); } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/ISqlSugarClient.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/ISqlSugarClient.cs index 8a2e9db1e..041c86af3 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/ISqlSugarClient.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/ISqlSugarClient.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using System.Data; using System.Dynamic; using System.Linq.Expressions; using System.Threading.Tasks; @@ -122,7 +123,10 @@ namespace SqlSugar #region Saveable IStorageable Storageable(List dataList) where T : class, new(); IStorageable Storageable(T data) where T : class, new(); + StorageableDataTable Storageable(DataTable data); + [Obsolete("use Storageable")] ISaveable Saveable(List saveObjects) where T : class, new(); + [Obsolete("use Storageable")] ISaveable Saveable(T saveObject) where T : class, new(); #endregion diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IStorageable.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IStorageable.cs index 823cea16b..41439b68a 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IStorageable.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IStorageable.cs @@ -88,7 +88,7 @@ namespace SqlSugar public IInsertable AsInsertable { get; set; } public IUpdateable AsUpdateable { get; set; } public IDeleteable AsDeleteable { get; set; } - internal bool _IsWhereColumn { get; set; } + internal List _WhereColumnList { get; set; } internal string _AsName { get; set; } internal SqlSugarProvider _Context { get; set; } @@ -103,13 +103,58 @@ namespace SqlSugar public int BulkUpdate() { - Check.Exception(_IsWhereColumn, "Storageable.BulkCopy no support WhereColumns"); - return this._Context.Fastest().AS(_AsName).BulkUpdate(UpdateList.Select(it => it.Item).ToList()); + var isWhereColums = _WhereColumnList != null && _WhereColumnList.Any(); + if (isWhereColums) + { + var updateColumns = this._Context.EntityMaintenance.GetEntityInfo().Columns.Where(it => !it.IsPrimarykey && !it.IsIdentity && !it.IsOnlyIgnoreUpdate && !it.IsIgnore).Select(it => it.DbColumnName ?? it.PropertyName).ToArray(); + return BulkUpdate(updateColumns); + } + else + { + return this._Context.Fastest().AS(_AsName).BulkUpdate(UpdateList.Select(it => it.Item).ToList()); + } } public Task BulkUpdateAsync() { - Check.Exception(_IsWhereColumn, "Storageable.BulkCopy no support WhereColumns"); - return this._Context.Fastest().AS(_AsName).BulkUpdateAsync(UpdateList.Select(it => it.Item).ToList()); + var isWhereColums = _WhereColumnList != null && _WhereColumnList.Any(); + if (isWhereColums) + { + var updateColumns = this._Context.EntityMaintenance.GetEntityInfo().Columns.Where(it => !it.IsPrimarykey && !it.IsIdentity && !it.IsOnlyIgnoreUpdate && !it.IsIgnore).Select(it => it.DbColumnName ?? it.PropertyName).ToArray(); + return BulkUpdateAsync(updateColumns); + } + else + { + return this._Context.Fastest().AS(_AsName).BulkUpdateAsync(UpdateList.Select(it => it.Item).ToList()); + } + } + public int BulkUpdate(params string[] UpdateColumns) + { + + Check.Exception(UpdateColumns==null, "UpdateColumns is null"); + if (_WhereColumnList != null && _WhereColumnList.Any()) + { + return this._Context.Fastest().AS(_AsName).BulkUpdate(UpdateList.Select(it => it.Item).ToList(), _WhereColumnList.Select(it => it.DbColumnName).ToArray(), UpdateColumns); + } + else + { + var pkColumns = this._Context.EntityMaintenance.GetEntityInfo().Columns.Where(it => it.IsPrimarykey).Select(it => it.DbColumnName).ToArray(); + Check.Exception(pkColumns.Count()==0,"need primary key"); + return this._Context.Fastest().AS(_AsName).BulkUpdate(UpdateList.Select(it => it.Item).ToList(), pkColumns, UpdateColumns); + } + } + public async Task BulkUpdateAsync(params string[] UpdateColumns) + { + Check.Exception(UpdateColumns == null, "UpdateColumns is null"); + if (_WhereColumnList != null && _WhereColumnList.Any()) + { + return await this._Context.Fastest().AS(_AsName).BulkUpdateAsync(UpdateList.Select(it => it.Item).ToList(), _WhereColumnList.Select(it => it.DbColumnName).ToArray(), UpdateColumns); + } + else + { + var pkColumns = this._Context.EntityMaintenance.GetEntityInfo().Columns.Where(it => it.IsPrimarykey).Select(it => it.DbColumnName).ToArray(); + Check.Exception(pkColumns.Count() == 0, "need primary key"); + return await this._Context.Fastest().AS(_AsName).BulkUpdateAsync(UpdateList.Select(it => it.Item).ToList(), pkColumns, UpdateColumns); + } } } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IUpdateable.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IUpdateable.cs index 733deb9e7..e259690ba 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IUpdateable.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Interface/IUpdateable.cs @@ -86,7 +86,7 @@ namespace SqlSugar IUpdateable IsEnableUpdateVersionValidation(); IUpdateable EnableDiffLogEvent(object businessData = null); - IUpdateable ReSetValue(Expression> setValueExpression); + IUpdateable ReSetValue(Action setValueExpression); IUpdateable RemoveDataCache(); IUpdateable RemoveDataCache(string likeString); IUpdateable CallEntityMethod(Expression> method); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/DbMaintenance/MySqlDbMaintenance.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/DbMaintenance/MySqlDbMaintenance.cs index 6dd9d414f..06fbf180d 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/DbMaintenance/MySqlDbMaintenance.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/DbMaintenance/MySqlDbMaintenance.cs @@ -430,7 +430,7 @@ namespace SqlSugar { defaultValue = ""; } - if (defaultValue.ToLower().IsIn("now()", "current_timestamp")) + if (defaultValue.ToLower().IsIn("now()", "current_timestamp")|| defaultValue.ToLower().Contains("current_timestamp")) { string template = "ALTER table {0} CHANGE COLUMN {1} {1} {3} default {2}"; var dbColumnInfo = this.Context.DbMaintenance.GetColumnInfosByTableName(tableName).First(it => it.DbColumnName.Equals(columnName, StringComparison.CurrentCultureIgnoreCase)); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/MySqlProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/MySqlProvider.cs index 3545299cf..4ce4d9220 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/MySqlProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/MySqlProvider.cs @@ -119,7 +119,8 @@ namespace SqlSugar } else if (parameter.DbType== System.Data.DbType.DateTimeOffset) { - sqlParameter.Value = UtilMethods.ConvertFromDateTimeOffset((DateTimeOffset)sqlParameter.Value); + if(sqlParameter.Value != DBNull.Value) + sqlParameter.Value = UtilMethods.ConvertFromDateTimeOffset((DateTimeOffset)sqlParameter.Value); sqlParameter.DbType = System.Data.DbType.DateTime; } ++index; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/SqlBuilder/MySqlBlukCopy.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/SqlBuilder/MySqlBlukCopy.cs index 3d3ae6c28..23989a677 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/SqlBuilder/MySqlBlukCopy.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/SqlBuilder/MySqlBlukCopy.cs @@ -164,7 +164,7 @@ namespace SqlSugar { colum = table.Columns[i]; if (i != 0) sb.Append(","); - if (colum.DataType == typeof(string) && row[colum].ToString().Contains(",")) + if (colum.DataType == typeof(string) &&( row[colum].ToString().Contains(",") || row[colum].ToString().Contains("\r"))) { sb.Append("\"" + row[colum].ToString().Replace("\"", "\"\"") + "\""); } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/OracleProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/OracleProvider.cs index 1e4082777..9a7c77c36 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/OracleProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/OracleProvider.cs @@ -146,7 +146,8 @@ namespace SqlSugar } else if (parameter.DbType == System.Data.DbType.DateTimeOffset) { - sqlParameter.Value = UtilMethods.ConvertFromDateTimeOffset((DateTimeOffset)parameter.Value); + if (parameter.Value != DBNull.Value) + sqlParameter.Value = UtilMethods.ConvertFromDateTimeOffset((DateTimeOffset)parameter.Value); sqlParameter.DbType = System.Data.DbType.DateTime; } else if (parameter.DbType == System.Data.DbType.Boolean) @@ -182,7 +183,7 @@ namespace SqlSugar if (parameter.Direction != 0) sqlParameter.Direction = parameter.Direction; result[index] = sqlParameter; - if (sqlParameter.Direction.IsIn(ParameterDirection.Output, ParameterDirection.InputOutput,ParameterDirection.ReturnValue)) + if (sqlParameter.Direction.IsIn(ParameterDirection.Output, ParameterDirection.InputOutput, ParameterDirection.ReturnValue)) { if (this.OutputParameters == null) this.OutputParameters = new List(); this.OutputParameters.RemoveAll(it => it.ParameterName == sqlParameter.ParameterName); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/DbMaintenance/PostgreSQLDbMaintenance.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/DbMaintenance/PostgreSQLDbMaintenance.cs index 7e54d13fc..0f28493f2 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/DbMaintenance/PostgreSQLDbMaintenance.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/DbMaintenance/PostgreSQLDbMaintenance.cs @@ -354,11 +354,11 @@ namespace SqlSugar { item.Length = 1; } - if (dataType == "uuid") - { - item.Length = 50; - dataType = "varchar"; - } + //if (dataType == "uuid") + //{ + // item.Length = 50; + // dataType = "varchar"; + //} string dataSize = item.Length > 0 ? string.Format("({0})", item.Length) : null; if (item.DecimalDigits > 0&&item.Length>0 && dataType == "numeric") { @@ -394,6 +394,42 @@ namespace SqlSugar if (result == null || result.Count() == 0) { result = base.GetColumnInfosByTableName(tableName, isCache); + } + try + { + string sql = $@"select + kcu.column_name as key_column + from information_schema.table_constraints tco + join information_schema.key_column_usage kcu + on kcu.constraint_name = tco.constraint_name + and kcu.constraint_schema = tco.constraint_schema + and kcu.constraint_name = tco.constraint_name + where tco.constraint_type = 'PRIMARY KEY' + and kcu.table_schema='public' and + upper(kcu.table_name)=upper('{tableName.TrimEnd('"').TrimStart('"')}')"; + List pkList = new List(); + if (isCache) + { + pkList=GetListOrCache("GetColumnInfosByTableName_N_Pk"+tableName, sql); + } + else + { + pkList = this.Context.Ado.SqlQuery(sql); + } + if (pkList.Count >1) + { + foreach (var item in result) + { + if (pkList.Select(it=>it.ToUpper()).Contains(item.DbColumnName.ToUpper())) + { + item.IsPrimarykey = true; + } + } + } + } + catch + { + } return result; } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/SqlBuilder/PostgreSQLExpressionContext.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/SqlBuilder/PostgreSQLExpressionContext.cs index 12c4c405b..9158581bd 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/SqlBuilder/PostgreSQLExpressionContext.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/PostgreSQL/SqlBuilder/PostgreSQLExpressionContext.cs @@ -210,6 +210,12 @@ namespace SqlSugar return string.Format(" ( to_char({0},'yyyy-MM-dd')=to_char({1},'yyyy-MM-dd') ) ", parameter.MemberName, parameter2.MemberName); ; } + public override string HasValue(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + return string.Format("( {0} IS NOT NULL )", parameter.MemberName); + } + public override string DateIsSameByType(MethodCallExpressionModel model) { var parameter = model.Args[0]; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteExpressionContext.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteExpressionContext.cs index f76da6120..4a909bce6 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteExpressionContext.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteExpressionContext.cs @@ -171,7 +171,7 @@ namespace SqlSugar var parameter = model.Args[0].MemberName; var parameter2 = model.Args[1].MemberName; int time = 1; - return string.Format(" date({0}, 'localtime', 'start of day')= date({1}, 'localtime', 'start of day') ", parameter, parameter2, time); + return string.Format(" strftime('%Y-%m-%d', {0})= strftime('%Y-%m-%d', {1}) ", parameter, parameter2, time); } public override string DateIsSameByType(MethodCallExpressionModel model) { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs index 86ad4fcb3..43ac21a94 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarClient.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using System.Data; using System.Diagnostics; using System.Dynamic; using System.Linq; @@ -345,6 +346,10 @@ namespace SqlSugar #endregion #region Saveable + public StorageableDataTable Storageable(DataTable data) + { + return this.Context.Storageable(data); + } public IStorageable Storageable(List dataList) where T : class, new() { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarScope.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarScope.cs index 4e2fbebc1..a2b372d97 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarScope.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugarScope.cs @@ -1,17 +1,17 @@ using System; using System.Collections.Generic; +using System.Data; using System.Diagnostics; using System.Dynamic; +using System.Linq; using System.Linq.Expressions; using System.Text; using System.Threading.Tasks; namespace SqlSugar { - public class SqlSugarScope: ISqlSugarClient, ITenant + public partial class SqlSugarScope: ISqlSugarClient, ITenant { - private List _configs; - private Action _configAction; private SqlSugarScope() { @@ -540,6 +540,10 @@ namespace SqlSugar { return ScopedContext.Storageable(data); } + public StorageableDataTable Storageable(DataTable data) + { + return ScopedContext.Storageable(data); + } public ISugarQueryable Union(List> queryables) where T : class, new() { @@ -645,53 +649,5 @@ namespace SqlSugar { return ScopedContext.Fastest(); } - private SqlSugarClient GetContext() - { - SqlSugarClient result = null; - var key = _configs.GetHashCode().ToString(); - StackTrace st = new StackTrace(true); - var methods = st.GetFrames(); - var isAsync = UtilMethods.IsAnyAsyncMethod(methods); - if (isAsync) - { - result = GetAsyncContext(key); - } - else - { - result = GetThreadContext(key); - } - return result; - } - - private SqlSugarClient GetAsyncContext(string key) - { - SqlSugarClient result = CallContextAsync.GetData(key); - if (result == null) - { - CallContextAsync.SetData(key, new SqlSugarClient(_configs)); - result = CallContextAsync.GetData(key); - if (this._configAction != null) - { - this._configAction(result); - } - } - - return result; - } - - private SqlSugarClient GetThreadContext(string key) - { - SqlSugarClient result = CallContextThread.GetData(key); - if (result == null) - { - CallContextThread.SetData(key, new SqlSugarClient(_configs)); - result = CallContextThread.GetData(key); - if (this._configAction != null) - { - this._configAction(result); - } - } - return result; - } } }