Update core

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

@@ -3,46 +3,91 @@ using System.Collections.Generic;
 using System.Data;
 using System.Text;
 using System.Threading.Tasks;
-
+using System.Linq;
 namespace SqlSugar 
 {
-    public class FastestProvider<T>:IFastest<T>
+    public class FastestProvider<T>:IFastest<T> where T:class,new()
     {
         private SqlSugarProvider context;
         private ISugarQueryable<T> queryable;
-
+        private string AsName { get; set; }
+        private EntityInfo entityInfo { get; set; }
         public FastestProvider(SqlSugarProvider sqlSugarProvider)
         {
             this.context = sqlSugarProvider;
             this.queryable = this.context.Queryable<T>();
+            entityInfo=this.context.EntityMaintenance.GetEntityInfo<T>();
         }
+        #region Api
         public int BulkCopy(List<T> datas)
         {
-            return BulkCopyAsync(datas).GetAwaiter().GetResult();
+            return BulkCopyAsync(datas).ConfigureAwait(true).GetAwaiter().GetResult();
         }
-        public async Task<int> BulkCopyAsync(List<T> datas) 
+        public async Task<int> BulkCopyAsync(List<T> datas)
         {
-             
+            DataTable dt = ToDdateTable(datas);
-            DataTable tempDataTable = ReflectionInoCore<DataTable>.GetInstance().GetOrCreate("BulkCopyAsync" + typeof(T).FullName,()=> queryable.Where(it=>false).ToDataTable());
+            IFastBuilder buider = new SqlServerFastBuilder();
+            buider.Context = context;
+            var result = await buider.ExecuteBulkCopyAsync(dt);
+            return result;
+        }
+        public int BulkUpdate(List<T> datas)
+        {
+            return BulkUpdateAsync(datas).ConfigureAwait(true).GetAwaiter().GetResult();
+        }
+        public async Task<int> BulkUpdateAsync(List<T> datas)
+        {
+           var whereColumns=entityInfo.Columns.Where(it => it.IsPrimarykey).Select(it=>it.DbColumnName??it.PropertyName).ToArray();
+           var updateColumns = entityInfo.Columns.Where(it => !it.IsPrimarykey&&!it.IsIdentity&&!it.IsOnlyIgnoreUpdate&&!it.IsIgnore).Select(it => it.DbColumnName ?? it.PropertyName).ToArray();
+           return await BulkUpdateAsync(datas,whereColumns,updateColumns);
+        }
+        public async Task<int> BulkUpdateAsync(List<T> datas,string [] whereColumns,string [] updateColumns)
+        {
+            var isAuto = this.context.CurrentConnectionConfig.IsAutoCloseConnection;
+            this.context.CurrentConnectionConfig.IsAutoCloseConnection = false;
+            DataTable dt = ToDdateTable(datas);
+            IFastBuilder buider = new SqlServerFastBuilder();
+            buider.Context = context;
+            await buider.CreateTempAsync<T>(dt);
+            await buider.ExecuteBulkCopyAsync(dt);
+            //var queryTemp = this.context.Queryable<T>().AS(dt.TableName).ToList();//test
+            var result =await buider.UpdateByTempAsync(GetTableName(),dt.TableName,updateColumns, whereColumns);
+            this.context.DbMaintenance.DropTable(dt.TableName);
+            this.context.CurrentConnectionConfig.IsAutoCloseConnection = isAuto;
+            return result;
+        }
+        #endregion
+
+        #region Setting
+        public IFastest<T> AS(string tableName)
+        {
+            this.AsName = tableName;
+            return this;
+        } 
+        #endregion
+
+        #region Helper
+        private DataTable ToDdateTable(List<T> datas)
+        {
+            DataTable tempDataTable = ReflectionInoCore<DataTable>.GetInstance().GetOrCreate("BulkCopyAsync" + typeof(T).FullName, () => queryable.Where(it => false).ToDataTable());
             var dt = new DataTable();
             foreach (DataColumn item in tempDataTable.Columns)
             {
-                dt.Columns.Add(item.ColumnName,item.DataType);
+                dt.Columns.Add(item.ColumnName, item.DataType);
             }
-            var entityInfo = this.context.EntityMaintenance.GetEntityInfo<T>();
+            dt.TableName = GetTableName();
-            dt.TableName =queryable.SqlBuilder.GetTranslationTableName(entityInfo.DbTableName);
             var columns = entityInfo.Columns;
             foreach (var item in datas)
             {
                 var dr = dt.NewRow();
                 foreach (var column in columns)
                 {
-                    if (column.IsIgnore || column.IsOnlyIgnoreInsert) 
+                    if (column.IsIgnore || column.IsOnlyIgnoreInsert)
                     {
                         continue;
                     }
                     var name = column.DbColumnName;
-                    if (name == null) 
+                    if (name == null)
                     {
                         name = column.PropertyName;
                     }
@@ -51,21 +96,30 @@ namespace SqlSugar
                 }
                 dt.Rows.Add(dr);
             }
-            IFastBuilder buider = new SqlServerFastBuilder();
-            buider.Context = context;
-            var result= await buider.ExecuteBulkCopyAsync(dt);
-            return result;
-        }
 
-        private object ValueConverter(EntityColumnInfo columnInfo,object value)
+            return dt;
+        }
+        private string GetTableName()
+        {
+            if (this.AsName.HasValue())
+            {
+                return queryable.SqlBuilder.GetTranslationTableName(AsName);
+            }
+            else
+            {
+                return queryable.SqlBuilder.GetTranslationTableName(entityInfo.DbTableName);
+            }
+        }
+        private object ValueConverter(EntityColumnInfo columnInfo, object value)
         {
             if (value == null)
                 return value;
-            if (value is DateTime&&(DateTime)value == DateTime.MinValue) 
+            if (value is DateTime && (DateTime)value == DateTime.MinValue)
             {
                 value = Convert.ToDateTime("1900-01-01");
             }
             return value;
-        }
+        } 
+        #endregion
     }
 }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SugarProvider/SqlSugarProvider.cs

@@ -1178,7 +1178,7 @@ namespace SqlSugar
 
         #endregion
         #region
-        public IFastest<T> Fastest<T>()
+        public IFastest<T> Fastest<T>() where T:class,new()
         {
             return new FastestProvider<T>(this);
         }

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

@@ -10,7 +10,8 @@ namespace SqlSugar
     public interface  IFastBuilder
     {
         SqlSugarProvider Context { get; set; }
-
+        Task<int> UpdateByTempAsync(string tableName,string tempName,string [] updateColumns,string[] whereColumns);
         Task<int> ExecuteBulkCopyAsync(DataTable dt);
+        Task CreateTempAsync<T>(DataTable dt) where T : class, new();
     }
 }

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

@@ -3,11 +3,14 @@ using System.Collections.Generic;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace SqlSugar 
+namespace SqlSugar
 {
     public interface IFastest<T>
     {
+        IFastest<T> AS(string tableName);
         int BulkCopy(List<T> datas);
-         Task<int> BulkCopyAsync(List<T> datas);
+        Task<int> BulkCopyAsync(List<T> datas);
+        int BulkUpdate(List<T> datas);
+        Task<int> BulkUpdateAsync(List<T> datas);
     }
 }

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

@@ -178,7 +178,7 @@ namespace SqlSugar
         #endregion
 
         #region Fastest
-        IFastest<T> Fastest<T>();
+        IFastest<T> Fastest<T>() where T : class, new();
         #endregion
 
     }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/SqlServer/SqlBuilder/SqlServerFastBuilder.cs

@@ -14,6 +14,10 @@ namespace SqlSugar
 
         public SqlSugarProvider Context { get; set;  }
 
+        public string UpdateSql { get; set; } = @"UPDATE TM
+                                                    SET  {0}
+                                                    FROM {1} TM
+                                                    INNER JOIN {2} TE ON {3} ";
 
         public async Task<int> ExecuteBulkCopyAsync(DataTable dt)
         {
@@ -56,5 +60,23 @@ namespace SqlSugar
                 this.Context.Ado.Connection.Close();
             }
         }
+
+        public async Task<int> UpdateByTempAsync(string tableName, string tempName, string[] updateColumns, string[] whereColumns)
+        {
+            Check.ArgumentNullException(!updateColumns.Any(),"update columns count is 0");
+            Check.ArgumentNullException(!whereColumns.Any(), "where columns count is 0");
+            var sets = string.Join(",", updateColumns.Select(it=>$"TM.{it}=TE.{it}"));
+            var wheres = string.Join(",", whereColumns.Select(it => $"TM.{it}=TE.{it}"));
+            string sql = string.Format(UpdateSql,sets, tableName,tempName, wheres);
+            return await this.Context.Ado.ExecuteCommandAsync(sql);
+        }
+
+        public async Task CreateTempAsync<T>(DataTable dt) where T :class,new()
+        {
+            await this.Context.UnionAll(
+                this.Context.Queryable<T>().Where(it => false).AS(dt.TableName), 
+                this.Context.Queryable<T>().Where(it => false).AS(dt.TableName)).Select("top 1 * into #temp").ToListAsync();
+            dt.TableName = "#temp";
+        }
     }
 }

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

@@ -566,7 +566,7 @@ namespace SqlSugar
         #endregion
 
         #region
-        public IFastest<T> Fastest<T>()
+        public IFastest<T> Fastest<T>() where T : class, new()
         {
             return this.Context.Fastest<T>();
         }

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

@@ -641,7 +641,7 @@ namespace SqlSugar
             return ScopedContext.IsAnyConnection(configId);
         }
 
-        public IFastest<T> Fastest<T>()
+        public IFastest<T> Fastest<T>() where T : class, new()
         {
             return ScopedContext.Fastest<T>();
         }