tk/FreeSql
1
0
Fork 0
mirror of https://github.com/nsnail/FreeSql.git synced 2025-04-22 10:42:52 +08:00
Code Issues Packages Projects Releases Wiki Activity

- 优化 IUpdate ToSql；

Browse Source
This commit is contained in:
2881099 2022-06-30 13:54:51 +08:00
parent 3f77ea3a63
commit 0e82d6c3e3
7 changed files with 306 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
FreeSql.DbContext/FreeSql.DbContext.xml
View File

@ -800,14 +800,5 @@
<param name="that"></param>
<returns></returns>
</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>
</doc>

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

@ -1,6 +1,8 @@
using FreeSql.DataAnnotations;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using Xunit;
@ -12,180 +14,196 @@ namespace FreeSql.Tests
[Fact]
public void DeleteCascade()
{
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 userRepo = fsql.GetRepository<DeleteCascadeUser>();
var userextRepo = fsql.GetRepository<DeleteCascadeUserExt>();
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<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
var user = new DeleteCascadeUser { Username = "admin01", Password = "pwd01", UserExt = new DeleteCascadeUserExt { Remark = "用户备注01" } };
userRepo.Insert(user);
var ret = userRepo.DeleteCascadeByDatabase(a => a.Id == user.Id);
Assert.Equal(2, ret.Count);
Assert.IsType<DeleteCascadeUserExt>(ret[0]);
Assert.Equal(user.UserExt.UserId, (ret[0] as DeleteCascadeUserExt).UserId);
Assert.Equal(user.UserExt.Remark, (ret[0] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUser>(ret[1]);
Assert.Equal(user.Id, (ret[1] as DeleteCascadeUser).Id);
Assert.Equal(user.Username, (ret[1] as DeleteCascadeUser).Username);
Assert.Equal(user.Password, (ret[1] as DeleteCascadeUser).Password);
//OneToOne EnableCascadeSave InMemory
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 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.DeleteCascadeByDatabase(a => a.UserId == user.UserExt.UserId);
Assert.Equal(2, ret.Count);
Assert.IsType<DeleteCascadeUserExt>(ret[1]);
Assert.Equal(user.UserExt.UserId, (ret[1] as DeleteCascadeUserExt).UserId);
Assert.Equal(user.UserExt.Remark, (ret[1] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUser>(ret[0]);
Assert.Equal(user.Id, (ret[0] as DeleteCascadeUser).Id);
Assert.Equal(user.Username, (ret[0] as DeleteCascadeUser).Username);
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 InDatabase
fsql.Delete<DeleteCascadeUserGroup>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
var group = new DeleteCascadeUserGroup
using (var fsql = new FreeSqlBuilder()
.UseConnectionString(DataType.Sqlite, "data source=:memory:")
.UseAutoSyncStructure(true)
.UseNoneCommandParameter(true)
.UseMonitorCommand(cmd => Trace.WriteLine(cmd.CommandText))
.Build())
{
GroupName = "group01",
Users = new List<DeleteCascadeUser>
fsql.CodeFirst.GetTableByEntity(typeof(DeleteCascadeUserGroup)).ColumnsByCs
.Where(a => !new[] { typeof(string), typeof(int), typeof(DateTime), typeof(long) }.Contains(a.Value.Attribute.MapType))
.ToArray();
fsql.GlobalFilter.Apply<DeleteCascadeUserGroup>("soft_delete", a => a.IsDeleted == false);
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 userRepo = fsql.GetRepository<DeleteCascadeUser>();
var userextRepo = fsql.GetRepository<DeleteCascadeUserExt>();
var tagRepo = fsql.GetRepository<DeleteCascadeTag>();
groupRepo.DbContextOptions.EnableCascadeSave = true;
userRepo.DbContextOptions.EnableCascadeSave = true;
userextRepo.DbContextOptions.EnableCascadeSave = true;
tagRepo.DbContextOptions.EnableCascadeSave = true;
groupRepo.DbContextOptions.EnableGlobalFilter = false;
userRepo.DbContextOptions.EnableGlobalFilter = false;
userextRepo.DbContextOptions.EnableGlobalFilter = false;
tagRepo.DbContextOptions.EnableGlobalFilter = false;
//OneToOne InDatabase
fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
var user = new DeleteCascadeUser { Username = "admin01", Password = "pwd01", UserExt = new DeleteCascadeUserExt { Remark = "用户备注01" } };
userRepo.Insert(user);
var ret = userRepo.DeleteCascadeByDatabase(a => a.Id == user.Id);
Assert.Equal(2, ret.Count);
Assert.IsType<DeleteCascadeUserExt>(ret[0]);
Assert.Equal(user.UserExt.UserId, (ret[0] as DeleteCascadeUserExt).UserId);
Assert.Equal(user.UserExt.Remark, (ret[0] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUser>(ret[1]);
Assert.Equal(user.Id, (ret[1] as DeleteCascadeUser).Id);
Assert.Equal(user.Username, (ret[1] as DeleteCascadeUser).Username);
Assert.Equal(user.Password, (ret[1] as DeleteCascadeUser).Password);
//OneToOne EnableCascadeSave InMemory
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 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.DeleteCascadeByDatabase(a => a.UserId == user.UserExt.UserId);
Assert.Equal(2, ret.Count);
Assert.IsType<DeleteCascadeUserExt>(ret[1]);
Assert.Equal(user.UserExt.UserId, (ret[1] as DeleteCascadeUserExt).UserId);
Assert.Equal(user.UserExt.Remark, (ret[1] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUser>(ret[0]);
Assert.Equal(user.Id, (ret[0] as DeleteCascadeUser).Id);
Assert.Equal(user.Username, (ret[0] as DeleteCascadeUser).Username);
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 InDatabase
fsql.Delete<DeleteCascadeUserGroup>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
var 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);
ret = groupRepo.DeleteCascadeByDatabase(a => a.Id == group.Id);
Assert.Equal(7, ret.Count);
Assert.IsType<DeleteCascadeUserExt>(ret[0]);
Assert.Equal(group.Users[0].UserExt.UserId, (ret[0] as DeleteCascadeUserExt).UserId);
Assert.Equal(group.Users[0].UserExt.Remark, (ret[0] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUserExt>(ret[1]);
Assert.Equal(group.Users[1].UserExt.UserId, (ret[1] as DeleteCascadeUserExt).UserId);
Assert.Equal(group.Users[1].UserExt.Remark, (ret[1] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUserExt>(ret[2]);
Assert.Equal(group.Users[2].UserExt.UserId, (ret[2] as DeleteCascadeUserExt).UserId);
Assert.Equal(group.Users[2].UserExt.Remark, (ret[2] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUser>(ret[3]);
Assert.Equal(group.Users[0].Id, (ret[3] as DeleteCascadeUser).Id);
Assert.Equal(group.Users[0].Username, (ret[3] as DeleteCascadeUser).Username);
Assert.Equal(group.Users[0].Password, (ret[3] as DeleteCascadeUser).Password);
Assert.IsType<DeleteCascadeUser>(ret[4]);
Assert.Equal(group.Users[1].Id, (ret[4] as DeleteCascadeUser).Id);
Assert.Equal(group.Users[1].Username, (ret[4] as DeleteCascadeUser).Username);
Assert.Equal(group.Users[1].Password, (ret[4] as DeleteCascadeUser).Password);
Assert.IsType<DeleteCascadeUser>(ret[5]);
Assert.Equal(group.Users[2].Id, (ret[5] as DeleteCascadeUser).Id);
Assert.Equal(group.Users[2].Username, (ret[5] as DeleteCascadeUser).Username);
Assert.Equal(group.Users[2].Password, (ret[5] as DeleteCascadeUser).Password);
Assert.IsType<DeleteCascadeUserGroup>(ret[6]);
Assert.Equal(group.Id, (ret[6] as DeleteCascadeUserGroup).Id);
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>
};
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);
ret = groupRepo.DeleteCascadeByDatabase(a => a.Id == group.Id);
Assert.Equal(7, ret.Count);
Assert.IsType<DeleteCascadeUserExt>(ret[0]);
Assert.Equal(group.Users[0].UserExt.UserId, (ret[0] as DeleteCascadeUserExt).UserId);
Assert.Equal(group.Users[0].UserExt.Remark, (ret[0] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUserExt>(ret[1]);
Assert.Equal(group.Users[1].UserExt.UserId, (ret[1] as DeleteCascadeUserExt).UserId);
Assert.Equal(group.Users[1].UserExt.Remark, (ret[1] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUserExt>(ret[2]);
Assert.Equal(group.Users[2].UserExt.UserId, (ret[2] as DeleteCascadeUserExt).UserId);
Assert.Equal(group.Users[2].UserExt.Remark, (ret[2] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUser>(ret[3]);
Assert.Equal(group.Users[0].Id, (ret[3] as DeleteCascadeUser).Id);
Assert.Equal(group.Users[0].Username, (ret[3] as DeleteCascadeUser).Username);
Assert.Equal(group.Users[0].Password, (ret[3] as DeleteCascadeUser).Password);
Assert.IsType<DeleteCascadeUser>(ret[4]);
Assert.Equal(group.Users[1].Id, (ret[4] as DeleteCascadeUser).Id);
Assert.Equal(group.Users[1].Username, (ret[4] as DeleteCascadeUser).Username);
Assert.Equal(group.Users[1].Password, (ret[4] as DeleteCascadeUser).Password);
Assert.IsType<DeleteCascadeUser>(ret[5]);
Assert.Equal(group.Users[2].Id, (ret[5] as DeleteCascadeUser).Id);
Assert.Equal(group.Users[2].Username, (ret[5] as DeleteCascadeUser).Username);
Assert.Equal(group.Users[2].Password, (ret[5] as DeleteCascadeUser).Password);
Assert.IsType<DeleteCascadeUserGroup>(ret[6]);
Assert.Equal(group.Id, (ret[6] as DeleteCascadeUserGroup).Id);
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());
};
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 InDatabase
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();
var tags = new[] {
//ManyToMany InDatabase
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();
var tags = new[] {
new DeleteCascadeTag { TagName = "tag01" },
new DeleteCascadeTag { TagName = "tag02" },
new DeleteCascadeTag { TagName = "tag03" },
@ -195,94 +213,94 @@ namespace FreeSql.Tests
new DeleteCascadeTag { TagName = "tag07" },
new DeleteCascadeTag { TagName = "tag08" },
};
tagRepo.Insert(tags);
groupRepo.DbContextOptions.EnableCascadeSave = true;
group = new DeleteCascadeUserGroup
{
GroupName = "group01",
Users = new List<DeleteCascadeUser>
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);
ret = groupRepo.DeleteCascadeByDatabase(a => a.Id == group.Id);
Assert.Equal(18, ret.Count);
};
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);
ret = groupRepo.DeleteCascadeByDatabase(a => a.Id == group.Id);
Assert.Equal(18, ret.Count);
Assert.IsType<DeleteCascadeUserExt>(ret[0]);
Assert.Equal(group.Users[0].UserExt.UserId, (ret[0] as DeleteCascadeUserExt).UserId);
Assert.Equal(group.Users[0].UserExt.Remark, (ret[0] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUserExt>(ret[1]);
Assert.Equal(group.Users[1].UserExt.UserId, (ret[1] as DeleteCascadeUserExt).UserId);
Assert.Equal(group.Users[1].UserExt.Remark, (ret[1] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUserExt>(ret[2]);
Assert.Equal(group.Users[2].UserExt.UserId, (ret[2] as DeleteCascadeUserExt).UserId);
Assert.Equal(group.Users[2].UserExt.Remark, (ret[2] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUserExt>(ret[0]);
Assert.Equal(group.Users[0].UserExt.UserId, (ret[0] as DeleteCascadeUserExt).UserId);
Assert.Equal(group.Users[0].UserExt.Remark, (ret[0] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUserExt>(ret[1]);
Assert.Equal(group.Users[1].UserExt.UserId, (ret[1] as DeleteCascadeUserExt).UserId);
Assert.Equal(group.Users[1].UserExt.Remark, (ret[1] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUserExt>(ret[2]);
Assert.Equal(group.Users[2].UserExt.UserId, (ret[2] as DeleteCascadeUserExt).UserId);
Assert.Equal(group.Users[2].UserExt.Remark, (ret[2] as DeleteCascadeUserExt).Remark);
Assert.IsType<DeleteCascadeUserTag>(ret[3]);
Assert.Equal(group.Users[0].Id, (ret[3] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[0].Id, (ret[3] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[4]);
Assert.Equal(group.Users[0].Id, (ret[4] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[2].Id, (ret[4] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[5]);
Assert.Equal(group.Users[0].Id, (ret[5] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[3].Id, (ret[5] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[6]);
Assert.Equal(group.Users[0].Id, (ret[6] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[6].Id, (ret[6] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[3]);
Assert.Equal(group.Users[0].Id, (ret[3] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[0].Id, (ret[3] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[4]);
Assert.Equal(group.Users[0].Id, (ret[4] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[2].Id, (ret[4] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[5]);
Assert.Equal(group.Users[0].Id, (ret[5] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[3].Id, (ret[5] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[6]);
Assert.Equal(group.Users[0].Id, (ret[6] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[6].Id, (ret[6] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[7]);
Assert.Equal(group.Users[1].Id, (ret[7] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[1].Id, (ret[7] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[8]);
Assert.Equal(group.Users[1].Id, (ret[8] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[2].Id, (ret[8] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[9]);
Assert.Equal(group.Users[1].Id, (ret[9] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[5].Id, (ret[9] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[7]);
Assert.Equal(group.Users[1].Id, (ret[7] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[1].Id, (ret[7] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[8]);
Assert.Equal(group.Users[1].Id, (ret[8] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[2].Id, (ret[8] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[9]);
Assert.Equal(group.Users[1].Id, (ret[9] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[5].Id, (ret[9] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[10]);
Assert.Equal(group.Users[2].Id, (ret[10] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[3].Id, (ret[10] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[11]);
Assert.Equal(group.Users[2].Id, (ret[11] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[4].Id, (ret[11] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[12]);
Assert.Equal(group.Users[2].Id, (ret[12] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[6].Id, (ret[12] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[13]);
Assert.Equal(group.Users[2].Id, (ret[13] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[7].Id, (ret[13] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[10]);
Assert.Equal(group.Users[2].Id, (ret[10] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[3].Id, (ret[10] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[11]);
Assert.Equal(group.Users[2].Id, (ret[11] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[4].Id, (ret[11] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[12]);
Assert.Equal(group.Users[2].Id, (ret[12] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[6].Id, (ret[12] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUserTag>(ret[13]);
Assert.Equal(group.Users[2].Id, (ret[13] as DeleteCascadeUserTag).UserId);
Assert.Equal(tags[7].Id, (ret[13] as DeleteCascadeUserTag).TagId);
Assert.IsType<DeleteCascadeUser>(ret[14]);
Assert.Equal(group.Users[0].Id, (ret[14] as DeleteCascadeUser).Id);
Assert.Equal(group.Users[0].Username, (ret[14] as DeleteCascadeUser).Username);
Assert.Equal(group.Users[0].Password, (ret[14] as DeleteCascadeUser).Password);
Assert.IsType<DeleteCascadeUser>(ret[15]);
Assert.Equal(group.Users[1].Id, (ret[15] as DeleteCascadeUser).Id);
Assert.Equal(group.Users[1].Username, (ret[15] as DeleteCascadeUser).Username);
Assert.Equal(group.Users[1].Password, (ret[15] as DeleteCascadeUser).Password);
Assert.IsType<DeleteCascadeUser>(ret[16]);
Assert.Equal(group.Users[2].Id, (ret[16] as DeleteCascadeUser).Id);
Assert.Equal(group.Users[2].Username, (ret[16] as DeleteCascadeUser).Username);
Assert.Equal(group.Users[2].Password, (ret[16] as DeleteCascadeUser).Password);
Assert.IsType<DeleteCascadeUserGroup>(ret[17]);
Assert.Equal(group.Id, (ret[17] as DeleteCascadeUserGroup).Id);
Assert.Equal(group.GroupName, (ret[17] as DeleteCascadeUserGroup).GroupName);
Assert.IsType<DeleteCascadeUser>(ret[14]);
Assert.Equal(group.Users[0].Id, (ret[14] as DeleteCascadeUser).Id);
Assert.Equal(group.Users[0].Username, (ret[14] as DeleteCascadeUser).Username);
Assert.Equal(group.Users[0].Password, (ret[14] as DeleteCascadeUser).Password);
Assert.IsType<DeleteCascadeUser>(ret[15]);
Assert.Equal(group.Users[1].Id, (ret[15] as DeleteCascadeUser).Id);
Assert.Equal(group.Users[1].Username, (ret[15] as DeleteCascadeUser).Username);
Assert.Equal(group.Users[1].Password, (ret[15] as DeleteCascadeUser).Password);
Assert.IsType<DeleteCascadeUser>(ret[16]);
Assert.Equal(group.Users[2].Id, (ret[16] as DeleteCascadeUser).Id);
Assert.Equal(group.Users[2].Username, (ret[16] as DeleteCascadeUser).Username);
Assert.Equal(group.Users[2].Password, (ret[16] as DeleteCascadeUser).Password);
Assert.IsType<DeleteCascadeUserGroup>(ret[17]);
Assert.Equal(group.Id, (ret[17] as DeleteCascadeUserGroup).Id);
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[] {
//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" },
@ -292,45 +310,46 @@ namespace FreeSql.Tests
new DeleteCascadeTag { TagName = "tag07" },
new DeleteCascadeTag { TagName = "tag08" },
};
tagRepo.Insert(tags);
groupRepo.DbContextOptions.EnableCascadeSave = true;
group = new DeleteCascadeUserGroup
{
GroupName = "group01",
Users = new List<DeleteCascadeUser>
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());
};
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
{
@ -339,6 +358,7 @@ namespace FreeSql.Tests
public string Username { get; set; }
public string Password { get; set; }
public int GroupId { get; set; }
public bool IsDeleted { get; set; }
[Navigate(nameof(Id))]
public DeleteCascadeUserExt UserExt { get; set; }
@ -350,6 +370,7 @@ namespace FreeSql.Tests
[Column(IsPrimary = true)]
public int UserId { get; set; }
public string Remark { get; set; }
public bool IsDeleted { get; set; }
[Navigate(nameof(UserId))]
public DeleteCascadeUser User { get; set; }
@ -359,6 +380,7 @@ namespace FreeSql.Tests
[Column(IsIdentity = true)]
public int Id { get; set; }
public string GroupName { get; set; }
public bool IsDeleted { get; set; }
[Navigate(nameof(DeleteCascadeUser.GroupId))]
public List<DeleteCascadeUser> Users { get; set; }
@ -368,6 +390,7 @@ namespace FreeSql.Tests
[Column(IsIdentity = true)]
public int Id { get; set; }
public string TagName { get; set; }
public bool IsDeleted { get; set; }
[Navigate(ManyToMany = typeof(DeleteCascadeUserTag))]
public List<DeleteCascadeUser> Users { get; set; }
@ -376,6 +399,7 @@ namespace FreeSql.Tests
{
public int UserId { get; set; }
public int TagId { get; set; }
public bool IsDeleted { get; set; }
[Navigate(nameof(UserId))]
public DeleteCascadeUser User { get; set; }

5
FreeSql.Tests/FreeSql.Tests/Sqlite/Curd/SqliteUpdateTest.cs
View File

@ -1,4 +1,4 @@
using FreeSql.DataAnnotations;
using FreeSql.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
@ -174,6 +174,9 @@ namespace FreeSql.Tests.Sqlite
sql = update.Set(a => a.Clicks == null).Where(a => a.Id == 1).ToSql().Replace("\r\n", "");
Assert.Equal("UPDATE \"tb_topic\" SET \"Clicks\" = NULL WHERE (\"Id\" = 1)", sql);
sql = update.SetIf(false, a => a.Clicks == null).Where(a => a.Id == 1).ToSql()?.Replace("\r\n", "");
Assert.Null(sql);
}
[Fact]
public void SetRaw()

1
FreeSql/Internal/CommonProvider/DeleteProvider.cs
View File

@ -177,6 +177,7 @@ namespace FreeSql.Internal.CommonProvider
sb.Append(sql).Append("\r\n\r\n;\r\n\r\n");
});
if (sb.Length > 0) sb.Remove(sb.Length - 9, 9);
if (sb.Length == 0) return null;
return sb.ToString();
}

2
FreeSql/Internal/CommonProvider/UpdateProvider.cs
View File

@ -797,6 +797,7 @@ namespace FreeSql.Internal.CommonProvider
sb2.Append(sql).Append("\r\n\r\n;\r\n\r\n");
});
if (sb2.Length > 0) sb2.Remove(sb2.Length - 9, 9);
if (sb2.Length == 0) return null;
return sb2.ToString();
}
@ -866,6 +867,7 @@ namespace FreeSql.Internal.CommonProvider
public virtual void ToSqlExtension110(StringBuilder sb, bool isAsTableSplited)
{
if (_where.Length == 0 && _source.Any() == false) return;
if (_source.Any() == false && _set.Length == 0 && _setIncr.Length == 0) return;
if (_table.AsTableImpl != null && isAsTableSplited == false && _source == _sourceOld && _source.Any())
{

2
Providers/FreeSql.Provider.ClickHouse/Curd/ClickHouseDelete.cs
View File

@ -20,7 +20,7 @@ namespace FreeSql.ClickHouse.Curd
public override string ToSql()
{
return base.ToSql().Replace("DELETE FROM ", "ALTER TABLE ").Replace(" WHERE ", " DELETE WHERE ");
return base.ToSql()?.Replace("DELETE FROM ", "ALTER TABLE ").Replace(" WHERE ", " DELETE WHERE ");
}
#if net40

1
Providers/FreeSql.Provider.ClickHouse/Curd/ClickHouseUpdate.cs
View File

@ -68,6 +68,7 @@ namespace FreeSql.ClickHouse.Curd
public override void ToSqlExtension110(StringBuilder sb, bool isAsTableSplited)
{
if (_where.Length == 0 && _source.Any() == false) return;
if (_source.Any() == false && _set.Length == 0 && _setIncr.Length == 0) return;
if (_table.AsTableImpl != null && isAsTableSplited == false && _source == _sourceOld && _source.Any())
{