update

贪婪加载.md

@@ -1,69 +1,70 @@
-贪婪加载顾名思议就是把所有要加载的东西一次性读取，FreeSql 不支持像 EntityFramework Include/ThenInclude 功能强大的实现。
+贪婪加载顾名思议就是把所有要加载的东西一次性读取，FreeSql 支持像 EntityFramework Include/ThenInclude 功能强大的实现，并且比它应该更加强大。
 
 本节内容为了配合【延时加载】而诞生，贪婪加载和他本该在一起介绍，开发项目的过程中应该双管齐下，才能写出高质量的程序。
 
-虽然不支持像 Include 这样的抽象方法实现，但是 FreeSql 的贪婪加载也是做了一些可控性高的操作。
-
-## 分析
+## Dto 映射查询
 
 ```csharp
-public partial class Tag {
-    [Column(IsIdentity = true)]
-    public int Id { get; set; }
-    public int? Parent_id { get; set; }
-    public virtual Tag Parent { get; set; }
-
-    public decimal? Ddd { get; set; }
-    public string Name { get; set; }
-
-    public virtual ICollection<Song> Songs { get; set; }
-}
+Select<Tag>().Limit(10).ToList(a => new TestDto { id = a.Id, name = a.Title });
+Select<Tag>().Limit(10).ToList(a => new TestDto());
+Select<Tag>().Limit(10).ToList(a => new TestDto { });
+Select<Tag>().Limit(10).ToList(a => new TestDto() { });
+Select<Tag>().Limit(10).ToList<TestDto>();
 ```
+这种映射支持单表/多表。
 
-我能确定的一点是：多表查询才有贪婪加载的需求，解析多表查询大致分为两种：
+查找规则，查找属性名，会循环内部对象 _tables（join 查询后会增长），以 主表优先查，直到查到相同的字段。
 
-1、多表查询：select x from a,b where a.id = b.id
+如：
 
-这种查询方法现在已经比较少人使用了，FreeSql没有放弃；场景：多表查询的时候，直接使用导航属性的成员条件时，采用了这种查询；
+A, B, C 都有 id，Dto { id, a1, a2, b1, b2 }，如果 id = A.id，那可以直接映射 成功。
+
+> 友情提醒：在 dto 可以直接映射一个导航属性
+
+## 导航属性 ManyToOne/OneToOne
+
+ManyToOne/OneToOne 导航属性通过 ToList() 加载，这个方法有一个参数：includeNestedMembers。
+
+参数说明：
+
+false: 返回 2级 LeftJoin/InnerJoin/RightJoin 对象；
+
+true: 返回所有层级深度 LeftJoin/InnerJoin/RightJoin 的导航数据；
+
+如果查询中已经使用了 a.Parent.Parent 类似表达式，则可以无需 LeftJoin/InnerJoin/RightJoin 等操作。
+
+如：
 
 ```csharp
-var sql = Select<Tag>().Where(a => a.Parent.Name == "xxx").ToSql();
-```
-```sql
-SELECT a.`Id`, a.`Parent_id`, a.`Ddd`, a.`Name` 
-FROM `Tag` a, `Tag` a__Parent 
-WHERE (a__Parent.`Name` = 'xxx')
+Select<Tag>().Where(a => a.Parent.Name == "1").ToList();
+//这样写，就不需要标记 Join 了，解析表达式时自动添加了 LeftJoin
 ```
 
-2、联表查询：select x from a inner join b on b.id = a.id
+如果导航属性没有使用，又想加载，可使用 Include 方法。
 
 ```csharp
-var sql = Select<Tag>().Where(a => a.Parent.Name == "xxx").LeftJoin(a => a.Parent_id == a.Parent.Id).ToSql();
-```
-```sql
-SELECT a.`Id`, a.`Parent_id`, a__Parent.`Id` as3, a__Parent.`Parent_id` as4, a__Parent.`Ddd`, a__Parent.`Name`, a.`Ddd` as7, a.`Name` as8 
-FROM `Tag` a 
-LEFT JOIN `Tag` a__Parent ON a.`Parent_id` = a__Parent.`Id` 
-WHERE (a__Parent.`Name` = 'xxx')
+Select<Tag>().Include(a => a.Parent).ToList();
 ```
 
-可以看到【方法2】属于贪婪加载，也就是使用了Join查询，FreeSql会把他们的数据都查询出来。
+## 导航属性 OneToMany/ManyToMany
 
-目前有两个困难未能解决：
+IncludeMany 贪婪加载集合的导航属性，其实是分两次查询，在 ToList 后进行了数据重装。可以把它想成和 EFCore 一样的功能，但应该比它的更加强大。
 
-一、1对多的贪婪加载（包含多对多）；
+```csharp
+Select<Tag>().IncludeMany(a => a.Songs).ToList();
+//这是 ManyToMany 关系的贪婪加载
+```
 
-二、只有主表下的导航属性支持贪婪加载；
+> OneToMany 的使用方法相同
 
-## 好了，来总结一下
+IncludeMany 有第二个参数，可以进行二次查询前的修饰工作。
 
-爱上 Include/ThenInclude 的死去活来，不喜欢他的狠到咬牙切齿。
+```csharp
+Select<Tag>().IncludeMany(a => a.Songs, 
+    then => then.Where(song => song.User == "admin")).ToList();
+```
 
-个人的感觉是抽象过了头，在多个实体间 Include/ThenInclude 后，执行的是什么SQL语句根本不知道，也许是一条SQL执行，也许是执行多条SQL返回数据后重新组装数据。
-
-FreeSql 只实现了非常简单可靠的贪婪加载数据的方式，更精准的优化查询仍然需要配合Join + 指定字段返回的方式，虽然会麻烦一些，但这样做起码更加可控。
-
-如果要在循环中使用数据，请使用贪婪加载，否则使用懒加载。
+然后，其实在 then 那里，还可以继续进行向下 Include/IncludeMany。只要你喜欢，向下 100 层都没问题。
 
 ## 参考资料