doc: 更新 一对一、一对多 文档说明。

docs/.vitepress/config.ts

@@ -63,7 +63,6 @@ export default defineConfig({
                     {text: '查询（多表和分页）', link: '/zh/base/query'},
                     {text: '批量操作', link: '/zh/base/batch'},
                     {text: '一对多、多对一', link: '/zh/base/field-query'},
-                    {text: '结果映射', link: '/zh/base/result-map'},
                     {text: 'QueryWrapper', link: '/zh/base/querywrapper'},
                     {text: 'Db + Row', link: '/zh/base/db-row'},
                     {text: 'IService', link: '/zh/base/service'},

docs/zh/base/field-query.md

@@ -2,7 +2,7 @@
 
 在很多场景下，我们可能会用到 `一对多`、`一对一`、`多对一`、`多对多`等场景的关联查询，MyBatis-Flex 内置了相关的方法，用于支持此类场景。
 
-## 代码示例（多对多）
+## 代码示例（Field Query）
 
 以下是文章的示例，一篇文章可能归属于多个分类，一个类可以有多篇文章，需要用到中间表 `article_category_mapping`。
 
@@ -104,4 +104,87 @@ List<Article> articles = mapper.selectListByQuery(query
 ## 更多场景
 
 通过以上内容看出，`Article` 的任何属性，都是可以通过传入 `FieldQueryBuilder` 来构建 `QueryWrapper` 进行再次查询，
-这些不仅仅只适用于  `一对多`、`一对一`、`多对一`、`多对多`等场景。任何 `Article` 对象里的属性，需要二次查询赋值的，都是可以通过这种方式进行。
+这些不仅仅只适用于  `一对多`、`一对一`、`多对一`、`多对多`等场景。任何 `Article` 对象里的属性，需要二次查询赋值的，都是可以通过这种方式进行。
+
+## 结果映射
+
+您也可以继续使用连表查询，如果是原生 MyBatis 的话，可以使用 `<resultMap>` 标签来构建结果映射，在 MyBatis-Flex 中提供了自动结果映射功能，这样您就可以只关注于 SQL 语句的构建。
+
+## 代码示例（Join Query）
+
+这里以用户和角色的 `多对多` 关系作为例子，首先有用户表和角色表，分别对应着用户类和角色类：
+
+```java
+@Table("sys_user")
+public class User {
+
+    @Id
+    private Integer userId;
+    private String userName;
+    
+}
+
+@Table("sys_role")
+public class Role {
+
+    @Id
+    private Integer roleId;
+    private String roleKey;
+    private String roleName;
+
+}
+```
+
+现在需要查询所有用户，以及每个用户对应的角色信息，并通过 UserVO 对象返回：
+
+```java
+public class UserVO {
+
+    private String userId;
+    private String userName;
+    private List<Role> roleList;
+
+}
+```
+
+这个操作只需要连表查询即可完成，对于连表查询的结果映射，MyBatis-Flex 会自动帮您完成：
+
+```java
+@SpringBootTest
+class UserMapperTest {
+
+    @Autowired
+    private UserMapper userMapper;
+
+    @Test
+    void testSelectList() {
+        QueryWrapper queryWrapper = QueryWrapper.create()
+                .select(USER.USER_ID, USER.USER_NAME, ROLE.ALL_COLUMNS)
+                .from(USER.as("u"))
+                .leftJoin(USER_ROLE).as("ur").on(USER_ROLE.USER_ID.eq(USER.USER_ID))
+                .leftJoin(ROLE).as("r").on(USER_ROLE.ROLE_ID.eq(ROLE.ROLE_ID));
+        List<UserVO> userVOS = userMapper.selectListByQueryAs(queryWrapper, UserVO.class);
+        userVOS.forEach(System.err::println);
+    }
+
+}
+```
+
+构建的连表查询 SQL 语句为：
+
+```sql
+SELECT `u`.`user_id`,
+       `u`.`user_name`,
+       `r`.*
+FROM `sys_user` AS `u`
+LEFT JOIN `sys_user_role` AS `ur` ON `ur`.`user_id` = `u`.`user_id`
+LEFT JOIN `sys_role` AS `r` ON `ur`.`role_id` = `r`.`role_id`;
+```
+
+最终自动映射的结果为：
+
+```text
+UserVO{userId='1', userName='admin', roleList=[Role{roleId=1, roleKey='admin', roleName='超级管理员'}]}
+UserVO{userId='2', userName='ry', roleList=[Role{roleId=2, roleKey='common', roleName='普通角色'}]}
+UserVO{userId='3', userName='test', roleList=[Role{roleId=1, roleKey='admin', roleName='超级管理员'}, Role{roleId=2, roleKey='common', roleName='普通角色'}]}
+```

docs/zh/base/result-map.md

@@ -1,82 +0,0 @@
-# 结果映射
-
-很多情况下，我们都会遇到 `一对一`、`一对多`、`多对一`、`多对多` 的场景，通常会用到连表查询，如果是原生 MyBatis 的话，可以使用 `<resultMap>` 标签来构建结果映射，在 MyBatis-Flex 中提供了自动结果映射功能，这样您就可以只关注于 SQL 语句的构建。
-
-## 代码示例
-
-这里以用户和角色的 `多对多` 关系作为例子，首先有用户表和角色表，分别对应着用户类和角色类：
-
-```java
-@Table("sys_user")
-public class User {
-
-    @Id
-    private Integer userId;
-    private String userName;
-    
-}
-
-@Table("sys_role")
-public class Role {
-
-    @Id
-    private Integer roleId;
-    private String roleKey;
-    private String roleName;
-
-}
-```
-
-现在需要查询所有用户，以及每个用户对应的角色信息，并通过 UserVO 对象返回：
-
-```java
-public class UserVO {
-
-    private String userId;
-    private String userName;
-    private List<Role> roleList;
-
-}
-```
-
-这个操作只需要连表查询即可完成，对于连表查询的结果映射，MyBatis-Flex 会自动帮您完成：
-
-```java
-@SpringBootTest
-class UserMapperTest {
-
-    @Autowired
-    private UserMapper userMapper;
-
-    @Test
-    void testSelectList() {
-        QueryWrapper queryWrapper = QueryWrapper.create()
-                .select(USER.USER_ID, USER.USER_NAME, ROLE.ALL_COLUMNS)
-                .from(USER.as("u"))
-                .leftJoin(USER_ROLE).as("ur").on(USER_ROLE.USER_ID.eq(USER.USER_ID))
-                .leftJoin(ROLE).as("r").on(USER_ROLE.ROLE_ID.eq(ROLE.ROLE_ID));
-        List<UserVO> userVOS = userMapper.selectListByQueryAs(queryWrapper, UserVO.class);
-        userVOS.forEach(System.err::println);
-    }
-
-}
-```
-
-构建的连表查询 SQL 语句为：
-
-```sql
-SELECT `u`.`user_id`,
-       `u`.`user_name`,
-       `r`.*
-FROM `sys_user` AS `u`
-LEFT JOIN `sys_user_role` AS `ur` ON `ur`.`user_id` = `u`.`user_id`
-LEFT JOIN `sys_role` AS `r` ON `ur`.`role_id` = `r`.`role_id`;
-```
-
-最终自动映射的结果为：
-
-```text
-UserVO{userId='1', userName='admin', roleList=[Role{roleId=1, roleKey='admin', roleName='超级管理员'}]}
-UserVO{userId='2', userName='ry', roleList=[Role{roleId=2, roleKey='common', roleName='普通角色'}]}
-UserVO{userId='3', userName='test', roleList=[Role{roleId=1, roleKey='admin', roleName='超级管理员'}, Role{roleId=2, roleKey='common', roleName='普通角色'}]}
-```