- 增加 DbSet/Repository DeleteCascade 级联删除功能；#609

FreeSql.Tests/FreeSql.Tests.DbContext/RepositoryTests.cs

@@ -9,6 +9,252 @@ namespace FreeSql.Tests
 {
     public class RepositoryTests
     {
+        [Fact]
+        public void DeleteCascade()
+        {
+            var fsql = g.sqlite;
+            var groupRepo = fsql.GetRepository<DeleteCascadeUserGroup>();
+            var userRepo = fsql.GetRepository<DeleteCascadeUser>();
+            //OneToOne
+            fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
+            fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
+            var user = new DeleteCascadeUser { Username = "admin01", Password = "pwd01" };
+            userRepo.Insert(user);
+            var userExt = new DeleteCascadeUserExt { UserId = user.Id, Remark = "用户备注01" };
+            Assert.Equal(1, fsql.Insert(userExt).ExecuteAffrows());
+            var ret = userRepo.DeleteCascade(user);
+            Assert.Equal(2, ret.Count);
+            Assert.IsType<DeleteCascadeUserExt>(ret[0]);
+            Assert.Equal(userExt.UserId, (ret[0] as DeleteCascadeUserExt).UserId);
+            Assert.Equal(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 先删除 UserExt
+            fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
+            fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
+            user = new DeleteCascadeUser { Username = "admin01", Password = "pwd01" };
+            userRepo.Insert(user);
+            userExt = new DeleteCascadeUserExt { UserId = user.Id, Remark = "用户备注01" };
+            Assert.Equal(1, fsql.Insert(userExt).ExecuteAffrows());
+            ret = fsql.GetRepository<DeleteCascadeUserExt>().DeleteCascade(userExt);
+            Assert.Equal(2, ret.Count);
+            Assert.IsType<DeleteCascadeUserExt>(ret[1]);
+            Assert.Equal(userExt.UserId, (ret[1] as DeleteCascadeUserExt).UserId);
+            Assert.Equal(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);
+
+            //OneToMany
+            fsql.Delete<DeleteCascadeUserGroup>().Where("1=1").ExecuteAffrows();
+            fsql.Delete<DeleteCascadeUser>().Where("1=1").ExecuteAffrows();
+            fsql.Delete<DeleteCascadeUserExt>().Where("1=1").ExecuteAffrows();
+            groupRepo.DbContextOptions.EnableAddOrUpdateNavigateList = true;
+            var group = new DeleteCascadeUserGroup
+            {
+                GroupName = "group01",
+                Users = new List<DeleteCascadeUser>
+                {
+                    new DeleteCascadeUser { Username = "admin01", Password = "pwd01" },
+                    new DeleteCascadeUser { Username = "admin02", Password = "pwd02" },
+                    new DeleteCascadeUser { Username = "admin03", Password = "pwd03" },
+                }
+            };
+            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);
+            var userExt0 = new DeleteCascadeUserExt { UserId = group.Users[0].Id, Remark = "用户备注01" };
+            Assert.Equal(1, fsql.Insert(userExt0).ExecuteAffrows());
+            var userExt1 = new DeleteCascadeUserExt { UserId = group.Users[1].Id, Remark = "用户备注02" };
+            Assert.Equal(1, fsql.Insert(userExt1).ExecuteAffrows());
+            var userExt2 = new DeleteCascadeUserExt { UserId = group.Users[2].Id, Remark = "用户备注03" };
+            Assert.Equal(1, fsql.Insert(userExt2).ExecuteAffrows());
+            ret = groupRepo.DeleteCascade(group);
+            Assert.Equal(7, ret.Count);
+            Assert.IsType<DeleteCascadeUserExt>(ret[0]);
+            Assert.Equal(userExt0.UserId, (ret[0] as DeleteCascadeUserExt).UserId);
+            Assert.Equal(userExt0.Remark, (ret[0] as DeleteCascadeUserExt).Remark);
+            Assert.IsType<DeleteCascadeUserExt>(ret[1]);
+            Assert.Equal(userExt1.UserId, (ret[1] as DeleteCascadeUserExt).UserId);
+            Assert.Equal(userExt1.Remark, (ret[1] as DeleteCascadeUserExt).Remark);
+            Assert.IsType<DeleteCascadeUserExt>(ret[2]);
+            Assert.Equal(userExt2.UserId, (ret[2] as DeleteCascadeUserExt).UserId);
+            Assert.Equal(userExt2.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);
+
+            //ManyToMany
+            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" },
+                new DeleteCascadeTag { TagName = "tag04" },
+                new DeleteCascadeTag { TagName = "tag05" },
+                new DeleteCascadeTag { TagName = "tag06" },
+                new DeleteCascadeTag { TagName = "tag07" },
+                new DeleteCascadeTag { TagName = "tag08" },
+            };
+            fsql.GetRepository<DeleteCascadeTag>().Insert(tags);
+            groupRepo.DbContextOptions.EnableAddOrUpdateNavigateList = true;
+            group = new DeleteCascadeUserGroup
+            {
+                GroupName = "group01",
+                Users = new List<DeleteCascadeUser>
+                {
+                    new DeleteCascadeUser { Username = "admin01", Password = "pwd01", Tags = new List<DeleteCascadeTag> { tags[0], tags[2], tags[3], tags[6] } },
+                    new DeleteCascadeUser { Username = "admin02", Password = "pwd02", Tags = new List<DeleteCascadeTag> { tags[1], tags[2], tags[5] } },
+                    new DeleteCascadeUser { Username = "admin03", Password = "pwd03", 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);
+            userExt0 = new DeleteCascadeUserExt { UserId = group.Users[0].Id, Remark = "用户备注01" };
+            Assert.Equal(1, fsql.Insert(userExt0).ExecuteAffrows());
+            userExt1 = new DeleteCascadeUserExt { UserId = group.Users[1].Id, Remark = "用户备注02" };
+            Assert.Equal(1, fsql.Insert(userExt1).ExecuteAffrows());
+            userExt2 = new DeleteCascadeUserExt { UserId = group.Users[2].Id, Remark = "用户备注03" };
+            Assert.Equal(1, fsql.Insert(userExt2).ExecuteAffrows());
+            ret = groupRepo.DeleteCascade(group);
+            Assert.Equal(18, ret.Count);
+
+            Assert.IsType<DeleteCascadeUserExt>(ret[0]);
+            Assert.Equal(userExt0.UserId, (ret[0] as DeleteCascadeUserExt).UserId);
+            Assert.Equal(userExt0.Remark, (ret[0] as DeleteCascadeUserExt).Remark);
+            Assert.IsType<DeleteCascadeUserExt>(ret[1]);
+            Assert.Equal(userExt1.UserId, (ret[1] as DeleteCascadeUserExt).UserId);
+            Assert.Equal(userExt1.Remark, (ret[1] as DeleteCascadeUserExt).Remark);
+            Assert.IsType<DeleteCascadeUserExt>(ret[2]);
+            Assert.Equal(userExt2.UserId, (ret[2] as DeleteCascadeUserExt).UserId);
+            Assert.Equal(userExt2.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[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<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);
+        }
+        public class DeleteCascadeUser
+        {
+            [Column(IsIdentity = true)]
+            public int Id { get; set; }
+            public string Username { get; set; }
+            public string Password { get; set; }
+            public int GroupId { get; set; }
+
+            [Navigate(nameof(Id))]
+            public DeleteCascadeUserExt UserExt { get; set; }
+            [Navigate(ManyToMany = typeof(DeleteCascadeUserTag))]
+            public List<DeleteCascadeTag> Tags { get; set; }
+        }
+        public class DeleteCascadeUserExt
+        {
+            [Column(IsPrimary = true)]
+            public int UserId { get; set; }
+            public string Remark { get; set; }
+
+            [Navigate(nameof(UserId))]
+            public DeleteCascadeUser User { get; set; }
+        }
+        public class DeleteCascadeUserGroup
+        {
+            [Column(IsIdentity = true)]
+            public int Id { get; set; }
+            public string GroupName { get; set; }
+
+            [Navigate(nameof(DeleteCascadeUser.GroupId))]
+            public List<DeleteCascadeUser> Users { get; set; }
+        }
+        public class DeleteCascadeTag
+        {
+            [Column(IsIdentity = true)]
+            public int Id { get; set; }
+            public string TagName { get; set; }
+
+            [Navigate(ManyToMany = typeof(DeleteCascadeUserTag))]
+            public List<DeleteCascadeUser> Users { get; set; }
+        }
+        public class DeleteCascadeUserTag
+        {
+            public int UserId { get; set; }
+            public int TagId { get; set; }
+
+            [Navigate(nameof(UserId))]
+            public DeleteCascadeUser User { get; set; }
+            [Navigate(nameof(TagId))]
+            public DeleteCascadeTag Tag { get; set; }
+        }
+
         /// <summary>
         /// 更一条无法更新。
         /// </summary>

FreeSql.Tests/FreeSql.Tests/Internal/UtilsTest.cs

@@ -148,7 +148,7 @@ UNION ALL
 SELECT  * from (SELECT a.""id"", a.""msg"", a.""createtime""
 FROM ""as_table_log_202201"" a
 WHERE (a.""createtime"" < '2022-05-01 00:00:00')) ftb", dict);
-            Assert.Equal(1, dict.Count);
+            Assert.Single(dict);
             sql3 = sql2;
             dict.Select(a => sql3 = sql3.Replace(a.Key, "{0}".FormatMySql(a.Value))).ToList();
             Assert.Equal(sql1, sql3);

FreeSql.Tests/FreeSql.Tests/Sqlite/Curd/SqliteDeleteTest.cs

@@ -5,6 +5,7 @@ using FreeSql.Internal.Model;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Reflection;
 using System.Text;
 using Xunit;
@@ -109,120 +110,3 @@ namespace FreeSql.Tests.Sqlite
         }
     }
 }
-
-public static class DeleteExtensions
-{
-    public static string ToSqlCascade<T>(this IDelete<T> that)
-    {
-        var delete = that as DeleteProvider;
-        if (delete == null) return null;
-        if (delete._whereTimes <= 0 || delete._where.Length == 0) return null;
-        if (LocalGetNavigates(delete._table).Any() == false) return that.ToSql();
-
-        var fsql = delete._orm;
-        var sb = new StringBuilder();
-        Dictionary<string, bool> eachdic = new Dictionary<string, bool>();
-
-        var rootSel = fsql.Select<object>().AsType(delete._table.Type).Where(delete._where.ToString());
-        var rootItems = rootSel.ToList();
-        LocalEach(delete._table.Type, rootItems, true);
-        return sb.ToString();
-
-        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();
-        }
-        void LocalEach(Type itemType, List<object> items, bool isOneToOne)
-        {
-            items = items?.Where(item =>
-            {
-                var itemKeystr = FreeSql.Extensions.EntityUtil.EntityUtilExtensions.GetEntityKeyString(fsql, itemType, item, false);
-                var eachdicKey = $"{itemType.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(itemType);
-            var navs = LocalGetNavigates(tb);
-
-            var otos = navs.Where(a => a.Item1.RefType == TableRefType.OneToOne).ToList();
-            if (otos.Any())
-            {
-                foreach (var oto in otos)
-                {
-                    var childsSel = fsql.Select<object>().AsType(oto.Item1.RefEntityType) as Select1Provider<object>;
-                    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(childsSel._tables[0].Table, refitem, oto.Item1.RefColumns[a].CsName, colval);
-                        }
-                        return refitem;
-                    }).ToList();
-
-                    childsSel.Where(childsSel._commonUtils.WhereItems(oto.Item1.RefColumns.ToArray(), "a.", refitems));
-                    var childs = childsSel.ToList();
-                    LocalEach(oto.Item1.RefEntityType, childs, false);
-                }
-            }
-
-            var otms = navs.Where(a => a.Item1.RefType == TableRefType.OneToMany).ToList();
-            if (otms.Any())
-            {
-                foreach (var otm in otms)
-                {
-                    var childsSel = fsql.Select<object>().AsType(otm.Item1.RefEntityType) as Select1Provider<object>;
-                    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(childsSel._tables[0].Table, refitem, otm.Item1.RefColumns[a].CsName, colval);
-                        }
-                        return refitem;
-                    }).ToList();
-
-                    childsSel.Where(childsSel._commonUtils.WhereItems(otm.Item1.RefColumns.ToArray(), "a.", refitems));
-                    var childs = childsSel.ToList();
-                    LocalEach(otm.Item1.RefEntityType, childs, true);
-                }
-            }
-
-            var mtms = navs.Where(a => a.Item1.RefType == TableRefType.ManyToMany).ToList();
-            if (mtms.Any())
-            {
-                foreach (var mtm in mtms)
-                {
-                    var childsSel = fsql.Select<object>().AsType(mtm.Item1.RefMiddleEntityType) as Select1Provider<object>;
-                    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(childsSel._tables[0].Table, refitem, mtm.Item1.MiddleColumns[a].CsName, colval);
-                        }
-                        return refitem;
-                    }).ToList();
-
-                    childsSel.Where(childsSel._commonUtils.WhereItems(mtm.Item1.MiddleColumns.Take(mtm.Item1.Columns.Count).ToArray(), "a.", miditems));
-                    var childs = childsSel.ToList();
-                    LocalEach(mtm.Item1.RefEntityType, childs, true);
-                }
-            }
-
-            var delSql = fsql.Delete<object>().AsType(itemType).WhereDynamic(items).ToSql();
-            if (string.IsNullOrWhiteSpace(delSql)) throw new Exception($"ToSqlCascade 失败");
-            if (sb.Length > 0) sb.Append("\r\n\r\n;\r\n\r\n");
-            sb.Append(delSql);
-        }
-    }
-}

FreeSql.Tests/FreeSql.Tests/Sqlite/Curd/SqliteSelectTest.cs

@@ -373,8 +373,6 @@ WHERE (((a.""Name"") in (SELECT s.""Title"" as1
             var ddd = g.sqlite.Select<District>().LeftJoin(d => d.ParentCode == d.Parent.Code).ToTreeList();
             Assert.Single(ddd);
             Assert.Equal(2, ddd[0].Childs.Count);
-
-            var sql = g.sqlite.Delete<District>().Where(a => a.Code == "001").ToSqlCascade();
         }
         public class District
         {
@@ -2238,8 +2236,6 @@ WHERE (((cast(a.""Id"" as character)) in (SELECT b.""Title""
                 })
             });
 
-            var sql = g.sqlite.Delete<VM_District_Child>().Where(a => a.Code == "100000").ToSqlCascade();
-
             var t1 = fsql.Select<VM_District_Parent>()
                 .InnerJoin(a => a.ParentCode == a.Parent.Code)
                 .Where(a => a.Code == "110101")