497 lines
24 KiB
C#
497 lines
24 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
namespace SqlSugar
|
|
{
|
|
public partial class FastestProvider<T>:IFastest<T> where T:class,new()
|
|
{
|
|
internal SqlSugarProvider context;
|
|
private ISugarQueryable<T> queryable;
|
|
private EntityInfo entityInfo { get; set; }
|
|
public bool isLog;
|
|
public FastestProvider(SqlSugarProvider sqlSugarProvider)
|
|
{
|
|
this.context = sqlSugarProvider;
|
|
this.queryable = this.context.Queryable<T>();
|
|
entityInfo=this.context.EntityMaintenance.GetEntityInfo<T>();
|
|
}
|
|
|
|
#region BulkCopy
|
|
public int BulkCopy(string tableName,DataTable dt)
|
|
{
|
|
return BulkCopyAsync(tableName,dt).ConfigureAwait(true).GetAwaiter().GetResult();
|
|
}
|
|
public int BulkCopy(DataTable dt)
|
|
{
|
|
Check.ExceptionEasy(this.AsName.IsNullOrEmpty(), "need .AS(tablaeName) ", "需要 .AS(tablaeName) 设置表名");
|
|
return BulkCopyAsync(this.AsName, dt).ConfigureAwait(true).GetAwaiter().GetResult();
|
|
}
|
|
public Task<int> BulkCopyAsync(DataTable dt)
|
|
{
|
|
Check.ExceptionEasy(this.AsName.IsNullOrEmpty(), "need .AS(tablaeName) ", "需要 .AS(tablaeName) 设置表名");
|
|
return BulkCopyAsync(this.AsName, dt);
|
|
}
|
|
public async Task<int> BulkCopyAsync(string tableName, DataTable dt)
|
|
{
|
|
if (Size > 0)
|
|
{
|
|
int resul = 0;
|
|
await this.context.Utilities.PageEachAsync(dt.Rows.Cast<DataRow>().ToList(), Size, async item =>
|
|
{
|
|
resul += await _BulkCopy(tableName,item.CopyToDataTable());
|
|
});
|
|
return resul;
|
|
}
|
|
else
|
|
{
|
|
return await _BulkCopy(tableName,dt);
|
|
}
|
|
}
|
|
public int BulkCopy(List<T> datas)
|
|
{
|
|
return BulkCopyAsync(datas).ConfigureAwait(true).GetAwaiter().GetResult();
|
|
}
|
|
public async Task<int> BulkCopyAsync(List<T> datas)
|
|
{
|
|
if (Size > 0)
|
|
{
|
|
int resul=0;
|
|
await this.context.Utilities.PageEachAsync(datas, Size, async item =>
|
|
{
|
|
resul+= await _BulkCopy(item);
|
|
});
|
|
return resul;
|
|
}
|
|
else
|
|
{
|
|
return await _BulkCopy(datas);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region BulkUpdate
|
|
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 int BulkUpdate(List<T> datas, string[] whereColumns, string[] updateColumns)
|
|
{
|
|
whereColumns = whereColumns.Select(x => this.entityInfo.Columns.FirstOrDefault(it => it.PropertyName.EqualCase(x) || it.DbColumnName.EqualCase(x))?.DbColumnName ?? x).ToArray();
|
|
updateColumns = updateColumns.Select(x => this.entityInfo.Columns.FirstOrDefault(it => it.PropertyName.EqualCase(x) || it.DbColumnName.EqualCase(x))?.DbColumnName ?? x).ToArray();
|
|
return BulkUpdateAsync(datas,whereColumns,updateColumns).ConfigureAwait(true).GetAwaiter().GetResult();
|
|
}
|
|
|
|
public int BulkUpdate(List<T> datas, string[] whereColumns)
|
|
{
|
|
return BulkUpdateAsync(datas, whereColumns).GetAwaiter().GetResult();
|
|
}
|
|
|
|
public async Task<int> BulkUpdateAsync(List<T> datas, string[] whereColumns)
|
|
{
|
|
whereColumns = whereColumns.Select(x => this.entityInfo.Columns.FirstOrDefault(it => it.PropertyName.EqualCase(x) || it.DbColumnName.EqualCase(x))?.DbColumnName ?? x).ToArray();
|
|
var updateColumns = this.entityInfo.Columns
|
|
.Where(it => !whereColumns.Any(z => z.EqualCase(it.DbColumnName)))
|
|
.Where(it => !it.IsIdentity)
|
|
.Where(it => !it.IsPrimarykey)
|
|
.Where(it => !it.IsOnlyIgnoreUpdate)
|
|
.Where(it => !it.IsIgnore)
|
|
.Select(it => it.DbColumnName)
|
|
.ToArray();
|
|
return await BulkUpdateAsync(datas, whereColumns, updateColumns).ConfigureAwait(true);
|
|
}
|
|
public async Task<int> BulkUpdateAsync(List<T> datas,string [] whereColumns,string [] updateColumns)
|
|
{
|
|
|
|
if (Size > 0)
|
|
{
|
|
int resul = 0;
|
|
await this.context.Utilities.PageEachAsync(datas, Size, async item =>
|
|
{
|
|
resul += await _BulkUpdate(item, whereColumns, updateColumns);
|
|
});
|
|
return resul;
|
|
}
|
|
else
|
|
{
|
|
return await _BulkUpdate(datas, whereColumns, updateColumns);
|
|
}
|
|
}
|
|
|
|
public int BulkUpdate(string tableName,DataTable dataTable, string[] whereColumns, string[] updateColumns)
|
|
{
|
|
return BulkUpdateAsync(tableName,dataTable, whereColumns, updateColumns).ConfigureAwait(true).GetAwaiter().GetResult();
|
|
}
|
|
public int BulkUpdate(DataTable dataTable, string[] whereColumns, string[] updateColumns)
|
|
{
|
|
Check.ExceptionEasy(this.AsName.IsNullOrEmpty(), "need .AS(tablaeName) ", "需要 .AS(tablaeName) 设置表名");
|
|
return BulkUpdateAsync(this.AsName, dataTable, whereColumns, updateColumns).ConfigureAwait(true).GetAwaiter().GetResult();
|
|
}
|
|
public int BulkUpdate(DataTable dataTable, string[] whereColumns)
|
|
{
|
|
string[] updateColumns = dataTable.Columns.Cast<DataColumn>().Select(it => it.ColumnName).Where(it => !whereColumns.Any(z => z.EqualCase(it))).ToArray();
|
|
whereColumns = dataTable.Columns.Cast<DataColumn>().Select(it => it.ColumnName).Where(it => whereColumns.Any(z => z.EqualCase(it))).ToArray();
|
|
Check.ExceptionEasy(this.AsName.IsNullOrEmpty(), "need .AS(tablaeName) ", "需要 .AS(tablaeName) 设置表名");
|
|
return BulkUpdateAsync(this.AsName, dataTable, whereColumns, updateColumns).ConfigureAwait(true).GetAwaiter().GetResult();
|
|
}
|
|
public Task<int> BulkUpdateAsync(DataTable dataTable, string[] whereColumns)
|
|
{
|
|
string[] updateColumns = dataTable.Columns.Cast<DataColumn>().Select(it => it.ColumnName).Where(it => !whereColumns.Any(z => z.EqualCase(it))).ToArray();
|
|
whereColumns = dataTable.Columns.Cast<DataColumn>().Select(it => it.ColumnName).Where(it => whereColumns.Any(z => z.EqualCase(it))).ToArray();
|
|
Check.ExceptionEasy(this.AsName.IsNullOrEmpty(), "need .AS(tablaeName) ", "需要 .AS(tablaeName) 设置表名");
|
|
return BulkUpdateAsync(this.AsName, dataTable, whereColumns, updateColumns);
|
|
}
|
|
public async Task<int> BulkUpdateAsync(string tableName, DataTable dataTable, string[] whereColumns, string[] updateColumns)
|
|
{
|
|
|
|
if (Size > 0)
|
|
{
|
|
int resul = 0;
|
|
await this.context.Utilities.PageEachAsync(dataTable.Rows.Cast<DataRow>().ToList(), Size, async item =>
|
|
{
|
|
resul += await _BulkUpdate(tableName,item.CopyToDataTable(), whereColumns, updateColumns);
|
|
});
|
|
return resul;
|
|
}
|
|
else
|
|
{
|
|
return await _BulkUpdate(tableName,dataTable, whereColumns, updateColumns);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region BulkMerge
|
|
public Task<int> BulkMergeAsync(List<T> datas)
|
|
{
|
|
var updateColumns = entityInfo.Columns.Where(it => !it.IsPrimarykey && !it.IsIdentity && !it.IsOnlyIgnoreUpdate && !it.IsIgnore).Select(it => it.DbColumnName ?? it.PropertyName).ToArray();
|
|
var whereColumns = entityInfo.Columns.Where(it => it.IsPrimarykey).Select(it => it.DbColumnName ?? it.PropertyName).ToArray(); ;
|
|
return BulkMergeAsync(datas, whereColumns, updateColumns);
|
|
}
|
|
public int BulkMerge(List<T> datas)
|
|
{
|
|
return BulkMergeAsync(datas).GetAwaiter().GetResult();
|
|
}
|
|
public int BulkMerge(DataTable dataTable, string[] whereColumns,bool isIdentity)
|
|
{
|
|
object newValue, fastestMethod;
|
|
MethodInfo bulkCopyMethod;
|
|
_BulkMerge(dataTable, whereColumns, out newValue, out fastestMethod, out bulkCopyMethod,false,isIdentity);
|
|
var result = (int)bulkCopyMethod.Invoke(fastestMethod, new object[] { newValue });
|
|
return result;
|
|
}
|
|
public Task<int> BulkMergeAsync(DataTable dataTable, string[] whereColumns, bool isIdentity)
|
|
{
|
|
object newValue, fastestMethod;
|
|
MethodInfo bulkCopyMethod;
|
|
_BulkMerge(dataTable, whereColumns, out newValue, out fastestMethod, out bulkCopyMethod,true,isIdentity);
|
|
var result = (Task<int>)bulkCopyMethod.Invoke(fastestMethod, new object[] { newValue });
|
|
return result;
|
|
}
|
|
public Task<int> BulkMergeAsync(List<T> datas, string[] whereColumns)
|
|
{
|
|
var updateColumns = entityInfo.Columns.Where(it => !it.IsPrimarykey && !it.IsIdentity && !it.IsOnlyIgnoreUpdate && !it.IsIgnore).Select(it => it.DbColumnName ?? it.PropertyName).ToArray();
|
|
return BulkMergeAsync(datas, whereColumns, updateColumns);
|
|
}
|
|
public int BulkMerge(List<T> datas, string[] whereColumns)
|
|
{
|
|
return BulkMergeAsync(datas, whereColumns).GetAwaiter().GetResult();
|
|
}
|
|
public async Task<int> BulkMergeAsync(List<T> datas, string[] whereColumns, string[] updateColumns)
|
|
{
|
|
if (Size > 0)
|
|
{
|
|
int resul = 0;
|
|
await this.context.Utilities.PageEachAsync(datas, Size, async item =>
|
|
{
|
|
resul += await _BulkMerge(item, updateColumns, whereColumns);
|
|
});
|
|
return resul;
|
|
}
|
|
else
|
|
{
|
|
return await _BulkMerge(datas, updateColumns, whereColumns);
|
|
}
|
|
}
|
|
public int BulkMerge(List<T> datas, string[] whereColumns, string[] updateColumns)
|
|
{
|
|
return BulkMergeAsync(datas, whereColumns, updateColumns).GetAwaiter().GetResult();
|
|
}
|
|
|
|
private async Task<int> _BulkMerge(List<T> datas, string[] updateColumns, string[] whereColumns)
|
|
{
|
|
try
|
|
{
|
|
Begin(datas, false, true);
|
|
Check.Exception(whereColumns == null || whereColumns.Count() == 0, "where columns count=0 or need primary key");
|
|
Check.Exception(whereColumns == null || whereColumns.Count() == 0, "where columns count=0 or need primary key");
|
|
var isAuto = this.context.CurrentConnectionConfig.IsAutoCloseConnection;
|
|
this.context.CurrentConnectionConfig.IsAutoCloseConnection = false;
|
|
var old = this.context.Ado.IsDisableMasterSlaveSeparation;
|
|
this.context.Ado.IsDisableMasterSlaveSeparation = true;
|
|
DataTable dt = ToDdateTable(datas);
|
|
IFastBuilder buider = GetBuider();
|
|
buider.Context = context;
|
|
if (buider?.DbFastestProperties?.IsMerge == true)
|
|
{
|
|
await buider.CreateTempAsync<T>(dt);
|
|
await buider.ExecuteBulkCopyAsync(dt);
|
|
}
|
|
var result = await buider.Merge(GetTableName(), dt, this.entityInfo, whereColumns, updateColumns, datas);
|
|
//var queryTemp = this.context.Queryable<T>().AS(dt.TableName).ToList();//test
|
|
//var result = await buider.UpdateByTempAsync(GetTableName(), dt.TableName, updateColumns, whereColumns);
|
|
if (buider?.DbFastestProperties?.IsMerge == true && this.context.CurrentConnectionConfig.DbType != DbType.Sqlite)
|
|
{
|
|
this.context.DbMaintenance.DropTable(dt.TableName);
|
|
}
|
|
this.context.CurrentConnectionConfig.IsAutoCloseConnection = isAuto;
|
|
buider.CloseDb();
|
|
End(datas, false, true);
|
|
this.context.Ado.IsDisableMasterSlaveSeparation = old;
|
|
return result;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
this.context.Close();
|
|
throw;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Core
|
|
private void _BulkMerge(DataTable dataTable, string[] whereColumns, out object newValue, out object fastestMethod, out MethodInfo bulkCopyMethod,bool isAsync, bool isIdentity)
|
|
{
|
|
Check.ExceptionEasy(this.AsName.IsNullOrEmpty(), "need .AS(tablaeName) ", "需要 .AS(tablaeName) 设置表名");
|
|
var className = "BulkMerge_" +isIdentity+ this.AsName.GetNonNegativeHashCodeString();
|
|
var builder = this.context.DynamicBuilder().CreateClass(className, new SugarTable()
|
|
{
|
|
TableName = this.AsName
|
|
});
|
|
foreach (DataColumn item in dataTable.Columns)
|
|
{
|
|
var isPrimaryKey = whereColumns.Any(it => it.EqualCase(item.ColumnName));
|
|
var propertyType = item.DataType;
|
|
if (!propertyType.IsClass()&& propertyType!=typeof(string) && propertyType != typeof(byte[]))
|
|
{
|
|
propertyType=typeof(Nullable<>).MakeGenericType(UtilMethods.GetUnderType(item.DataType));
|
|
}
|
|
builder.CreateProperty(item.ColumnName, propertyType, new SugarColumn()
|
|
{
|
|
IsPrimaryKey = isPrimaryKey,
|
|
IsIdentity=isIdentity&& isPrimaryKey,
|
|
IsNullable= true,
|
|
|
|
});
|
|
}
|
|
var dicList = this.context.Utilities.DataTableToDictionaryList(dataTable);
|
|
var type = builder.WithCache().BuilderType();
|
|
var value = this.context.DynamicBuilder().CreateObjectByType(type, dicList);
|
|
newValue = UtilMethods.ConvertToObjectList(type, value);
|
|
fastestMethod = this.context.GetType()
|
|
.GetMethod("Fastest")
|
|
.MakeGenericMethod(type)
|
|
.Invoke(this.context, null);
|
|
bulkCopyMethod = fastestMethod.GetType().GetMyMethod(isAsync? "BulkMergeAsync" : "BulkMerge", 1);
|
|
}
|
|
|
|
private async Task<int> _BulkUpdate(List<T> datas, string[] whereColumns, string[] updateColumns)
|
|
{
|
|
try
|
|
{
|
|
Begin(datas, false);
|
|
Check.Exception(whereColumns == null || whereColumns.Count() == 0, "where columns count=0 or need primary key");
|
|
Check.Exception(updateColumns == null || updateColumns.Count() == 0, "set columns count=0");
|
|
var isAuto = this.context.CurrentConnectionConfig.IsAutoCloseConnection;
|
|
this.context.CurrentConnectionConfig.IsAutoCloseConnection = false;
|
|
var old = this.context.Ado.IsDisableMasterSlaveSeparation;
|
|
this.context.Ado.IsDisableMasterSlaveSeparation = true;
|
|
DataTable dt = ToDdateTable(datas);
|
|
IFastBuilder buider = GetBuider();
|
|
ActionIgnoreColums(whereColumns, updateColumns, dt, buider.IsActionUpdateColumns);
|
|
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);
|
|
if (this.context.CurrentConnectionConfig.DbType != DbType.Sqlite)
|
|
{
|
|
this.context.DbMaintenance.DropTable(dt.TableName);
|
|
}
|
|
this.context.CurrentConnectionConfig.IsAutoCloseConnection = isAuto;
|
|
buider.CloseDb();
|
|
this.context.Ado.IsDisableMasterSlaveSeparation = old;
|
|
End(datas, false);
|
|
return result;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
this.context.Close();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
private void ActionIgnoreColums(string[] whereColumns, string[] updateColumns, DataTable dt,bool IsActionUpdateColumns)
|
|
{
|
|
if (entityInfo.Columns.Where(it => it.IsIgnore == false).Count() > whereColumns.Length + updateColumns.Length &&IsActionUpdateColumns)
|
|
{
|
|
var ignoreColums = dt.Columns.Cast<DataColumn>()
|
|
.Where(it => !whereColumns.Any(y => y.EqualCase(it.ColumnName)))
|
|
.Where(it => !updateColumns.Any(y => y.EqualCase(it.ColumnName))).ToList();
|
|
foreach (DataRow item in dt.Rows)
|
|
{
|
|
foreach (var col in ignoreColums)
|
|
{
|
|
if (item[col.ColumnName].IsNullOrEmpty())
|
|
{
|
|
if (col.DataType == UtilConstants.StringType)
|
|
{
|
|
item[col.ColumnName] = string.Empty;
|
|
if (this.queryable?.SqlBuilder?.SqlParameterKeyWord == ":")
|
|
{
|
|
item[col.ColumnName] = " ";
|
|
};
|
|
}
|
|
else if (col.DataType == UtilConstants.DateType)
|
|
{
|
|
item[col.ColumnName] =UtilMethods.GetMinDate(this.context.CurrentConnectionConfig);
|
|
}
|
|
else
|
|
{
|
|
item[col.ColumnName] = Activator.CreateInstance(col.DataType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private async Task<int> _BulkUpdate(string tableName,DataTable dataTable, string[] whereColumns, string[] updateColumns)
|
|
{
|
|
var datas = new string[dataTable.Rows.Count].ToList();
|
|
Begin(datas, false);
|
|
Check.Exception(whereColumns == null || whereColumns.Count() == 0, "where columns count=0 or need primary key");
|
|
Check.Exception(updateColumns == null || updateColumns.Count() == 0, "set columns count=0");
|
|
var isAuto = this.context.CurrentConnectionConfig.IsAutoCloseConnection;
|
|
this.context.CurrentConnectionConfig.IsAutoCloseConnection = false;
|
|
var old = this.context.Ado.IsDisableMasterSlaveSeparation;
|
|
this.context.Ado.IsDisableMasterSlaveSeparation = true;
|
|
dataTable.TableName = this.queryable.SqlBuilder.GetTranslationTableName(tableName);
|
|
DataTable dt = GetCopyWriteDataTableUpdate(dataTable);
|
|
IFastBuilder buider = GetBuider();
|
|
if (dt.Columns.Count != dataTable.Columns.Count)
|
|
{
|
|
ActionIgnoreColums(whereColumns, updateColumns, dt, buider.IsActionUpdateColumns);
|
|
}
|
|
buider.Context = context;
|
|
if (buider.DbFastestProperties == null)
|
|
{
|
|
buider.DbFastestProperties = new DbFastestProperties();
|
|
}
|
|
buider.DbFastestProperties.WhereColumns = whereColumns;
|
|
await buider.CreateTempAsync<object>(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);
|
|
if (this.context.CurrentConnectionConfig.DbType != DbType.Sqlite)
|
|
{
|
|
this.context.DbMaintenance.DropTable(dt.TableName);
|
|
}
|
|
this.context.CurrentConnectionConfig.IsAutoCloseConnection = isAuto;
|
|
buider.CloseDb();
|
|
this.context.Ado.IsDisableMasterSlaveSeparation = old;
|
|
End(datas, false);
|
|
return result;
|
|
}
|
|
private async Task<int> _BulkCopy(List<T> datas)
|
|
{
|
|
Begin(datas,true);
|
|
DataTable dt = ToDdateTable(datas);
|
|
IFastBuilder buider =GetBuider();
|
|
buider.Context = context;
|
|
var result = await buider.ExecuteBulkCopyAsync(dt);
|
|
End(datas,true);
|
|
return result;
|
|
}
|
|
private async Task<int> _BulkCopy(string tableName,DataTable dataTable)
|
|
{
|
|
var datas =new string[dataTable.Rows.Count].ToList();
|
|
Begin(datas, true);
|
|
DataTable dt = dataTable;
|
|
dt.TableName =this.queryable.SqlBuilder.GetTranslationTableName(tableName);
|
|
dt = GetCopyWriteDataTable(dt);
|
|
IFastBuilder buider = GetBuider();
|
|
buider.Context = context;
|
|
var result = await buider.ExecuteBulkCopyAsync(dt);
|
|
End(datas, true);
|
|
return result;
|
|
}
|
|
#endregion
|
|
|
|
#region AOP
|
|
private void End<Type>(List<Type> datas,bool isAdd,bool isMerge=false)
|
|
{
|
|
var title = isAdd ? "BulkCopy" : "BulkUpdate";
|
|
if (isMerge)
|
|
{
|
|
title = "BulkMerge";
|
|
}
|
|
this.context.Ado.IsEnableLogEvent = isLog;
|
|
if (this.context.CurrentConnectionConfig?.AopEvents?.OnLogExecuted != null)
|
|
{
|
|
this.context.CurrentConnectionConfig?.AopEvents?.OnLogExecuted($"End {title} name:{GetTableName()} ,count: {datas.Count},current time: {DateTime.Now}", new SugarParameter[] { });
|
|
}
|
|
RemoveCache();
|
|
}
|
|
private void Begin<Type>(List<Type> datas,bool isAdd, bool isMerge = false)
|
|
{
|
|
var title = isAdd ? "BulkCopy" : "BulkUpdate";
|
|
if (isMerge)
|
|
{
|
|
title = "BulkMerge";
|
|
}
|
|
isLog = this.context.Ado.IsEnableLogEvent;
|
|
this.context.Ado.IsEnableLogEvent = false;
|
|
if (this.context.CurrentConnectionConfig?.AopEvents?.OnLogExecuting != null)
|
|
{
|
|
this.context.CurrentConnectionConfig?.AopEvents?.OnLogExecuting($"Begin {title} name:{GetTableName()} ,count: {datas.Count},current time: {DateTime.Now} ", new SugarParameter[] { });
|
|
}
|
|
var dataEvent = this.context.CurrentConnectionConfig.AopEvents?.DataExecuting;
|
|
if (IsDataAop&&dataEvent!=null)
|
|
{
|
|
var entity = this.context.EntityMaintenance.GetEntityInfo(typeof(Type));
|
|
foreach (var item in datas)
|
|
{
|
|
DataAop(item, isAdd
|
|
?
|
|
DataFilterType.InsertByObject:
|
|
DataFilterType.UpdateByObject
|
|
, entity);
|
|
}
|
|
}
|
|
}
|
|
private void DataAop<Type>(Type item, DataFilterType type,EntityInfo entity)
|
|
{
|
|
var dataEvent = this.context.CurrentConnectionConfig.AopEvents?.DataExecuting;
|
|
if (dataEvent != null && item != null)
|
|
{
|
|
foreach (var columnInfo in entity.Columns)
|
|
{
|
|
dataEvent(columnInfo.PropertyInfo.GetValue(item, null), new DataFilterModel() { OperationType = type, EntityValue = item, EntityColumnInfo = columnInfo });
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
}
|