tk/FreeSql
1
0
Fork 0
mirror of https://github.com/nsnail/FreeSql.git synced 2025-06-18 03:53:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

- 调整 DbSet/Repository DeleteCascadeByDatabase/Delete 区别于数据库/内存的级联删除；#609

Browse Source
This commit is contained in:
2881099 2022-05-04 22:38:17 +08:00
parent a80d2cdf9d
commit 0ecab32f34
40 changed files with 420 additions and 355 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
FreeSql.DbContext/DbContext/DbContext.cs
View File

@ -46,7 +46,7 @@ namespace FreeSql
_optionsPriv = new DbContextOptions(); _optionsPriv = new DbContextOptions();
if (FreeSqlDbContextExtensions._dicSetDbContextOptions.TryGetValue(OrmOriginal.Ado.Identifier, out var opt)) if (FreeSqlDbContextExtensions._dicSetDbContextOptions.TryGetValue(OrmOriginal.Ado.Identifier, out var opt))
{ {
_optionsPriv.EnableAddOrUpdateNavigate = opt.EnableAddOrUpdateNavigate; _optionsPriv.EnableCascadeSave = opt.EnableCascadeSave;
_optionsPriv.EnableGlobalFilter = opt.EnableGlobalFilter; _optionsPriv.EnableGlobalFilter = opt.EnableGlobalFilter;
_optionsPriv.NoneParameter = opt.NoneParameter; _optionsPriv.NoneParameter = opt.NoneParameter;
_optionsPriv.OnEntityChange = opt.OnEntityChange; _optionsPriv.OnEntityChange = opt.OnEntityChange;
@ -225,29 +225,29 @@ namespace FreeSql
} }
#if net40 #if net40
#else #else
public Task AddAsync<TEntity>(TEntity data) where TEntity : class public Task AddAsync<TEntity>(TEntity data, CancellationToken cancellationToken = default) where TEntity : class
{ {
CheckEntityTypeOrThrow(typeof(TEntity)); CheckEntityTypeOrThrow(typeof(TEntity));
return this.Set<TEntity>().AddAsync(data); return this.Set<TEntity>().AddAsync(data, cancellationToken);
} }
public Task AddRangeAsync<TEntity>(IEnumerable<TEntity> data) where TEntity : class => this.Set<TEntity>().AddRangeAsync(data); public Task AddRangeAsync<TEntity>(IEnumerable<TEntity> data, CancellationToken cancellationToken = default) where TEntity : class => this.Set<TEntity>().AddRangeAsync(data, cancellationToken);
public Task UpdateAsync<TEntity>(TEntity data) where TEntity : class public Task UpdateAsync<TEntity>(TEntity data, CancellationToken cancellationToken = default) where TEntity : class
{ {
CheckEntityTypeOrThrow(typeof(TEntity)); CheckEntityTypeOrThrow(typeof(TEntity));
return this.Set<TEntity>().UpdateAsync(data); return this.Set<TEntity>().UpdateAsync(data, cancellationToken);
} }
public Task UpdateRangeAsync<TEntity>(IEnumerable<TEntity> data) where TEntity : class => this.Set<TEntity>().UpdateRangeAsync(data); public Task UpdateRangeAsync<TEntity>(IEnumerable<TEntity> data, CancellationToken cancellationToken = default) where TEntity : class => this.Set<TEntity>().UpdateRangeAsync(data, cancellationToken);
public Task AddOrUpdateAsync<TEntity>(TEntity data) where TEntity : class public Task AddOrUpdateAsync<TEntity>(TEntity data, CancellationToken cancellationToken = default) where TEntity : class
{ {
CheckEntityTypeOrThrow(typeof(TEntity)); CheckEntityTypeOrThrow(typeof(TEntity));
return this.Set<TEntity>().AddOrUpdateAsync(data); return this.Set<TEntity>().AddOrUpdateAsync(data, cancellationToken);
} }
public Task SaveManyAsync<TEntity>(TEntity data, string propertyName) where TEntity : class public Task SaveManyAsync<TEntity>(TEntity data, string propertyName, CancellationToken cancellationToken = default) where TEntity : class
{ {
CheckEntityTypeOrThrow(typeof(TEntity)); CheckEntityTypeOrThrow(typeof(TEntity));
return this.Set<TEntity>().SaveManyAsync(data, propertyName); return this.Set<TEntity>().SaveManyAsync(data, propertyName, cancellationToken);
} }
#endif #endif
#endregion #endregion

10
FreeSql.DbContext/DbContext/DbContextOptions.cs
View File

@ -21,16 +21,16 @@ namespace FreeSql
/// - 属性集合为空时(!=null)，删除他们的所有关联数据（中间表）<para></para> /// - 属性集合为空时(!=null)，删除他们的所有关联数据（中间表）<para></para>
/// - 属性集合不为空时，与数据库存在的关联数据（中间表）完全对比，计算出应该删除和添加的记录 /// - 属性集合不为空时，与数据库存在的关联数据（中间表）完全对比，计算出应该删除和添加的记录
/// </summary> /// </summary>
public bool EnableAddOrUpdateNavigate { get; set; } = false; public bool EnableCascadeSave { get; set; } = false;
/// <summary> /// <summary>
/// 因增加支持 OneToOne 级联保存，请了解机制，已改名为 EnableAddOrUpdateNavigate /// 因增加支持 OneToOne 级联保存，和基于内存的级联删除，已改名为 EnableCascadeSave
/// </summary> /// </summary>
[Obsolete("因增加支持 OneToOne 级联保存，请了解机制，已改名为 EnableAddOrUpdateNavigate")] [Obsolete("因增加支持 OneToOne 级联保存，和基于内存的级联删除，已改名为 EnableCascadeSave")]
public bool EnableAddOrUpdateNavigateList public bool EnableAddOrUpdateNavigateList
{ {
get => EnableAddOrUpdateNavigate; get => EnableCascadeSave;
set => EnableAddOrUpdateNavigate = value; set => EnableCascadeSave = value;
} }
/// <summary> /// <summary>

9
FreeSql.DbContext/DbSet/DbSet.cs
View File

@ -166,6 +166,15 @@ namespace FreeSql
{ {
ds.AttachRange(_states.Values.OrderBy(a => a.Time).Select(a => a.Value).ToArray()); ds.AttachRange(_states.Values.OrderBy(a => a.Time).Select(a => a.Value).ToArray());
} }
void StatesRemoveByObjects(IEnumerable<object> data)
{
if (data == null) return;
foreach (var item in data)
{
var stateKey = _db.OrmOriginal.GetEntityKeyString(_entityType, item, false);
_states.TryRemove(stateKey, out var trystate);
}
}
public class EntityState public class EntityState
{ {

172
FreeSql.DbContext/DbSet/DbSetAsync.cs
View File

@ -55,7 +55,7 @@ namespace FreeSql
_db.OrmOriginal.SetEntityValueWithPropertyName(_entityType, data, _tableIdentitys[0].CsName, idtval); _db.OrmOriginal.SetEntityValueWithPropertyName(_entityType, data, _tableIdentitys[0].CsName, idtval);
_db._entityChangeReport.Add(new DbContext.EntityChangeReport.ChangeInfo { Object = data, Type = DbContext.EntityChangeType.Insert }); _db._entityChangeReport.Add(new DbContext.EntityChangeReport.ChangeInfo { Object = data, Type = DbContext.EntityChangeType.Insert });
Attach(data); Attach(data);
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
await AddOrUpdateNavigateAsync(data, true, null, cancellationToken); await AddOrUpdateNavigateAsync(data, true, null, cancellationToken);
} }
else else
@ -66,7 +66,7 @@ namespace FreeSql
IncrAffrows(1); IncrAffrows(1);
_db.OrmOriginal.MapEntityValue(_entityType, newval, data); _db.OrmOriginal.MapEntityValue(_entityType, newval, data);
Attach(newval); Attach(newval);
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
await AddOrUpdateNavigateAsync(data, true, null, cancellationToken); await AddOrUpdateNavigateAsync(data, true, null, cancellationToken);
} }
return; return;
@ -79,7 +79,7 @@ namespace FreeSql
_db.OrmOriginal.SetEntityValueWithPropertyName(_entityType, data, _tableIdentitys[0].CsName, idtval); _db.OrmOriginal.SetEntityValueWithPropertyName(_entityType, data, _tableIdentitys[0].CsName, idtval);
_db._entityChangeReport.Add(new DbContext.EntityChangeReport.ChangeInfo { Object = data, Type = DbContext.EntityChangeType.Insert }); _db._entityChangeReport.Add(new DbContext.EntityChangeReport.ChangeInfo { Object = data, Type = DbContext.EntityChangeType.Insert });
Attach(data); Attach(data);
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
await AddOrUpdateNavigateAsync(data, true, null, cancellationToken); await AddOrUpdateNavigateAsync(data, true, null, cancellationToken);
return; return;
} }
@ -88,7 +88,7 @@ namespace FreeSql
} }
EnqueueToDbContext(DbContext.EntityChangeType.Insert, CreateEntityState(data)); EnqueueToDbContext(DbContext.EntityChangeType.Insert, CreateEntityState(data));
Attach(data); Attach(data);
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
await AddOrUpdateNavigateAsync(data, true, null, cancellationToken); await AddOrUpdateNavigateAsync(data, true, null, cancellationToken);
} }
public Task AddAsync(TEntity data, CancellationToken cancellationToken = default) => AddPrivAsync(data, true, cancellationToken); public Task AddAsync(TEntity data, CancellationToken cancellationToken = default) => AddPrivAsync(data, true, cancellationToken);
@ -121,7 +121,7 @@ namespace FreeSql
_db.OrmOriginal.MapEntityValue(_entityType, rets[idx++], s); _db.OrmOriginal.MapEntityValue(_entityType, rets[idx++], s);
IncrAffrows(rets.Count); IncrAffrows(rets.Count);
AttachRange(rets); AttachRange(rets);
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
foreach (var item in data) foreach (var item in data)
await AddOrUpdateNavigateAsync(item, true, null, cancellationToken); await AddOrUpdateNavigateAsync(item, true, null, cancellationToken);
return; return;
@ -139,7 +139,7 @@ namespace FreeSql
foreach (var item in data) foreach (var item in data)
EnqueueToDbContext(DbContext.EntityChangeType.Insert, CreateEntityState(item)); EnqueueToDbContext(DbContext.EntityChangeType.Insert, CreateEntityState(item));
AttachRange(data); AttachRange(data);
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
foreach (var item in data) foreach (var item in data)
await AddOrUpdateNavigateAsync(item, true, null, cancellationToken); await AddOrUpdateNavigateAsync(item, true, null, cancellationToken);
} }
@ -161,8 +161,8 @@ namespace FreeSql
} }
await DbContextFlushCommandAsync(cancellationToken); await DbContextFlushCommandAsync(cancellationToken);
var oldEnable = _db.Options.EnableAddOrUpdateNavigate; var oldEnable = _db.Options.EnableCascadeSave;
_db.Options.EnableAddOrUpdateNavigate = false; _db.Options.EnableCascadeSave = false;
try try
{ {
await AddOrUpdateNavigateAsync(item, false, propertyName, cancellationToken); await AddOrUpdateNavigateAsync(item, false, propertyName, cancellationToken);
@ -198,7 +198,7 @@ namespace FreeSql
} }
finally finally
{ {
_db.Options.EnableAddOrUpdateNavigate = oldEnable; _db.Options.EnableCascadeSave = oldEnable;
} }
} }
async Task AddOrUpdateNavigateAsync(TEntity item, bool isAdd, string propertyName, CancellationToken cancellationToken) async Task AddOrUpdateNavigateAsync(TEntity item, bool isAdd, string propertyName, CancellationToken cancellationToken)
@ -447,7 +447,7 @@ namespace FreeSql
state.OldValue = item; state.OldValue = item;
EnqueueToDbContext(DbContext.EntityChangeType.Update, state); EnqueueToDbContext(DbContext.EntityChangeType.Update, state);
} }
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
foreach (var item in data) foreach (var item in data)
await AddOrUpdateNavigateAsync(item, false, null, cancellationToken); await AddOrUpdateNavigateAsync(item, false, null, cancellationToken);
} }
@ -499,155 +499,11 @@ namespace FreeSql
#endregion #endregion
#region RemoveCascadeAsync #region RemoveCascadeAsync
public Task<List<object>> RemoveCascadeAsync(TEntity data, CancellationToken cancellationToken = default) => RemoveRangeCascadeAsync(new[] { data }, cancellationToken); public Task<List<object>> RemoveCascadeByDatabaseAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default) => RemoveRangeCascadeByMemoryOrDatabaseAsync(Select.Where(predicate).ToList(), false, cancellationToken);
public Task<List<object>> RemoveCascadeAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default) => RemoveRangeCascadeAsync(Select.Where(predicate).ToList(), cancellationToken); async internal protected Task<List<object>> RemoveRangeCascadeByMemoryOrDatabaseAsync(IEnumerable<TEntity> data, bool inMemory, CancellationToken cancellationToken = default)
async public Task<List<object>> RemoveRangeCascadeAsync(IEnumerable<TEntity> data, CancellationToken cancellationToken = default)
{ {
var returnDeleted = new List<object>(); //临时调用同步方法，后续会改
if (data?.Any() != true) return returnDeleted; return await Task.FromResult(RemoveRangeCascadeByMemoryOrDatabase(data, inMemory));
await DbContextFlushCommandAsync(cancellationToken);
var fsql = _db.Orm;
if (LocalGetNavigates(_table).Any() == false)
{
if (CanRemove(data, true) == false) return returnDeleted;
foreach (var item in data) //防止清除 Identity/Guid
{
var state = CreateEntityState(item);
_states.TryRemove(state.Key, out var trystate);
EnqueueToDbContext(DbContext.EntityChangeType.Delete, state);
}
await DbContextFlushCommandAsync(cancellationToken);
returnDeleted.AddRange(data.Select(a => (object)a));
return returnDeleted;
}
var commonUtils = (fsql.Select<object>() as Internal.CommonProvider.Select0Provider)._commonUtils;
var eachdic = new Dictionary<string, bool>();
var rootItems = data.Select(a => (object)a).ToArray();
var rootDbSet = _db.Set<object>();
rootDbSet.AsType(_table.Type);
rootDbSet.AttachRange(rootItems);
await LocalEachAsync(rootDbSet, rootItems, true);
return returnDeleted;
List<NativeTuple<TableRef, PropertyInfo>> LocalGetNavigates(TableInfo tb)
{
return tb.Properties.Where(a => tb.ColumnsByCs.ContainsKey(a.Key) == false)
.Select(a => new NativeTuple<TableRef, PropertyInfo>(tb.GetTableRef(a.Key, false), a.Value))
.Where(a => a.Item1 != null && a.Item1.RefType != TableRefType.ManyToOne)
.ToList();
}
async Task LocalEachAsync(DbSet<object> dbset, IEnumerable<object> items, bool isOneToOne)
{
items = items?.Where(item =>
{
var itemkeyStr = FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetEntityKeyString(fsql, dbset.EntityType, item, false);
var eachdicKey = $"{dbset.EntityType.FullName},{itemkeyStr}";
if (eachdic.ContainsKey(eachdicKey)) return false;
eachdic.Add(eachdicKey, true);
return true;
}).ToList();
if (items?.Any() != true) return;
var tb = fsql.CodeFirst.GetTableByEntity(dbset.EntityType);
var navs = LocalGetNavigates(tb);
var otos = navs.Where(a => a.Item1.RefType == TableRefType.OneToOne).ToList();
if (isOneToOne && otos.Any())
{
foreach (var oto in otos)
{
var childTable = fsql.CodeFirst.GetTableByEntity(oto.Item1.RefEntityType);
var childDbSet = _db.Set<object>();
childDbSet.AsType(oto.Item1.RefEntityType);
var refitems = items.Select(item =>
{
var refitem = oto.Item1.RefEntityType.CreateInstanceGetDefaultValue();
for (var a = 0; a < oto.Item1.Columns.Count; a++)
{
var colval = FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetPropertyValue(tb, item, oto.Item1.Columns[a].CsName);
FreeSql.Extensions.EntityUtil.EntityUtilExtensions.SetPropertyValue(childTable, refitem, oto.Item1.RefColumns[a].CsName, colval);
}
return refitem;
}).ToList();
var childs = await childDbSet.Select.Where(commonUtils.WhereItems(oto.Item1.RefColumns.ToArray(), "a.", refitems)).ToListAsync(false, cancellationToken);
await LocalEachAsync(childDbSet, childs, false);
}
}
var otms = navs.Where(a => a.Item1.RefType == TableRefType.OneToMany).ToList();
if (otms.Any())
{
foreach (var otm in otms)
{
var childTable = fsql.CodeFirst.GetTableByEntity(otm.Item1.RefEntityType);
var childDbSet = _db.Set<object>();
childDbSet.AsType(otm.Item1.RefEntityType);
var refitems = items.Select(item =>
{
var refitem = otm.Item1.RefEntityType.CreateInstanceGetDefaultValue();
for (var a = 0; a < otm.Item1.Columns.Count; a++)
{
var colval = FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetPropertyValue(tb, item, otm.Item1.Columns[a].CsName);
FreeSql.Extensions.EntityUtil.EntityUtilExtensions.SetPropertyValue(childTable, refitem, otm.Item1.RefColumns[a].CsName, colval);
}
return refitem;
}).ToList();
var childs = await childDbSet.Select.Where(commonUtils.WhereItems(otm.Item1.RefColumns.ToArray(), "a.", refitems)).ToListAsync(false, cancellationToken);
await LocalEachAsync(childDbSet, childs, true);
}
}
var mtms = navs.Where(a => a.Item1.RefType == TableRefType.ManyToMany).ToList();
if (mtms.Any())
{
foreach (var mtm in mtms)
{
var childTable = fsql.CodeFirst.GetTableByEntity(mtm.Item1.RefMiddleEntityType);
var childDbSet = _db.Set<object>();
childDbSet.AsType(mtm.Item1.RefMiddleEntityType);
var miditems = items.Select(item =>
{
var refitem = mtm.Item1.RefMiddleEntityType.CreateInstanceGetDefaultValue();
for (var a = 0; a < mtm.Item1.Columns.Count; a++)
{
var colval = FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetPropertyValue(tb, item, mtm.Item1.Columns[a].CsName);
FreeSql.Extensions.EntityUtil.EntityUtilExtensions.SetPropertyValue(childTable, refitem, mtm.Item1.MiddleColumns[a].CsName, colval);
}
return refitem;
}).ToList();
var childs = await childDbSet.Select.Where(commonUtils.WhereItems(mtm.Item1.MiddleColumns.Take(mtm.Item1.Columns.Count).ToArray(), "a.", miditems)).ToListAsync(false, cancellationToken);
await LocalEachAsync(childDbSet, childs, true);
}
}
if (dbset == rootDbSet)
{
if (CanRemove(data, true) == false) return;
foreach (var item in data) //防止清除 Identity/Guid
{
var state = CreateEntityState(item);
_states.TryRemove(state.Key, out var trystate);
EnqueueToDbContext(DbContext.EntityChangeType.Delete, state);
}
await DbContextFlushCommandAsync(cancellationToken);
}
else
{
if (dbset.CanRemove(items, true) == false) return;
foreach (var item in items) //防止清除 Identity/Guid
{
var state = dbset.CreateEntityState(item);
dbset._states.TryRemove(state.Key, out var trystate);
dbset.EnqueueToDbContext(DbContext.EntityChangeType.Delete, state);
}
await DbContextFlushCommandAsync(cancellationToken);
}
returnDeleted.AddRange(items);
}
} }
#endregion #endregion
} }

160
FreeSql.DbContext/DbSet/DbSetSync.cs
View File

@ -53,7 +53,7 @@ namespace FreeSql
_db.OrmOriginal.SetEntityValueWithPropertyName(_entityType, data, _tableIdentitys[0].CsName, idtval); _db.OrmOriginal.SetEntityValueWithPropertyName(_entityType, data, _tableIdentitys[0].CsName, idtval);
_db._entityChangeReport.Add(new DbContext.EntityChangeReport.ChangeInfo { Object = data, Type = DbContext.EntityChangeType.Insert }); _db._entityChangeReport.Add(new DbContext.EntityChangeReport.ChangeInfo { Object = data, Type = DbContext.EntityChangeType.Insert });
Attach(data); Attach(data);
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
AddOrUpdateNavigate(data, true, null); AddOrUpdateNavigate(data, true, null);
} }
else else
@ -64,7 +64,7 @@ namespace FreeSql
IncrAffrows(1); IncrAffrows(1);
_db.OrmOriginal.MapEntityValue(_entityType, newval, data); _db.OrmOriginal.MapEntityValue(_entityType, newval, data);
Attach(newval); Attach(newval);
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
AddOrUpdateNavigate(data, true, null); AddOrUpdateNavigate(data, true, null);
} }
return; return;
@ -77,7 +77,7 @@ namespace FreeSql
_db.OrmOriginal.SetEntityValueWithPropertyName(_entityType, data, _tableIdentitys[0].CsName, idtval); _db.OrmOriginal.SetEntityValueWithPropertyName(_entityType, data, _tableIdentitys[0].CsName, idtval);
_db._entityChangeReport.Add(new DbContext.EntityChangeReport.ChangeInfo { Object = data, Type = DbContext.EntityChangeType.Insert }); _db._entityChangeReport.Add(new DbContext.EntityChangeReport.ChangeInfo { Object = data, Type = DbContext.EntityChangeType.Insert });
Attach(data); Attach(data);
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
AddOrUpdateNavigate(data, true, null); AddOrUpdateNavigate(data, true, null);
return; return;
} }
@ -86,7 +86,7 @@ namespace FreeSql
} }
EnqueueToDbContext(DbContext.EntityChangeType.Insert, CreateEntityState(data)); EnqueueToDbContext(DbContext.EntityChangeType.Insert, CreateEntityState(data));
Attach(data); Attach(data);
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
AddOrUpdateNavigate(data, true, null); AddOrUpdateNavigate(data, true, null);
} }
/// <summary> /// <summary>
@ -123,7 +123,7 @@ namespace FreeSql
_db.OrmOriginal.MapEntityValue(_entityType, rets[idx++], s); _db.OrmOriginal.MapEntityValue(_entityType, rets[idx++], s);
IncrAffrows(rets.Count); IncrAffrows(rets.Count);
AttachRange(rets); AttachRange(rets);
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
foreach (var item in data) foreach (var item in data)
AddOrUpdateNavigate(item, true, null); AddOrUpdateNavigate(item, true, null);
return; return;
@ -141,7 +141,7 @@ namespace FreeSql
foreach (var item in data) foreach (var item in data)
EnqueueToDbContext(DbContext.EntityChangeType.Insert, CreateEntityState(item)); EnqueueToDbContext(DbContext.EntityChangeType.Insert, CreateEntityState(item));
AttachRange(data); AttachRange(data);
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
foreach (var item in data) foreach (var item in data)
AddOrUpdateNavigate(item, true, null); AddOrUpdateNavigate(item, true, null);
} }
@ -172,8 +172,8 @@ namespace FreeSql
} }
DbContextFlushCommand(); DbContextFlushCommand();
var oldEnable = _db.Options.EnableAddOrUpdateNavigate; var oldEnable = _db.Options.EnableCascadeSave;
_db.Options.EnableAddOrUpdateNavigate = false; _db.Options.EnableCascadeSave = false;
try try
{ {
AddOrUpdateNavigate(item, false, propertyName); AddOrUpdateNavigate(item, false, propertyName);
@ -209,7 +209,7 @@ namespace FreeSql
} }
finally finally
{ {
_db.Options.EnableAddOrUpdateNavigate = oldEnable; _db.Options.EnableCascadeSave = oldEnable;
} }
} }
void AddOrUpdateNavigate(TEntity item, bool isAdd, string propertyName) void AddOrUpdateNavigate(TEntity item, bool isAdd, string propertyName)
@ -488,7 +488,7 @@ namespace FreeSql
state.OldValue = item; state.OldValue = item;
EnqueueToDbContext(DbContext.EntityChangeType.Update, state); EnqueueToDbContext(DbContext.EntityChangeType.Update, state);
} }
if (_db.Options.EnableAddOrUpdateNavigate) if (_db.Options.EnableCascadeSave)
foreach (var item in data) foreach (var item in data)
AddOrUpdateNavigate(item, false, null); AddOrUpdateNavigate(item, false, null);
} }
@ -510,6 +510,11 @@ namespace FreeSql
public void Remove(TEntity data) => RemoveRange(new[] { data }); public void Remove(TEntity data) => RemoveRange(new[] { data });
public void RemoveRange(IEnumerable<TEntity> data) public void RemoveRange(IEnumerable<TEntity> data)
{ {
if (_db.Options.EnableCascadeSave)
{
RemoveRangeCascadeByMemoryOrDatabase(data, true);
return;
}
if (CanRemove(data, true) == false) return; if (CanRemove(data, true) == false) return;
foreach (var item in data) foreach (var item in data)
{ {
@ -608,8 +613,8 @@ namespace FreeSql
if (data == null) data = _dataEditing; if (data == null) data = _dataEditing;
var beforeAffrows = 0; var beforeAffrows = 0;
if (data == null) return 0; if (data == null) return 0;
var oldEnable = _db.Options.EnableAddOrUpdateNavigate; var oldEnable = _db.Options.EnableCascadeSave;
_db.Options.EnableAddOrUpdateNavigate = false; _db.Options.EnableCascadeSave = false;
try try
{ {
DbContextFlushCommand(); DbContextFlushCommand();
@ -651,7 +656,7 @@ namespace FreeSql
{ {
_dataEditing = null; _dataEditing = null;
_statesEditing.Clear(); _statesEditing.Clear();
_db.Options.EnableAddOrUpdateNavigate = oldEnable; _db.Options.EnableCascadeSave = oldEnable;
} }
return _db._affrows - beforeAffrows; return _db._affrows - beforeAffrows;
} }
@ -659,33 +664,31 @@ namespace FreeSql
#region RemoveCascade #region RemoveCascade
/// <summary> /// <summary>
/// 根据设置的导航属性，递归查询删除 OneToOne/OneToMany/ManyToMany 数据，并返回已删除的数据 /// 根据设置的 OneToOne/OneToMany/ManyToMany 导航属性，级联查询所有的数据库记录，删除并返回它们
/// </summary> /// </summary>
/// <param name="data"></param> /// <param name="predicate"></param>
/// <returns></returns> /// <returns></returns>
public List<object> RemoveCascade(TEntity data) => RemoveRangeCascade(new[] { data }); public List<object> RemoveCascadeByDatabase(Expression<Func<TEntity, bool>> predicate) => RemoveRangeCascadeByMemoryOrDatabase(Select.Where(predicate).ToList(), false);
public List<object> RemoveCascade(Expression<Func<TEntity, bool>> predicate) => RemoveRangeCascade(Select.Where(predicate).ToList()); internal protected List<object> RemoveRangeCascadeByMemoryOrDatabase(IEnumerable<TEntity> data, bool inMemory)
public List<object> RemoveRangeCascade(IEnumerable<TEntity> data)
{ {
var returnDeleted = new List<object>(); var returnDeleted = inMemory ? null : new List<object>();
if (data?.Any() != true) return returnDeleted; if (data?.Any() != true) return returnDeleted;
DbContextFlushCommand();
var fsql = _db.Orm;
if (LocalGetNavigates(_table).Any() == false) if (LocalGetNavigates(_table).Any() == false)
{ {
if (CanRemove(data, true) == false) return returnDeleted; if (CanRemove(data, true) == false) return returnDeleted;
foreach (var item in data) //防止清除 Identity/Guid foreach (var item in data) //不直接调用 Remove，防止清除 Identity/Guid
{ {
var state = CreateEntityState(item); var state = CreateEntityState(item);
_states.TryRemove(state.Key, out var trystate); _states.TryRemove(state.Key, out var trystate);
if (inMemory) _db.OrmOriginal.ClearEntityPrimaryValueWithIdentityAndGuid(_entityType, item);
EnqueueToDbContext(DbContext.EntityChangeType.Delete, state); EnqueueToDbContext(DbContext.EntityChangeType.Delete, state);
} }
DbContextFlushCommand(); returnDeleted?.AddRange(data.Select(a => (object)a));
returnDeleted.AddRange(data.Select(a => (object)a));
return returnDeleted; return returnDeleted;
} }
var fsql = _db.Orm;
var commonUtils = (fsql.Select<object>() as Internal.CommonProvider.Select0Provider)._commonUtils; var commonUtils = (fsql.Select<object>() as Internal.CommonProvider.Select0Provider)._commonUtils;
var eachdic = new Dictionary<string, bool>(); var eachdic = new Dictionary<string, bool>();
var rootItems = data.Select(a => (object)a).ToArray(); var rootItems = data.Select(a => (object)a).ToArray();
@ -693,6 +696,7 @@ namespace FreeSql
rootDbSet.AsType(_table.Type); rootDbSet.AsType(_table.Type);
rootDbSet.AttachRange(rootItems); rootDbSet.AttachRange(rootItems);
LocalEach(rootDbSet, rootItems, true); LocalEach(rootDbSet, rootItems, true);
rootDbSet.FlushState();
return returnDeleted; return returnDeleted;
List<NativeTuple<TableRef, PropertyInfo>> LocalGetNavigates(TableInfo tb) List<NativeTuple<TableRef, PropertyInfo>> LocalGetNavigates(TableInfo tb)
@ -722,21 +726,31 @@ namespace FreeSql
{ {
foreach (var oto in otos) foreach (var oto in otos)
{ {
var childTable = fsql.CodeFirst.GetTableByEntity(oto.Item1.RefEntityType); var refset = _db.Set<object>();
var childDbSet = _db.Set<object>(); refset.AsType(oto.Item1.RefEntityType);
childDbSet.AsType(oto.Item1.RefEntityType);
var refitems = items.Select(item => if (inMemory)
{
var refitems = items.Select(item => FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetPropertyValue(tb, item, oto.Item2.Name)).Where(item => item != null).ToList();
refset.AttachRange(refitems);
LocalEach(refset, refitems, false);
}
else
{
var reftb = fsql.CodeFirst.GetTableByEntity(oto.Item1.RefEntityType);
var refwhereItems = items.Select(item =>
{ {
var refitem = oto.Item1.RefEntityType.CreateInstanceGetDefaultValue(); var refitem = oto.Item1.RefEntityType.CreateInstanceGetDefaultValue();
for (var a = 0; a < oto.Item1.Columns.Count; a++) for (var a = 0; a < oto.Item1.Columns.Count; a++)
{ {
var colval = FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetPropertyValue(tb, item, oto.Item1.Columns[a].CsName); var colval = FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetPropertyValue(tb, item, oto.Item1.Columns[a].CsName);
FreeSql.Extensions.EntityUtil.EntityUtilExtensions.SetPropertyValue(childTable, refitem, oto.Item1.RefColumns[a].CsName, colval); FreeSql.Extensions.EntityUtil.EntityUtilExtensions.SetPropertyValue(reftb, refitem, oto.Item1.RefColumns[a].CsName, colval);
} }
return refitem; return refitem;
}).ToList(); }).ToList();
var childs = childDbSet.Select.Where(commonUtils.WhereItems(oto.Item1.RefColumns.ToArray(), "a.", refitems)).ToList(); var refitems = refset.Select.Where(commonUtils.WhereItems(oto.Item1.RefColumns.ToArray(), "a.", refwhereItems)).ToList();
LocalEach(childDbSet, childs, false); LocalEach(refset, refitems, false);
}
} }
} }
@ -745,21 +759,38 @@ namespace FreeSql
{ {
foreach (var otm in otms) foreach (var otm in otms)
{ {
var childTable = fsql.CodeFirst.GetTableByEntity(otm.Item1.RefEntityType); var refset = _db.Set<object>();
var childDbSet = _db.Set<object>(); refset.AsType(otm.Item1.RefEntityType);
childDbSet.AsType(otm.Item1.RefEntityType);
if (inMemory)
{
var refitems = items.Select(item => var refitems = items.Select(item =>
{
var reflist = new List<object>();
var reflistie = FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetPropertyValue(tb, item, otm.Item2.Name) as IEnumerable;
if (reflistie == null) return null;
foreach (var refitem in reflistie) reflist.Add(refitem);
return reflist;
}).Where(itemlst => itemlst != null).SelectMany(itemlst => itemlst).ToList();
refset.AttachRange(refitems);
LocalEach(refset, refitems, true);
}
else
{
var reftb = fsql.CodeFirst.GetTableByEntity(otm.Item1.RefEntityType);
var refwhereItems = items.Select(item =>
{ {
var refitem = otm.Item1.RefEntityType.CreateInstanceGetDefaultValue(); var refitem = otm.Item1.RefEntityType.CreateInstanceGetDefaultValue();
for (var a = 0; a < otm.Item1.Columns.Count; a++) for (var a = 0; a < otm.Item1.Columns.Count; a++)
{ {
var colval = FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetPropertyValue(tb, item, otm.Item1.Columns[a].CsName); var colval = FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetPropertyValue(tb, item, otm.Item1.Columns[a].CsName);
FreeSql.Extensions.EntityUtil.EntityUtilExtensions.SetPropertyValue(childTable, refitem, otm.Item1.RefColumns[a].CsName, colval); FreeSql.Extensions.EntityUtil.EntityUtilExtensions.SetPropertyValue(reftb, refitem, otm.Item1.RefColumns[a].CsName, colval);
} }
return refitem; return refitem;
}).ToList(); }).ToList();
var childs = childDbSet.Select.Where(commonUtils.WhereItems(otm.Item1.RefColumns.ToArray(), "a.", refitems)).ToList(); var childs = refset.Select.Where(commonUtils.WhereItems(otm.Item1.RefColumns.ToArray(), "a.", refwhereItems)).ToList();
LocalEach(childDbSet, childs, true); LocalEach(refset, childs, true);
}
} }
} }
@ -768,9 +799,40 @@ namespace FreeSql
{ {
foreach (var mtm in mtms) foreach (var mtm in mtms)
{ {
var midset = _db.Set<object>();
midset.AsType(mtm.Item1.RefMiddleEntityType);
var childTable = fsql.CodeFirst.GetTableByEntity(mtm.Item1.RefMiddleEntityType); var childTable = fsql.CodeFirst.GetTableByEntity(mtm.Item1.RefMiddleEntityType);
var childDbSet = _db.Set<object>();
childDbSet.AsType(mtm.Item1.RefMiddleEntityType); if (inMemory)
{
var miditems = items.Select(item =>
{
var midlist = new List<object>();
var refitems = FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetPropertyValue(tb, item, mtm.Item2.Name) as IEnumerable;
if (refitems == null) return null;
var reftb = fsql.CodeFirst.GetTableByEntity(mtm.Item1.RefEntityType);
foreach (var refitem in refitems)
{
var miditem = mtm.Item1.RefMiddleEntityType.CreateInstanceGetDefaultValue();
for (var a = 0; a < mtm.Item1.Columns.Count; a++)
{
var colval = FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetPropertyValue(tb, item, mtm.Item1.Columns[a].CsName);
FreeSql.Extensions.EntityUtil.EntityUtilExtensions.SetPropertyValue(childTable, miditem, mtm.Item1.MiddleColumns[a].CsName, colval);
}
for (var a = 0; a < mtm.Item1.RefColumns.Count; a++)
{
var colval = FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetPropertyValue(reftb, refitem, mtm.Item1.RefColumns[a].CsName);
FreeSql.Extensions.EntityUtil.EntityUtilExtensions.SetPropertyValue(childTable, miditem, mtm.Item1.MiddleColumns[a + mtm.Item1.Columns.Count].CsName, colval);
}
midlist.Add(miditem);
}
return midlist;
}).Where(midlist => midlist != null).SelectMany(midlist => midlist).ToList();
midset.AttachRange(miditems);
LocalEach(midset, miditems, true);
}
else
{
var miditems = items.Select(item => var miditems = items.Select(item =>
{ {
var refitem = mtm.Item1.RefMiddleEntityType.CreateInstanceGetDefaultValue(); var refitem = mtm.Item1.RefMiddleEntityType.CreateInstanceGetDefaultValue();
@ -781,36 +843,42 @@ namespace FreeSql
} }
return refitem; return refitem;
}).ToList(); }).ToList();
var childs = childDbSet.Select.Where(commonUtils.WhereItems(mtm.Item1.MiddleColumns.Take(mtm.Item1.Columns.Count).ToArray(), "a.", miditems)).ToList(); var childs = midset.Select.Where(commonUtils.WhereItems(mtm.Item1.MiddleColumns.Take(mtm.Item1.Columns.Count).ToArray(), "a.", miditems)).ToList();
LocalEach(childDbSet, childs, true); LocalEach(midset, childs, true);
}
} }
} }
if (dbset == rootDbSet) if (dbset == rootDbSet)
{ {
if (CanRemove(data, true) == false) return; if (CanRemove(data, true) == false) return;
foreach (var item in data) //防止清除 Identity/Guid foreach (var item in data) //不直接调用 Remove，防止清除 Identity/Guid
{ {
var state = CreateEntityState(item); var state = CreateEntityState(item);
_states.TryRemove(state.Key, out var trystate); _states.TryRemove(state.Key, out var trystate);
if (inMemory) _db.OrmOriginal.ClearEntityPrimaryValueWithIdentityAndGuid(_entityType, item);
EnqueueToDbContext(DbContext.EntityChangeType.Delete, state); EnqueueToDbContext(DbContext.EntityChangeType.Delete, state);
} }
DbContextFlushCommand();
} }
else else
{ {
if (dbset.CanRemove(items, true) == false) return; if (dbset.CanRemove(items, true) == false) return;
foreach (var item in items) //防止清除 Identity/Guid foreach (var item in items) //不直接调用 dbset.Remove，防止清除 Identity/Guid
{ {
var state = dbset.CreateEntityState(item); var state = dbset.CreateEntityState(item);
dbset._states.TryRemove(state.Key, out var trystate); dbset._states.TryRemove(state.Key, out var trystate);
if (inMemory) _db.OrmOriginal.ClearEntityPrimaryValueWithIdentityAndGuid(dbset.EntityType, item);
dbset.EnqueueToDbContext(DbContext.EntityChangeType.Delete, state); dbset.EnqueueToDbContext(DbContext.EntityChangeType.Delete, state);
} }
dbset.DbContextFlushCommand();
var rawset = _db.Set(dbset.EntityType);
var statesRemove = typeof(DbSet<>).MakeGenericType(dbset.EntityType).GetMethod("StatesRemoveByObjects", BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(IEnumerable<object>) }, null);
if (statesRemove == null) throw new Exception("找不到方法 DbSet<>.StatesRemoveByObjects");
statesRemove.Invoke(rawset, new object[] { items });
} }
returnDeleted.AddRange(items); returnDeleted?.AddRange(items);
} }
} }
#endregion #endregion

4
FreeSql.DbContext/EfCoreFluentApi/EfCoreTableFluent.cs
View File

@ -242,7 +242,7 @@ namespace FreeSql.Extensions.EfCoreFluentApi
} }
/// <summary> /// <summary>
/// 使用 Repository + EnableAddOrUpdateNavigate + NoneParameter 方式插入种子数据 /// 使用 Repository + EnableCascadeSave + NoneParameter 方式插入种子数据
/// </summary> /// </summary>
/// <param name="data"></param> /// <param name="data"></param>
/// <returns></returns> /// <returns></returns>
@ -263,7 +263,7 @@ namespace FreeSql.Extensions.EfCoreFluentApi
if (_fsql.Select<object>().AsType(et).Any()) continue; if (_fsql.Select<object>().AsType(et).Any()) continue;
var repo = _fsql.GetRepository<object>(); var repo = _fsql.GetRepository<object>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.AsType(et); repo.AsType(et);
repo.Insert(sd); repo.Insert(sd);

4
FreeSql.DbContext/EfCoreFluentApi/EfCoreTableFluent`1.cs
View File

@ -329,7 +329,7 @@ namespace FreeSql.Extensions.EfCoreFluentApi
public EfCoreTableFluent<T> HasData(T data) => HasData(new[] { data }); public EfCoreTableFluent<T> HasData(T data) => HasData(new[] { data });
/// <summary> /// <summary>
/// 使用 Repository + EnableAddOrUpdateNavigate + NoneParameter 方式插入种子数据 /// 使用 Repository + EnableCascadeSave + NoneParameter 方式插入种子数据
/// </summary> /// </summary>
/// <param name="data"></param> /// <param name="data"></param>
/// <returns></returns> /// <returns></returns>
@ -350,7 +350,7 @@ namespace FreeSql.Extensions.EfCoreFluentApi
if (_fsql.Select<object>().AsType(et).Any()) continue; if (_fsql.Select<object>().AsType(et).Any()) continue;
var repo = _fsql.GetRepository<object>(); var repo = _fsql.GetRepository<object>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.AsType(et); repo.AsType(et);
repo.Insert(sd); repo.Insert(sd);

29
FreeSql.DbContext/FreeSql.DbContext.xml
View File

@ -89,7 +89,7 @@
刷新队列中的命令 刷新队列中的命令
</summary> </summary>
</member> </member>
<member name="P:FreeSql.DbContextOptions.EnableAddOrUpdateNavigate"> <member name="P:FreeSql.DbContextOptions.EnableCascadeSave">
<summary> <summary>
是否开启 一对一(OneToOne)、一对多(OneToMany)、多对多(ManyToMany) 级联保存功能<para></para> 是否开启 一对一(OneToOne)、一对多(OneToMany)、多对多(ManyToMany) 级联保存功能<para></para>
<para></para> <para></para>
@ -107,7 +107,7 @@
</member> </member>
<member name="P:FreeSql.DbContextOptions.EnableAddOrUpdateNavigateList"> <member name="P:FreeSql.DbContextOptions.EnableAddOrUpdateNavigateList">
<summary> <summary>
因增加支持 OneToOne 级联保存，请了解机制，已改名为 EnableAddOrUpdateNavigate 因增加支持 OneToOne 级联保存，和基于内存的级联删除，已改名为 EnableCascadeSave
</summary> </summary>
</member> </member>
<member name="P:FreeSql.DbContextOptions.NoneParameter"> <member name="P:FreeSql.DbContextOptions.NoneParameter">
@ -216,11 +216,11 @@
<param name="data">可选参数：手工传递最终的 data 值进行对比<para></para>默认：如果不传递，则使用 BeginEdit 传入的 data 引用进行对比</param> <param name="data">可选参数：手工传递最终的 data 值进行对比<para></para>默认：如果不传递，则使用 BeginEdit 传入的 data 引用进行对比</param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:FreeSql.DbSet`1.RemoveCascade(`0)"> <member name="M:FreeSql.DbSet`1.RemoveCascadeByDatabase(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary> <summary>
根据设置的导航属性，递归查询删除 OneToOne/OneToMany/ManyToMany 数据，并返回已删除的数据 根据设置的 OneToOne/OneToMany/ManyToMany 导航属性，级联查询所有的数据库记录，删除并返回它们
</summary> </summary>
<param name="data"></param> <param name="predicate"></param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:FreeSql.Extensions.EfCoreFluentApi.EfCoreColumnFluent.Help"> <member name="M:FreeSql.Extensions.EfCoreFluentApi.EfCoreColumnFluent.Help">
@ -237,7 +237,7 @@
</member> </member>
<member name="M:FreeSql.Extensions.EfCoreFluentApi.EfCoreTableFluent.HasData(System.Collections.Generic.IEnumerable{System.Object})"> <member name="M:FreeSql.Extensions.EfCoreFluentApi.EfCoreTableFluent.HasData(System.Collections.Generic.IEnumerable{System.Object})">
<summary> <summary>
使用 Repository + EnableAddOrUpdateNavigate + NoneParameter 方式插入种子数据 使用 Repository + EnableCascadeSave + NoneParameter 方式插入种子数据
</summary> </summary>
<param name="data"></param> <param name="data"></param>
<returns></returns> <returns></returns>
@ -250,7 +250,7 @@
</member> </member>
<member name="M:FreeSql.Extensions.EfCoreFluentApi.EfCoreTableFluent`1.HasData(System.Collections.Generic.IEnumerable{`0})"> <member name="M:FreeSql.Extensions.EfCoreFluentApi.EfCoreTableFluent`1.HasData(System.Collections.Generic.IEnumerable{`0})">
<summary> <summary>
使用 Repository + EnableAddOrUpdateNavigate + NoneParameter 方式插入种子数据 使用 Repository + EnableCascadeSave + NoneParameter 方式插入种子数据
</summary> </summary>
<param name="data"></param> <param name="data"></param>
<returns></returns> <returns></returns>
@ -360,11 +360,11 @@
<param name="entity">实体对象</param> <param name="entity">实体对象</param>
<param name="propertyName">属性名</param> <param name="propertyName">属性名</param>
</member> </member>
<member name="M:FreeSql.IBaseRepository`1.DeleteCascade(`0)"> <member name="M:FreeSql.IBaseRepository`1.RemoveCascadeByDatabase(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary> <summary>
根据设置的导航属性，递归查询删除 OneToOne/OneToMany/ManyToMany 数据，并返回已删除的数据 根据设置的 OneToOne/OneToMany/ManyToMany 导航属性，级联查询所有的数据库记录，删除并返回它们
</summary> </summary>
<param name="entity"></param> <param name="predicate"></param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:FreeSql.IBaseRepository`1.BeginEdit(System.Collections.Generic.List{`0})"> <member name="M:FreeSql.IBaseRepository`1.BeginEdit(System.Collections.Generic.List{`0})">
@ -559,14 +559,5 @@
<param name="that"></param> <param name="that"></param>
<returns></returns> <returns></returns>
</member> </member>
<member name="M:Microsoft.Extensions.DependencyInjection.FreeSqlRepositoryDependencyInjection.AddFreeRepository(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Action{FreeSql.FluentDataFilter},System.Reflection.Assembly[])">
<summary>
批量注入 Repository，可以参考代码自行调整
</summary>
<param name="services"></param>
<param name="globalDataFilter"></param>
<param name="assemblies"></param>
<returns></returns>
</member>
</members> </members>
</doc> </doc>

10
FreeSql.DbContext/Repository/Repository/BaseRepository.cs
View File

@ -94,9 +94,12 @@ namespace FreeSql
_dbset.RemoveRange(entitys); _dbset.RemoveRange(entitys);
return _db.SaveChanges(); return _db.SaveChanges();
} }
public List<object> DeleteCascade(TEntity entity) => _dbset.RemoveCascade(entity); public List<object> RemoveCascadeByDatabase(Expression<Func<TEntity, bool>> predicate)
public List<object> DeleteCascade(IEnumerable<TEntity> entitys) => _dbset.RemoveRangeCascade(entitys); {
public List<object> DeleteCascade(Expression<Func<TEntity, bool>> predicate) => _dbset.RemoveCascade(predicate); var list = _dbset.RemoveCascadeByDatabase(predicate);
var affrows = _db.SaveChanges();
return list;
}
public virtual TEntity Insert(TEntity entity) public virtual TEntity Insert(TEntity entity)
{ {
@ -192,7 +195,6 @@ namespace FreeSql
return ret; return ret;
} }
public virtual List<object> DeleteCascade(TKey id) => _dbset.RemoveCascade(Find(id));
public virtual int Delete(TKey id) => Delete(CheckTKeyAndReturnIdEntity(id)); public virtual int Delete(TKey id) => Delete(CheckTKeyAndReturnIdEntity(id));
public virtual TEntity Find(TKey id) => _dbset.OrmSelectInternal(CheckTKeyAndReturnIdEntity(id)).ToOne(); public virtual TEntity Find(TKey id) => _dbset.OrmSelectInternal(CheckTKeyAndReturnIdEntity(id)).ToOne();
public TEntity Get(TKey id) => _dbset.OrmSelectInternal(CheckTKeyAndReturnIdEntity(id)).ToOne(); public TEntity Get(TKey id) => _dbset.OrmSelectInternal(CheckTKeyAndReturnIdEntity(id)).ToOne();

10
FreeSql.DbContext/Repository/Repository/BaseRepositoryAsync.cs
View File

@ -32,9 +32,12 @@ namespace FreeSql
_dbset.RemoveRange(entitys); _dbset.RemoveRange(entitys);
return _db.SaveChangesAsync(cancellationToken); return _db.SaveChangesAsync(cancellationToken);
} }
public virtual Task<List<object>> DeleteCascade(TEntity entity, CancellationToken cancellationToken = default) => _dbset.RemoveCascadeAsync(entity, cancellationToken); async public virtual Task<List<object>> RemoveCascadeByDatabaseAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
public virtual Task<List<object>> DeleteCascade(IEnumerable<TEntity> entitys, CancellationToken cancellationToken = default) => _dbset.RemoveRangeCascadeAsync(entitys, cancellationToken); {
public virtual Task<List<object>> DeleteCascade(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default) => _dbset.RemoveCascadeAsync(predicate, cancellationToken); var list = await _dbset.RemoveCascadeByDatabaseAsync(predicate, cancellationToken);
var affrows = await _db.SaveChangesAsync(cancellationToken);
return list;
}
async public virtual Task<TEntity> InsertAsync(TEntity entity, CancellationToken cancellationToken = default) async public virtual Task<TEntity> InsertAsync(TEntity entity, CancellationToken cancellationToken = default)
{ {
@ -76,7 +79,6 @@ namespace FreeSql
partial class BaseRepository<TEntity, TKey> partial class BaseRepository<TEntity, TKey>
{ {
public virtual Task<List<object>> DeleteCascadeAsync(TKey id, CancellationToken cancellationToken = default) => _dbset.RemoveCascadeAsync(Find(id), cancellationToken);
public virtual Task<int> DeleteAsync(TKey id, CancellationToken cancellationToken = default) => DeleteAsync(CheckTKeyAndReturnIdEntity(id), cancellationToken); public virtual Task<int> DeleteAsync(TKey id, CancellationToken cancellationToken = default) => DeleteAsync(CheckTKeyAndReturnIdEntity(id), cancellationToken);
public virtual Task<TEntity> FindAsync(TKey id, CancellationToken cancellationToken = default) => _dbset.OrmSelectInternal(CheckTKeyAndReturnIdEntity(id)).ToOneAsync(cancellationToken); public virtual Task<TEntity> FindAsync(TKey id, CancellationToken cancellationToken = default) => _dbset.OrmSelectInternal(CheckTKeyAndReturnIdEntity(id)).ToOneAsync(cancellationToken);
public Task<TEntity> GetAsync(TKey id, CancellationToken cancellationToken = default) => _dbset.OrmSelectInternal(CheckTKeyAndReturnIdEntity(id)).ToOneAsync(cancellationToken); public Task<TEntity> GetAsync(TKey id, CancellationToken cancellationToken = default) => _dbset.OrmSelectInternal(CheckTKeyAndReturnIdEntity(id)).ToOneAsync(cancellationToken);

14
FreeSql.DbContext/Repository/Repository/IBaseRepository.cs
View File

@ -86,13 +86,11 @@ namespace FreeSql
int Delete(IEnumerable<TEntity> entitys); int Delete(IEnumerable<TEntity> entitys);
int Delete(Expression<Func<TEntity, bool>> predicate); int Delete(Expression<Func<TEntity, bool>> predicate);
/// <summary> /// <summary>
/// 根据设置的导航属性，递归查询删除 OneToOne/OneToMany/ManyToMany 数据，并返回已删除的数据 /// 根据设置的 OneToOne/OneToMany/ManyToMany 导航属性，级联查询所有的数据库记录，删除并返回它们
/// </summary> /// </summary>
/// <param name="entity"></param> /// <param name="predicate"></param>
/// <returns></returns> /// <returns></returns>
List<object> DeleteCascade(TEntity entity); List<object> RemoveCascadeByDatabase(Expression<Func<TEntity, bool>> predicate);
List<object> DeleteCascade(IEnumerable<TEntity> entitys);
List<object> DeleteCascade(Expression<Func<TEntity, bool>> predicate);
/// <summary> /// <summary>
/// 开始编辑数据，然后调用方法 EndEdit 分析出添加、修改、删除 SQL 语句进行执行<para></para> /// 开始编辑数据，然后调用方法 EndEdit 分析出添加、修改、删除 SQL 语句进行执行<para></para>
@ -124,9 +122,7 @@ namespace FreeSql
Task<int> DeleteAsync(TEntity entity, CancellationToken cancellationToken = default); Task<int> DeleteAsync(TEntity entity, CancellationToken cancellationToken = default);
Task<int> DeleteAsync(IEnumerable<TEntity> entitys, CancellationToken cancellationToken = default); Task<int> DeleteAsync(IEnumerable<TEntity> entitys, CancellationToken cancellationToken = default);
Task<int> DeleteAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default); Task<int> DeleteAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
Task<List<object>> DeleteCascade(TEntity entity, CancellationToken cancellationToken = default); Task<List<object>> RemoveCascadeByDatabaseAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
Task<List<object>> DeleteCascade(IEnumerable<TEntity> entitys, CancellationToken cancellationToken = default);
Task<List<object>> DeleteCascade(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default);
#endif #endif
} }
@ -136,14 +132,12 @@ namespace FreeSql
TEntity Get(TKey id); TEntity Get(TKey id);
TEntity Find(TKey id); TEntity Find(TKey id);
int Delete(TKey id); int Delete(TKey id);
List<object> DeleteCascade(TKey id);
#if net40 #if net40
#else #else
Task<TEntity> GetAsync(TKey id, CancellationToken cancellationToken = default); Task<TEntity> GetAsync(TKey id, CancellationToken cancellationToken = default);
Task<TEntity> FindAsync(TKey id, CancellationToken cancellationToken = default); Task<TEntity> FindAsync(TKey id, CancellationToken cancellationToken = default);
Task<int> DeleteAsync(TKey id, CancellationToken cancellationToken = default); Task<int> DeleteAsync(TKey id, CancellationToken cancellationToken = default);
Task<List<object>> DeleteCascadeAsync(TKey id, CancellationToken cancellationToken = default);
#endif #endif
} }
} }

187
FreeSql.Tests/FreeSql.Tests.DbContext/RepositoryTests.cs
View File

@ -13,15 +13,27 @@ namespace FreeSql.Tests
public void DeleteCascade() public void DeleteCascade()
{ {
var fsql = g.sqlite; var fsql = g.sqlite;
fsql.Delete<DeleteCascadeUserGroup>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserTag>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeTag>().Where("1=1").ExecuteAffrows();
var groupRepo = fsql.GetRepository<DeleteCascadeUserGroup>(); var groupRepo = fsql.GetRepository<DeleteCascadeUserGroup>();
var userRepo = fsql.GetRepository<DeleteCascadeUser>(); var userRepo = fsql.GetRepository<DeleteCascadeUser>();
userRepo.DbContextOptions.EnableAddOrUpdateNavigate = true; var userextRepo = fsql.GetRepository<DeleteCascadeUserExt>();
//OneToOne var tagRepo = fsql.GetRepository<DeleteCascadeTag>();
groupRepo.DbContextOptions.EnableCascadeSave = true;
userRepo.DbContextOptions.EnableCascadeSave = true;
userextRepo.DbContextOptions.EnableCascadeSave = true;
tagRepo.DbContextOptions.EnableCascadeSave = true;
//OneToOne InDatabase
fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows(); fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows(); fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
var user = new DeleteCascadeUser { Username = "admin01", Password = "pwd01", UserExt = new DeleteCascadeUserExt { Remark = "用户备注01" } }; var user = new DeleteCascadeUser { Username = "admin01", Password = "pwd01", UserExt = new DeleteCascadeUserExt { Remark = "用户备注01" } };
userRepo.Insert(user); userRepo.Insert(user);
var ret = userRepo.DeleteCascade(user); var ret = userRepo.RemoveCascadeByDatabase(a => a.Id == user.Id);
Assert.Equal(2, ret.Count); Assert.Equal(2, ret.Count);
Assert.IsType<DeleteCascadeUserExt>(ret[0]); Assert.IsType<DeleteCascadeUserExt>(ret[0]);
Assert.Equal(user.UserExt.UserId, (ret[0] as DeleteCascadeUserExt).UserId); Assert.Equal(user.UserExt.UserId, (ret[0] as DeleteCascadeUserExt).UserId);
@ -30,13 +42,29 @@ namespace FreeSql.Tests
Assert.Equal(user.Id, (ret[1] as DeleteCascadeUser).Id); Assert.Equal(user.Id, (ret[1] as DeleteCascadeUser).Id);
Assert.Equal(user.Username, (ret[1] as DeleteCascadeUser).Username); Assert.Equal(user.Username, (ret[1] as DeleteCascadeUser).Username);
Assert.Equal(user.Password, (ret[1] as DeleteCascadeUser).Password); Assert.Equal(user.Password, (ret[1] as DeleteCascadeUser).Password);
//OneToOne EnableCascadeSave InMemory
//OneToOne 先删除 UserExt
fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows(); fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows(); fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
user = new DeleteCascadeUser { Username = "admin01", Password = "pwd01", UserExt = new DeleteCascadeUserExt { Remark = "用户备注01" } }; user = new DeleteCascadeUser { Username = "admin01", Password = "pwd01", UserExt = new DeleteCascadeUserExt { Remark = "用户备注01" } };
userRepo.Insert(user); userRepo.Insert(user);
ret = fsql.GetRepository<DeleteCascadeUserExt>().DeleteCascade(user.UserExt); Assert.True(user.Id > 0);
Assert.True(user.UserExt.UserId > 0);
var affrows = userRepo.Delete(user);
Assert.Equal(2, affrows);
Assert.Equal(0, user.Id);
Assert.Equal("admin01", user.Username);
Assert.Equal("pwd01", user.Password);
Assert.True(user.UserExt.UserId > 0);
Assert.Equal("用户备注01", user.UserExt.Remark);
Assert.False(userRepo.Select.Any());
Assert.False(userextRepo.Select.Any());
//OneToOne InDatabase 先删除 UserExt
fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
user = new DeleteCascadeUser { Username = "admin01", Password = "pwd01", UserExt = new DeleteCascadeUserExt { Remark = "用户备注01" } };
userRepo.Insert(user);
ret = userextRepo.RemoveCascadeByDatabase(a => a.UserId == user.UserExt.UserId);
Assert.Equal(2, ret.Count); Assert.Equal(2, ret.Count);
Assert.IsType<DeleteCascadeUserExt>(ret[1]); Assert.IsType<DeleteCascadeUserExt>(ret[1]);
Assert.Equal(user.UserExt.UserId, (ret[1] as DeleteCascadeUserExt).UserId); Assert.Equal(user.UserExt.UserId, (ret[1] as DeleteCascadeUserExt).UserId);
@ -45,12 +73,31 @@ namespace FreeSql.Tests
Assert.Equal(user.Id, (ret[0] as DeleteCascadeUser).Id); Assert.Equal(user.Id, (ret[0] as DeleteCascadeUser).Id);
Assert.Equal(user.Username, (ret[0] as DeleteCascadeUser).Username); Assert.Equal(user.Username, (ret[0] as DeleteCascadeUser).Username);
Assert.Equal(user.Password, (ret[0] as DeleteCascadeUser).Password); Assert.Equal(user.Password, (ret[0] as DeleteCascadeUser).Password);
//OneToOne EnableCascadeSave InMemory 先删除 UserExt
fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
user = new DeleteCascadeUser { Username = "admin01", Password = "pwd01", UserExt = new DeleteCascadeUserExt { Remark = "用户备注01" } };
userRepo.Insert(user);
Assert.True(user.Id > 0);
Assert.True(user.UserExt.UserId > 0);
var userext = userextRepo.Where(a => a.UserId == user.Id).Include(a => a.User).First();
Assert.NotNull(userext);
Assert.Equal(user.UserExt.UserId, userext.UserId);
Assert.Equal(user.Id, userext.User.Id);
affrows = userextRepo.Delete(userext);
Assert.Equal(2, affrows);
Assert.Equal(0, userext.User.Id);
Assert.Equal("admin01", userext.User.Username);
Assert.Equal("pwd01", userext.User.Password);
Assert.True(userext.UserId > 0);
Assert.Equal("用户备注01", userext.Remark);
Assert.False(userRepo.Select.Any());
Assert.False(userextRepo.Select.Any());
//OneToMany //OneToMany InDatabase
fsql.Delete<DeleteCascadeUserGroup>().Where("1=1").ExecuteAffrows(); fsql.Delete<DeleteCascadeUserGroup>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows(); fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows(); fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
groupRepo.DbContextOptions.EnableAddOrUpdateNavigate = true;
var group = new DeleteCascadeUserGroup var group = new DeleteCascadeUserGroup
{ {
GroupName = "group01", GroupName = "group01",
@ -65,7 +112,7 @@ namespace FreeSql.Tests
Assert.Equal(group.Id, group.Users[0].GroupId); Assert.Equal(group.Id, group.Users[0].GroupId);
Assert.Equal(group.Id, group.Users[1].GroupId); Assert.Equal(group.Id, group.Users[1].GroupId);
Assert.Equal(group.Id, group.Users[2].GroupId); Assert.Equal(group.Id, group.Users[2].GroupId);
ret = groupRepo.DeleteCascade(group); ret = groupRepo.RemoveCascadeByDatabase(a => a.Id == group.Id);
Assert.Equal(7, ret.Count); Assert.Equal(7, ret.Count);
Assert.IsType<DeleteCascadeUserExt>(ret[0]); Assert.IsType<DeleteCascadeUserExt>(ret[0]);
Assert.Equal(group.Users[0].UserExt.UserId, (ret[0] as DeleteCascadeUserExt).UserId); Assert.Equal(group.Users[0].UserExt.UserId, (ret[0] as DeleteCascadeUserExt).UserId);
@ -91,8 +138,48 @@ namespace FreeSql.Tests
Assert.IsType<DeleteCascadeUserGroup>(ret[6]); Assert.IsType<DeleteCascadeUserGroup>(ret[6]);
Assert.Equal(group.Id, (ret[6] as DeleteCascadeUserGroup).Id); Assert.Equal(group.Id, (ret[6] as DeleteCascadeUserGroup).Id);
Assert.Equal(group.GroupName, (ret[6] as DeleteCascadeUserGroup).GroupName); Assert.Equal(group.GroupName, (ret[6] as DeleteCascadeUserGroup).GroupName);
//OneToMany EnableCascadeSave InMemory
fsql.Delete<DeleteCascadeUserGroup>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
group = new DeleteCascadeUserGroup
{
GroupName = "group01",
Users = new List<DeleteCascadeUser>
{
new DeleteCascadeUser { Username = "admin01", Password = "pwd01", UserExt = new DeleteCascadeUserExt { Remark = "用户备注01" } },
new DeleteCascadeUser { Username = "admin02", Password = "pwd02", UserExt = new DeleteCascadeUserExt { Remark = "用户备注02" } },
new DeleteCascadeUser { Username = "admin03", Password = "pwd03", UserExt = new DeleteCascadeUserExt { Remark = "用户备注03" } },
}
};
groupRepo.Insert(group);
Assert.Equal(group.Id, group.Users[0].GroupId);
Assert.Equal(group.Id, group.Users[1].GroupId);
Assert.Equal(group.Id, group.Users[2].GroupId);
affrows = groupRepo.Delete(group);
Assert.Equal(7, affrows);
Assert.Equal(0, group.Id);
Assert.Equal("group01", group.GroupName);
Assert.Equal(0, group.Users[0].Id);
Assert.Equal("admin01", group.Users[0].Username);
Assert.Equal("pwd01", group.Users[0].Password);
Assert.True(group.Users[0].UserExt.UserId > 0);
Assert.Equal("用户备注01", group.Users[0].UserExt.Remark);
Assert.Equal(0, group.Users[1].Id);
Assert.Equal("admin02", group.Users[1].Username);
Assert.Equal("pwd02", group.Users[1].Password);
Assert.True(group.Users[1].UserExt.UserId > 0);
Assert.Equal("用户备注02", group.Users[1].UserExt.Remark);
Assert.Equal(0, group.Users[2].Id);
Assert.Equal("admin03", group.Users[2].Username);
Assert.Equal("pwd03", group.Users[2].Password);
Assert.True(group.Users[2].UserExt.UserId > 0);
Assert.Equal("用户备注03", group.Users[2].UserExt.Remark);
Assert.False(groupRepo.Select.Any());
Assert.False(userRepo.Select.Any());
Assert.False(userextRepo.Select.Any());
//ManyToMany //ManyToMany InDatabase
fsql.Delete<DeleteCascadeUserGroup>().Where("1=1").ExecuteAffrows(); fsql.Delete<DeleteCascadeUserGroup>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows(); fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows(); fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
@ -108,8 +195,8 @@ namespace FreeSql.Tests
new DeleteCascadeTag { TagName = "tag07" }, new DeleteCascadeTag { TagName = "tag07" },
new DeleteCascadeTag { TagName = "tag08" }, new DeleteCascadeTag { TagName = "tag08" },
}; };
fsql.GetRepository<DeleteCascadeTag>().Insert(tags); tagRepo.Insert(tags);
groupRepo.DbContextOptions.EnableAddOrUpdateNavigate = true; groupRepo.DbContextOptions.EnableCascadeSave = true;
group = new DeleteCascadeUserGroup group = new DeleteCascadeUserGroup
{ {
GroupName = "group01", GroupName = "group01",
@ -124,7 +211,7 @@ namespace FreeSql.Tests
Assert.Equal(group.Id, group.Users[0].GroupId); Assert.Equal(group.Id, group.Users[0].GroupId);
Assert.Equal(group.Id, group.Users[1].GroupId); Assert.Equal(group.Id, group.Users[1].GroupId);
Assert.Equal(group.Id, group.Users[2].GroupId); Assert.Equal(group.Id, group.Users[2].GroupId);
ret = groupRepo.DeleteCascade(group); ret = groupRepo.RemoveCascadeByDatabase(a => a.Id == group.Id);
Assert.Equal(18, ret.Count); Assert.Equal(18, ret.Count);
Assert.IsType<DeleteCascadeUserExt>(ret[0]); Assert.IsType<DeleteCascadeUserExt>(ret[0]);
@ -188,6 +275,62 @@ namespace FreeSql.Tests
Assert.IsType<DeleteCascadeUserGroup>(ret[17]); Assert.IsType<DeleteCascadeUserGroup>(ret[17]);
Assert.Equal(group.Id, (ret[17] as DeleteCascadeUserGroup).Id); Assert.Equal(group.Id, (ret[17] as DeleteCascadeUserGroup).Id);
Assert.Equal(group.GroupName, (ret[17] as DeleteCascadeUserGroup).GroupName); Assert.Equal(group.GroupName, (ret[17] as DeleteCascadeUserGroup).GroupName);
//ManyToMany EnableCascadeSave InMemory
fsql.Delete<DeleteCascadeUserGroup>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeTag>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserTag>().Where("1=1").ExecuteAffrows();
tags = new[] {
new DeleteCascadeTag { TagName = "tag01" },
new DeleteCascadeTag { TagName = "tag02" },
new DeleteCascadeTag { TagName = "tag03" },
new DeleteCascadeTag { TagName = "tag04" },
new DeleteCascadeTag { TagName = "tag05" },
new DeleteCascadeTag { TagName = "tag06" },
new DeleteCascadeTag { TagName = "tag07" },
new DeleteCascadeTag { TagName = "tag08" },
};
tagRepo.Insert(tags);
groupRepo.DbContextOptions.EnableCascadeSave = true;
group = new DeleteCascadeUserGroup
{
GroupName = "group01",
Users = new List<DeleteCascadeUser>
{
new DeleteCascadeUser { Username = "admin01", Password = "pwd01", UserExt = new DeleteCascadeUserExt { Remark = "用户备注01" }, Tags = new List<DeleteCascadeTag> { tags[0], tags[2], tags[3], tags[6] } },
new DeleteCascadeUser { Username = "admin02", Password = "pwd02", UserExt = new DeleteCascadeUserExt { Remark = "用户备注02" }, Tags = new List<DeleteCascadeTag> { tags[1], tags[2], tags[5] } },
new DeleteCascadeUser { Username = "admin03", Password = "pwd03", UserExt = new DeleteCascadeUserExt { Remark = "用户备注03" }, Tags = new List<DeleteCascadeTag> { tags[3], tags[4], tags[6], tags[7] } },
}
};
groupRepo.Insert(group);
Assert.Equal(group.Id, group.Users[0].GroupId);
Assert.Equal(group.Id, group.Users[1].GroupId);
Assert.Equal(group.Id, group.Users[2].GroupId);
affrows = groupRepo.Delete(group);
Assert.Equal(18, affrows);
Assert.Equal(0, group.Id);
Assert.Equal("group01", group.GroupName);
Assert.Equal(0, group.Users[0].Id);
Assert.Equal("admin01", group.Users[0].Username);
Assert.Equal("pwd01", group.Users[0].Password);
Assert.True(group.Users[0].UserExt.UserId > 0);
Assert.Equal("用户备注01", group.Users[0].UserExt.Remark);
Assert.Equal(0, group.Users[1].Id);
Assert.Equal("admin02", group.Users[1].Username);
Assert.Equal("pwd02", group.Users[1].Password);
Assert.True(group.Users[1].UserExt.UserId > 0);
Assert.Equal("用户备注02", group.Users[1].UserExt.Remark);
Assert.Equal(0, group.Users[2].Id);
Assert.Equal("admin03", group.Users[2].Username);
Assert.Equal("pwd03", group.Users[2].Password);
Assert.True(group.Users[2].UserExt.UserId > 0);
Assert.Equal("用户备注03", group.Users[2].UserExt.Remark);
Assert.False(groupRepo.Select.Any());
Assert.False(userRepo.Select.Any());
Assert.False(userextRepo.Select.Any());
Assert.False(fsql.Select<DeleteCascadeUserTag>().Any());
} }
public class DeleteCascadeUser public class DeleteCascadeUser
{ {
@ -465,10 +608,10 @@ namespace FreeSql.Tests
} }
[Fact] [Fact]
public void EnableAddOrUpdateNavigate_OneToMany() public void EnableCascadeSave_OneToMany()
{ {
var repo = g.sqlite.GetRepository<Cagetory>(); var repo = g.sqlite.GetRepository<Cagetory>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
var cts = new[] { var cts = new[] {
new Cagetory new Cagetory
{ {
@ -528,10 +671,10 @@ namespace FreeSql.Tests
} }
[Fact] [Fact]
public void EnableAddOrUpdateNavigate_OneToMany_lazyloading() public void EnableCascadeSave_OneToMany_lazyloading()
{ {
var repo = g.sqlite.GetRepository<CagetoryLD>(); var repo = g.sqlite.GetRepository<CagetoryLD>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
var cts = new[] { var cts = new[] {
new CagetoryLD new CagetoryLD
{ {
@ -600,7 +743,7 @@ namespace FreeSql.Tests
public void SaveMany_OneToMany() public void SaveMany_OneToMany()
{ {
var repo = g.sqlite.GetRepository<Cagetory>(); var repo = g.sqlite.GetRepository<Cagetory>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = false; //关闭级联保存功能 repo.DbContextOptions.EnableCascadeSave = false; //关闭级联保存功能
var cts = new[] { var cts = new[] {
new Cagetory new Cagetory
{ {
@ -649,7 +792,7 @@ namespace FreeSql.Tests
} }
[Fact] [Fact]
public void EnableAddOrUpdateNavigate_OneToMany_Parent() public void EnableCascadeSave_OneToMany_Parent()
{ {
g.sqlite.Delete<CagetoryParent>().Where("1=1").ExecuteAffrows(); g.sqlite.Delete<CagetoryParent>().Where("1=1").ExecuteAffrows();
var repo = g.sqlite.GetRepository<CagetoryParent>(); var repo = g.sqlite.GetRepository<CagetoryParent>();
@ -674,7 +817,7 @@ namespace FreeSql.Tests
}) })
} }
}; };
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; //打开级联保存功能 repo.DbContextOptions.EnableCascadeSave = true; //打开级联保存功能
repo.Insert(cts); repo.Insert(cts);
var notreelist1 = repo.Select.ToList(); var notreelist1 = repo.Select.ToList();
@ -707,7 +850,7 @@ namespace FreeSql.Tests
} }
[Fact] [Fact]
public void EnableAddOrUpdateNavigate_ManyToMany() public void EnableCascadeSave_ManyToMany()
{ {
var tags = new[] { var tags = new[] {
new Tag { TagName = "流行" }, new Tag { TagName = "流行" },
@ -735,7 +878,7 @@ namespace FreeSql.Tests
} }
}; };
var repo = g.sqlite.GetRepository<Song>(); var repo = g.sqlite.GetRepository<Song>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; //打开级联保存功能 repo.DbContextOptions.EnableCascadeSave = true; //打开级联保存功能
repo.Insert(ss); repo.Insert(ss);
ss[0].Tags[0].TagName = "流行101"; ss[0].Tags[0].TagName = "流行101";

6
FreeSql.Tests/FreeSql.Tests.DbContext/UnitTest1.cs
View File

@ -155,7 +155,7 @@ namespace FreeSql.Tests
g.sqlite.SetDbContextOptions(opt => g.sqlite.SetDbContextOptions(opt =>
{ {
//opt.EnableAddOrUpdateNavigate = false; //opt.EnableCascadeSave = false;
}); });
g.mysql.Insert<testenumWhere>().AppendData(new testenumWhere { type = testenumWhereType.Blaaa }).ExecuteAffrows(); g.mysql.Insert<testenumWhere>().AppendData(new testenumWhere { type = testenumWhereType.Blaaa }).ExecuteAffrows();
@ -167,7 +167,7 @@ namespace FreeSql.Tests
using (var ctx = g.sqlite.CreateDbContext()) using (var ctx = g.sqlite.CreateDbContext())
{ {
ctx.Options.EnableAddOrUpdateNavigate = true; ctx.Options.EnableCascadeSave = true;
var tags = ctx.Set<Tag>().Select.IncludeMany(a => a.Tags).ToList(); var tags = ctx.Set<Tag>().Select.IncludeMany(a => a.Tags).ToList();
var tag = new Tag var tag = new Tag
@ -199,7 +199,7 @@ namespace FreeSql.Tests
using (var ctx = g.sqlite.CreateDbContext()) using (var ctx = g.sqlite.CreateDbContext())
{ {
ctx.Options.EnableAddOrUpdateNavigate = true; ctx.Options.EnableCascadeSave = true;
var tag = ctx.Set<Tag>().Select.First(); var tag = ctx.Set<Tag>().Select.First();
tag.Tags.Add(new Tag { Name = "sub3" }); tag.Tags.Add(new Tag { Name = "sub3" });
tag.Name = Guid.NewGuid().ToString(); tag.Name = Guid.NewGuid().ToString();

4
FreeSql.Tests/FreeSql.Tests.Provider.GBase/GBase/Curd/GBaseSelectTest.cs
View File

@ -191,7 +191,7 @@ WHERE (exists(SELECT 1
g.gbase.Delete<District>().Where("1=1").ExecuteAffrows(); g.gbase.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.gbase.GetRepository<District>(); var repo = g.gbase.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1704,7 +1704,7 @@ WHERE (((cast(a.Id as varchar(8000))) in ( SELECT * FROM (SELECT FIRST 10 b.Titl
var fsql = g.gbase; var fsql = g.gbase;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests.Provider.MySqlConnector/MySqlConnector/Curd/MySqlSelectTest.cs
View File

@ -384,7 +384,7 @@ WHERE (((a.`Name`) in (SELECT s.`Title` as1
g.mysql.Delete<District>().Where("1=1").ExecuteAffrows(); g.mysql.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.mysql.GetRepository<District>(); var repo = g.mysql.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -2001,7 +2001,7 @@ WHERE ((b.`IsFinished` OR a.`TaskType` = 3) AND b.`EnabledMark` = 1)", groupsql1
var fsql = g.mysql; var fsql = g.mysql;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests.Provider.Odbc/Dameng/Curd/DamengSelectTest.cs
View File

@ -194,7 +194,7 @@ namespace FreeSql.Tests.Odbc.Dameng
g.dameng.Delete<District>().Where("1=1").ExecuteAffrows(); g.dameng.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.dameng.GetRepository<District>(); var repo = g.dameng.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1728,7 +1728,7 @@ WHERE (((to_char(a.""ID"")) in (SELECT b.""TITLE""
var fsql = g.dameng; var fsql = g.dameng;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests.Provider.Odbc/Default/Curd/OdbcSelectTest.cs
View File

@ -185,7 +185,7 @@ namespace FreeSql.Tests.Odbc.Default
g.odbc.Delete<District>().Where("1=1").ExecuteAffrows(); g.odbc.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.odbc.GetRepository<District>(); var repo = g.odbc.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1517,7 +1517,7 @@ WHERE (((cast(a.[Id] as nvarchar)) in (SELECT b.[Title]
var fsql = g.odbc; var fsql = g.odbc;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests.Provider.Odbc/KingbaseES/Curd/KingbaseESSelectTest.cs
View File

@ -194,7 +194,7 @@ namespace FreeSql.Tests.Odbc.KingbaseES
g.kingbaseES.Delete<District>().Where("1=1").ExecuteAffrows(); g.kingbaseES.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.kingbaseES.GetRepository<District>(); var repo = g.kingbaseES.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1677,7 +1677,7 @@ WHERE ((((a.""ID"")::text) in (SELECT b.""TITLE""
var fsql = g.kingbaseES; var fsql = g.kingbaseES;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests.Provider.Odbc/MySql/Curd/MySqlSelectTest.cs
View File

@ -294,7 +294,7 @@ namespace FreeSql.Tests.Odbc.MySql
g.mysql.Delete<District>().Where("1=1").ExecuteAffrows(); g.mysql.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.mysql.GetRepository<District>(); var repo = g.mysql.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1881,7 +1881,7 @@ WHERE ((b.`IsFinished` OR a.`TaskType` = 3) AND b.`EnabledMark` = 1)", groupsql1
var fsql = g.mysql; var fsql = g.mysql;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests.Provider.Odbc/Oracle/Curd/OracleSelectTest.cs
View File

@ -194,7 +194,7 @@ namespace FreeSql.Tests.Odbc.Oracle
g.oracle.Delete<District>().Where("1=1").ExecuteAffrows(); g.oracle.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.oracle.GetRepository<District>(); var repo = g.oracle.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1720,7 +1720,7 @@ WHERE (((to_char(a.""ID"")) in (SELECT b.""TITLE""
var fsql = g.oracle; var fsql = g.oracle;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests.Provider.Odbc/PostgreSQL/Curd/PostgreSQLSelectTest.cs
View File

@ -270,7 +270,7 @@ namespace FreeSql.Tests.Odbc.PostgreSQL
g.pgsql.Delete<District>().Where("1=1").ExecuteAffrows(); g.pgsql.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.pgsql.GetRepository<District>(); var repo = g.pgsql.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1780,7 +1780,7 @@ WHERE ((((a.""id"")::text) in (SELECT b.""title""
var fsql = g.pgsql; var fsql = g.pgsql;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests.Provider.Odbc/SqlServer/Curd/SqlServerSelectTest.cs
View File

@ -184,7 +184,7 @@ namespace FreeSql.Tests.Odbc.SqlServer
g.sqlserver.Delete<District>().Where("1=1").ExecuteAffrows(); g.sqlserver.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.sqlserver.GetRepository<District>(); var repo = g.sqlserver.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1666,7 +1666,7 @@ WHERE (((cast(a.[Id] as nvarchar(100))) in (SELECT b.[Title]
var fsql = g.sqlserver; var fsql = g.sqlserver;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

2
FreeSql.Tests/FreeSql.Tests.Provider.Odbc/UnitTest1.cs
View File

@ -532,7 +532,7 @@ WHERE ROWNUM < 11";
).ToSql(); ).ToSql();
g.mysql.SetDbContextOptions(opt => opt.EnableAddOrUpdateNavigate = true); g.mysql.SetDbContextOptions(opt => opt.EnableCascadeSave = true);
var trepo = g.mysql.GetGuidRepository<TaskBuild>(); var trepo = g.mysql.GetGuidRepository<TaskBuild>();
trepo.Insert(new TaskBuild trepo.Insert(new TaskBuild
{ {

4
FreeSql.Tests/FreeSql.Tests.Provider.Sqlite.Data/Sqlite/Curd/SqliteSelectTest.cs
View File

@ -234,7 +234,7 @@ namespace FreeSql.Tests.Sqlite
g.sqlite.Delete<District>().Where("1=1").ExecuteAffrows(); g.sqlite.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.sqlite.GetRepository<District>(); var repo = g.sqlite.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -2072,7 +2072,7 @@ WHERE (((cast(a.""Id"" as character)) in (SELECT b.""Title""
var fsql = g.sqlite; var fsql = g.sqlite;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests/Dameng/Curd/DamengSelectTest.cs
View File

@ -309,7 +309,7 @@ WHERE (((a.""NAME"") in (SELECT s.""TITLE"" as1
g.dameng.Delete<District>().Where("1=1").ExecuteAffrows(); g.dameng.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.dameng.GetRepository<District>(); var repo = g.dameng.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1867,7 +1867,7 @@ WHERE (((to_char(a.""ID"")) in (SELECT b.""TITLE""
var fsql = g.dameng; var fsql = g.dameng;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests/Firebird/Curd/FirebirdSelectTest.cs
View File

@ -309,7 +309,7 @@ WHERE (((a.""NAME"") in (SELECT s.""TITLE"" as1
g.firebird.Delete<District>().Where("1=1").ExecuteAffrows(); g.firebird.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.firebird.GetRepository<District>(); var repo = g.firebird.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1834,7 +1834,7 @@ WHERE (((cast(a.""ID"" as blob sub_type 1)) in (SELECT FIRST 10 b.""TITLE""
var fsql = g.firebird; var fsql = g.firebird;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests/KingbaseES/Curd/KingbaseESSelectTest.cs
View File

@ -194,7 +194,7 @@ namespace FreeSql.Tests.KingbaseES
g.kingbaseES.Delete<District>().Where("1=1").ExecuteAffrows(); g.kingbaseES.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.kingbaseES.GetRepository<District>(); var repo = g.kingbaseES.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1681,7 +1681,7 @@ WHERE ((((a.""ID"")::text) in (SELECT b.""TITLE""
var fsql = g.kingbaseES; var fsql = g.kingbaseES;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

2
FreeSql.Tests/FreeSql.Tests/Linq/QueryableTest.cs
View File

@ -59,7 +59,7 @@ namespace FreeSql.Tests.Linq
} }
}; };
var repo = fsql.GetRepository<qt01>(); var repo = fsql.GetRepository<qt01>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(sd); repo.Insert(sd);
Assert.True(fsql.Select<qt01>().AsQueryable().Any()); Assert.True(fsql.Select<qt01>().AsQueryable().Any());

4
FreeSql.Tests/FreeSql.Tests/MsAccess/Curd/MsAccessSelectTest.cs
View File

@ -300,7 +300,7 @@ WHERE (((a.[Name]) in (SELECT s.[Title] as as1
g.msaccess.Delete<District>().Where("1=1").ExecuteAffrows(); g.msaccess.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.msaccess.GetRepository<District>(); var repo = g.msaccess.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1645,7 +1645,7 @@ WHERE (((cstr(a.[Id])) in (SELECT TOP 10 b.[Title]
var fsql = g.msaccess; var fsql = g.msaccess;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests/MySql/Curd/MySqlSelectTest.cs
View File

@ -427,7 +427,7 @@ WHERE (((a.`Name`) in (SELECT s.`Title` as1
g.mysql.Delete<District>().Where("1=1").ExecuteAffrows(); g.mysql.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.mysql.GetRepository<District>(); var repo = g.mysql.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -2090,7 +2090,7 @@ WHERE ((b.`IsFinished` OR a.`TaskType` = 3) AND b.`EnabledMark` = 1)", groupsql1
var fsql = g.mysql; var fsql = g.mysql;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests/Oracle/Curd/OracleSelectTest.cs
View File

@ -309,7 +309,7 @@ WHERE (((a.""NAME"") in (SELECT s.""TITLE"" as1
g.oracle.Delete<District>().Where("1=1").ExecuteAffrows(); g.oracle.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.oracle.GetRepository<District>(); var repo = g.oracle.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1843,7 +1843,7 @@ WHERE (((to_char(a.""ID"")) in (SELECT b.""TITLE""
var fsql = g.oracle; var fsql = g.oracle;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests/PostgreSQL/Curd/PostgreSQLSelectTest.cs
View File

@ -401,7 +401,7 @@ WHERE (((a.""name"") in (SELECT s.""title"" as1
g.pgsql.Delete<District>().Where("1=1").ExecuteAffrows(); g.pgsql.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.pgsql.GetRepository<District>(); var repo = g.pgsql.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1927,7 +1927,7 @@ WHERE ((((a.""id"")::text) in (SELECT b.""title""
var fsql = g.pgsql; var fsql = g.pgsql;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests/ShenTong/Curd/ShenTongSelectTest.cs
View File

@ -270,7 +270,7 @@ namespace FreeSql.Tests.ShenTong
g.shentong.Delete<District>().Where("1=1").ExecuteAffrows(); g.shentong.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.shentong.GetRepository<District>(); var repo = g.shentong.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1789,7 +1789,7 @@ WHERE ((((a.""ID"")::text) in (SELECT b.""TITLE""
var fsql = g.shentong; var fsql = g.shentong;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests/SqlServer/Curd/SqlServerSelectTest.cs
View File

@ -306,7 +306,7 @@ WHERE (((a.[Name]) in (SELECT s.[Title] as1
g.sqlserver.Delete<District>().Where("1=1").ExecuteAffrows(); g.sqlserver.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.sqlserver.GetRepository<District>(); var repo = g.sqlserver.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -1910,7 +1910,7 @@ INNER JOIN [TestTypeInfo] a__Type With(NoLock) ON a__Type.[Guid] = a.[Id]", sql2
var fsql = g.sqlserver; var fsql = g.sqlserver;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests/Sqlite/Curd/SqliteSelectTest.cs
View File

@ -354,7 +354,7 @@ WHERE (((a.""Name"") in (SELECT s.""Title"" as1
g.sqlite.Delete<District>().Where("1=1").ExecuteAffrows(); g.sqlite.Delete<District>().Where("1=1").ExecuteAffrows();
var repo = g.sqlite.GetRepository<District>(); var repo = g.sqlite.GetRepository<District>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new District repo.Insert(new District
{ {
Code = "001", Code = "001",
@ -2217,7 +2217,7 @@ WHERE (((cast(a.""Id"" as character)) in (SELECT b.""Title""
var fsql = g.sqlite; var fsql = g.sqlite;
fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows(); fsql.Delete<BaseDistrict>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<VM_District_Child>(); var repo = fsql.GetRepository<VM_District_Child>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.DbContextOptions.NoneParameter = true; repo.DbContextOptions.NoneParameter = true;
repo.Insert(new VM_District_Child repo.Insert(new VM_District_Child
{ {

4
FreeSql.Tests/FreeSql.Tests/UnitTest1.cs
View File

@ -830,7 +830,7 @@ namespace FreeSql.Tests
).ToSql(); ).ToSql();
g.sqlite.SetDbContextOptions(opt => opt.EnableAddOrUpdateNavigate = true); g.sqlite.SetDbContextOptions(opt => opt.EnableCascadeSave = true);
var trepo = g.sqlite.GetGuidRepository<TaskBuild>(); var trepo = g.sqlite.GetGuidRepository<TaskBuild>();
trepo.Insert(new TaskBuild trepo.Insert(new TaskBuild
{ {
@ -1146,7 +1146,7 @@ namespace FreeSql.Tests
}; };
var repo = g.mysql.GetRepository<Order>(); var repo = g.mysql.GetRepository<Order>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(neworder); repo.Insert(neworder);
var order = g.mysql.Select<Order>().Where(a => a.Id == neworder.Id).ToOne(); //查询订单表 var order = g.mysql.Select<Order>().Where(a => a.Id == neworder.Id).ToOne(); //查询订单表

2
FreeSql.Tests/FreeSql.Tests/UnitTest3.cs
View File

@ -210,7 +210,7 @@ namespace FreeSql.Tests
g.sqlite.Delete<tcate01>().Where("1=1").ExecuteAffrows(); g.sqlite.Delete<tcate01>().Where("1=1").ExecuteAffrows();
g.sqlite.Delete<tshop01>().Where("1=1").ExecuteAffrows(); g.sqlite.Delete<tshop01>().Where("1=1").ExecuteAffrows();
var tshoprepo = g.sqlite.GetRepository<tcate01>(); var tshoprepo = g.sqlite.GetRepository<tcate01>();
tshoprepo.DbContextOptions.EnableAddOrUpdateNavigate = true; tshoprepo.DbContextOptions.EnableCascadeSave = true;
tshoprepo.Insert(new tcate01[] tshoprepo.Insert(new tcate01[]
{ {
new tcate01 { name = "tcate1", tshops = new List<tshop01>{ new tshop01(), new tshop01(), new tshop01() } }, new tcate01 { name = "tcate1", tshops = new List<tshop01>{ new tshop01(), new tshop01(), new tshop01() } },

2
FreeSql.Tests/FreeSql.Tests/UnitTest4.cs
View File

@ -304,7 +304,7 @@ GROUP BY a.""code"", a.""seqid"", a.""name""", sql);
fsql.Delete<ts_otm_ll_02>().Where("1=1").ExecuteAffrows(); fsql.Delete<ts_otm_ll_02>().Where("1=1").ExecuteAffrows();
var repo = fsql.GetRepository<ts_otm_ll_01>(); var repo = fsql.GetRepository<ts_otm_ll_01>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
repo.Insert(new ts_otm_ll_01 repo.Insert(new ts_otm_ll_01
{ {
name = "001", name = "001",

2
README.md
View File

@ -132,7 +132,7 @@ fsql.Select<Song>().OrderBy(a => Guid.NewGuid()).Limit(10).ToList();
[Transactional] [Transactional]
public void Add() { public void Add() {
var repo = ioc.GetService<BaseRepository<Tag>>(); var repo = ioc.GetService<BaseRepository<Tag>>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
var item = new Tag { var item = new Tag {
Name = "testaddsublist", Name = "testaddsublist",

2
README.zh-CN.md
View File

@ -135,7 +135,7 @@ fsql.Select<Song>().OrderBy(a => Guid.NewGuid()).Limit(10).ToList();
[Transactional] [Transactional]
public void Add() { public void Add() {
var repo = ioc.GetService<BaseRepository<Tag>>(); var repo = ioc.GetService<BaseRepository<Tag>>();
repo.DbContextOptions.EnableAddOrUpdateNavigate = true; repo.DbContextOptions.EnableCascadeSave = true;
var item = new Tag { var item = new Tag {
Name = "testaddsublist", Name = "testaddsublist",