diff --git a/SeaORM/docs/01-introduction/02-async.md b/SeaORM/docs/01-introduction/02-async.md
index 4f8822d77b0..696666e2d7a 100644
--- a/SeaORM/docs/01-introduction/02-async.md
+++ b/SeaORM/docs/01-introduction/02-async.md
@@ -4,7 +4,7 @@ Async programming in Rust is a recent development, only having been stabilized i
 
 The first thing to learn is the [`Future`](https://rust-lang.github.io/async-book/02_execution/02_future.html) trait. It's a placeholder for a function that will compute and return some value in the future. It's lazy, meaning `.await` must be called for any actual work to be done. `Future` allows us to achieve concurrency with little programming effort, e.g. [`future::join_all`](https://docs.rs/futures/latest/futures/future/fn.join_all.html) to execute multiple queries in parallel.
 
-Second, `async` in Rust is [multi-threaded programming](https://rust-lang.github.io/async-book/03_async_await/01_chapter.html) with syntactic sugar. A `Future` may move between threads, so any variables used in async bodies must be able to travel between threads, i.e. [`Send`](https://doc.rust-lang.org/nomicon/send-and-sync.html).
+Second, in multi-threaded async executor, a `Future` may move between threads, so any variables used in async bodies must be able to travel between threads, i.e. [`Send`](https://doc.rust-lang.org/nomicon/send-and-sync.html).
 
 Third, there are multiple async runtimes in Rust. [`async-std`](https://crates.io/crates/async-std) and [`tokio`](https://crates.io/crates/tokio) are the two most widely used. SeaORM's underlying driver, [`SQLx`](https://crates.io/crates/sqlx), supports both.
 
diff --git a/SeaORM/docusaurus.config.js b/SeaORM/docusaurus.config.js
index e1fcade6241..a1e1108d9f4 100644
--- a/SeaORM/docusaurus.config.js
+++ b/SeaORM/docusaurus.config.js
@@ -28,6 +28,10 @@ module.exports = {
   organizationName: 'SeaQL',
   projectName: 'sea-orm',
   trailingSlash: true,
+    i18n: {
+    defaultLocale: 'en',
+    locales: ['en', 'zh-Hans'],
+  },
   themeConfig: {
     colorMode: {
       respectPrefersColorScheme: true,
@@ -80,6 +84,10 @@ module.exports = {
           position: 'right',
           dropdownActiveClassDisabled: true,
         },
+        {
+          type: 'localeDropdown',
+          position: 'right',
+        },
       ],
     },
     footer: {
diff --git a/SeaORM/i18n/zh-Hans/code.json b/SeaORM/i18n/zh-Hans/code.json
new file mode 100644
index 00000000000..85bb87b3029
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/code.json
@@ -0,0 +1,456 @@
+{
+  "theme.ErrorPageContent.title": {
+    "message": "页面已崩溃。",
+    "description": "The title of the fallback page when the page crashed"
+  },
+  "theme.BackToTopButton.buttonAriaLabel": {
+    "message": "回到顶部",
+    "description": "The ARIA label for the back to top button"
+  },
+  "theme.blog.archive.title": {
+    "message": "历史博文",
+    "description": "The page & hero title of the blog archive page"
+  },
+  "theme.blog.archive.description": {
+    "message": "历史博文",
+    "description": "The page & hero description of the blog archive page"
+  },
+  "theme.blog.paginator.navAriaLabel": {
+    "message": "博文列表分页导航",
+    "description": "The ARIA label for the blog pagination"
+  },
+  "theme.blog.paginator.newerEntries": {
+    "message": "较新的博文",
+    "description": "The label used to navigate to the newer blog posts page (previous page)"
+  },
+  "theme.blog.paginator.olderEntries": {
+    "message": "较旧的博文",
+    "description": "The label used to navigate to the older blog posts page (next page)"
+  },
+  "theme.blog.post.paginator.navAriaLabel": {
+    "message": "博文分页导航",
+    "description": "The ARIA label for the blog posts pagination"
+  },
+  "theme.blog.post.paginator.newerPost": {
+    "message": "较新一篇",
+    "description": "The blog post button label to navigate to the newer/previous post"
+  },
+  "theme.blog.post.paginator.olderPost": {
+    "message": "较旧一篇",
+    "description": "The blog post button label to navigate to the older/next post"
+  },
+  "theme.tags.tagsPageLink": {
+    "message": "查看所有标签",
+    "description": "The label of the link targeting the tag list page"
+  },
+  "theme.colorToggle.ariaLabel.mode.system": {
+    "message": "system mode",
+    "description": "The name for the system color mode"
+  },
+  "theme.colorToggle.ariaLabel.mode.light": {
+    "message": "浅色模式",
+    "description": "The name for the light color mode"
+  },
+  "theme.colorToggle.ariaLabel.mode.dark": {
+    "message": "暗黑模式",
+    "description": "The name for the dark color mode"
+  },
+  "theme.colorToggle.ariaLabel": {
+    "message": "切换浅色/暗黑模式（当前为{mode}）",
+    "description": "The ARIA label for the color mode toggle"
+  },
+  "theme.docs.breadcrumbs.navAriaLabel": {
+    "message": "页面路径",
+    "description": "The ARIA label for the breadcrumbs"
+  },
+  "theme.docs.DocCard.categoryDescription.plurals": {
+    "message": "{count} 个项目",
+    "description": "The default description for a category card in the generated index about how many items this category includes"
+  },
+  "theme.docs.paginator.navAriaLabel": {
+    "message": "文件选项卡",
+    "description": "The ARIA label for the docs pagination"
+  },
+  "theme.docs.paginator.previous": {
+    "message": "上一页",
+    "description": "The label used to navigate to the previous doc"
+  },
+  "theme.docs.paginator.next": {
+    "message": "下一页",
+    "description": "The label used to navigate to the next doc"
+  },
+  "theme.docs.tagDocListPageTitle.nDocsTagged": {
+    "message": "{count} 篇文档带有标签",
+    "description": "Pluralized label for \"{count} docs tagged\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
+  },
+  "theme.docs.tagDocListPageTitle": {
+    "message": "{nDocsTagged}「{tagName}」",
+    "description": "The title of the page for a docs tag"
+  },
+  "theme.docs.versions.unreleasedVersionLabel": {
+    "message": "此为 {siteTitle} {versionLabel} 版尚未发行的文档。",
+    "description": "The label used to tell the user that he's browsing an unreleased doc version"
+  },
+  "theme.docs.versions.unmaintainedVersionLabel": {
+    "message": "此为 {siteTitle} {versionLabel} 版的文档，现已不再积极维护。",
+    "description": "The label used to tell the user that he's browsing an unmaintained doc version"
+  },
+  "theme.docs.versions.latestVersionSuggestionLabel": {
+    "message": "最新的文档请参阅 {latestVersionLink} ({versionLabel})。",
+    "description": "The label used to tell the user to check the latest version"
+  },
+  "theme.docs.versions.latestVersionLinkLabel": {
+    "message": "最新版本",
+    "description": "The label used for the latest version suggestion link label"
+  },
+  "theme.docs.versionBadge.label": {
+    "message": "版本：{versionLabel}"
+  },
+  "theme.common.editThisPage": {
+    "message": "编辑此页",
+    "description": "The link label to edit the current page"
+  },
+  "theme.common.headingLinkTitle": {
+    "message": "{heading}的直接链接",
+    "description": "Title for link to heading"
+  },
+  "theme.lastUpdated.atDate": {
+    "message": "于 {date} ",
+    "description": "The words used to describe on which date a page has been last updated"
+  },
+  "theme.lastUpdated.byUser": {
+    "message": "由 {user} ",
+    "description": "The words used to describe by who the page has been last updated"
+  },
+  "theme.lastUpdated.lastUpdatedAtBy": {
+    "message": "最后{byUser}{atDate}更新",
+    "description": "The sentence used to display when a page has been last updated, and by who"
+  },
+  "theme.navbar.mobileVersionsDropdown.label": {
+    "message": "选择版本",
+    "description": "The label for the navbar versions dropdown on mobile view"
+  },
+  "theme.NotFound.title": {
+    "message": "找不到页面",
+    "description": "The title of the 404 page"
+  },
+  "theme.tags.tagsListLabel": {
+    "message": "标签：",
+    "description": "The label alongside a tag list"
+  },
+  "theme.admonition.caution": {
+    "message": "警告",
+    "description": "The default label used for the Caution admonition (:::caution)"
+  },
+  "theme.admonition.danger": {
+    "message": "危险",
+    "description": "The default label used for the Danger admonition (:::danger)"
+  },
+  "theme.admonition.info": {
+    "message": "信息",
+    "description": "The default label used for the Info admonition (:::info)"
+  },
+  "theme.admonition.note": {
+    "message": "备注",
+    "description": "The default label used for the Note admonition (:::note)"
+  },
+  "theme.admonition.tip": {
+    "message": "提示",
+    "description": "The default label used for the Tip admonition (:::tip)"
+  },
+  "theme.admonition.warning": {
+    "message": "注意",
+    "description": "The default label used for the Warning admonition (:::warning)"
+  },
+  "theme.AnnouncementBar.closeButtonAriaLabel": {
+    "message": "关闭",
+    "description": "The ARIA label for close button of announcement bar"
+  },
+  "theme.blog.sidebar.navAriaLabel": {
+    "message": "最近博文导航",
+    "description": "The ARIA label for recent posts in the blog sidebar"
+  },
+  "theme.DocSidebarItem.expandCategoryAriaLabel": {
+    "message": "展开侧边栏分类 '{label}'",
+    "description": "The ARIA label to expand the sidebar category"
+  },
+  "theme.DocSidebarItem.collapseCategoryAriaLabel": {
+    "message": "折叠侧边栏分类 '{label}'",
+    "description": "The ARIA label to collapse the sidebar category"
+  },
+  "theme.NavBar.navAriaLabel": {
+    "message": "主导航",
+    "description": "The ARIA label for the main navigation"
+  },
+  "theme.navbar.mobileLanguageDropdown.label": {
+    "message": "选择语言",
+    "description": "The label for the mobile language switcher dropdown"
+  },
+  "theme.NotFound.p1": {
+    "message": "我们找不到您要找的页面。",
+    "description": "The first paragraph of the 404 page"
+  },
+  "theme.NotFound.p2": {
+    "message": "请联系原始链接来源网站的所有者，并告知他们链接已损坏。",
+    "description": "The 2nd paragraph of the 404 page"
+  },
+  "theme.TOCCollapsible.toggleButtonLabel": {
+    "message": "本页总览",
+    "description": "The label used by the button on the collapsible TOC component"
+  },
+  "theme.blog.post.readMore": {
+    "message": "阅读更多",
+    "description": "The label used in blog post item excerpts to link to full blog posts"
+  },
+  "theme.blog.post.readMoreLabel": {
+    "message": "阅读 {title} 的全文",
+    "description": "The ARIA label for the link to full blog posts from excerpts"
+  },
+  "theme.blog.post.readingTime.plurals": {
+    "message": "阅读需 {readingTime} 分钟",
+    "description": "Pluralized label for \"{readingTime} min read\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
+  },
+  "theme.CodeBlock.copy": {
+    "message": "复制",
+    "description": "The copy button label on code blocks"
+  },
+  "theme.CodeBlock.copied": {
+    "message": "复制成功",
+    "description": "The copied button label on code blocks"
+  },
+  "theme.CodeBlock.copyButtonAriaLabel": {
+    "message": "复制代码到剪贴板",
+    "description": "The ARIA label for copy code blocks button"
+  },
+  "theme.CodeBlock.wordWrapToggle": {
+    "message": "切换自动换行",
+    "description": "The title attribute for toggle word wrapping button of code block lines"
+  },
+  "theme.docs.breadcrumbs.home": {
+    "message": "主页面",
+    "description": "The ARIA label for the home page in the breadcrumbs"
+  },
+  "theme.docs.sidebar.collapseButtonTitle": {
+    "message": "收起侧边栏",
+    "description": "The title attribute for collapse button of doc sidebar"
+  },
+  "theme.docs.sidebar.collapseButtonAriaLabel": {
+    "message": "收起侧边栏",
+    "description": "The title attribute for collapse button of doc sidebar"
+  },
+  "theme.docs.sidebar.navAriaLabel": {
+    "message": "文档侧边栏",
+    "description": "The ARIA label for the sidebar navigation"
+  },
+  "theme.docs.sidebar.closeSidebarButtonAriaLabel": {
+    "message": "关闭导航栏",
+    "description": "The ARIA label for close button of mobile sidebar"
+  },
+  "theme.navbar.mobileSidebarSecondaryMenu.backButtonLabel": {
+    "message": "← 回到主菜单",
+    "description": "The label of the back button to return to main menu, inside the mobile navbar sidebar secondary menu (notably used to display the docs sidebar)"
+  },
+  "theme.docs.sidebar.toggleSidebarButtonAriaLabel": {
+    "message": "切换导航栏",
+    "description": "The ARIA label for hamburger menu button of mobile navigation"
+  },
+  "theme.navbar.mobileDropdown.collapseButton.expandAriaLabel": {
+    "message": "Expand the dropdown",
+    "description": "The ARIA label of the button to expand the mobile dropdown navbar item"
+  },
+  "theme.navbar.mobileDropdown.collapseButton.collapseAriaLabel": {
+    "message": "Collapse the dropdown",
+    "description": "The ARIA label of the button to collapse the mobile dropdown navbar item"
+  },
+  "theme.docs.sidebar.expandButtonTitle": {
+    "message": "展开侧边栏",
+    "description": "The ARIA label and title attribute for expand button of doc sidebar"
+  },
+  "theme.docs.sidebar.expandButtonAriaLabel": {
+    "message": "展开侧边栏",
+    "description": "The ARIA label and title attribute for expand button of doc sidebar"
+  },
+  "theme.SearchBar.seeAll": {
+    "message": "查看全部 {count} 个结果"
+  },
+  "theme.SearchPage.documentsFound.plurals": {
+    "message": "找到 {count} 份文件",
+    "description": "Pluralized label for \"{count} documents found\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
+  },
+  "theme.SearchPage.existingResultsTitle": {
+    "message": "「{query}」的搜索结果",
+    "description": "The search page title for non-empty query"
+  },
+  "theme.SearchPage.emptyResultsTitle": {
+    "message": "在文档中搜索",
+    "description": "The search page title for empty query"
+  },
+  "theme.SearchPage.inputPlaceholder": {
+    "message": "在此输入搜索字词",
+    "description": "The placeholder for search page input"
+  },
+  "theme.SearchPage.inputLabel": {
+    "message": "搜索",
+    "description": "The ARIA label for search page input"
+  },
+  "theme.SearchPage.algoliaLabel": {
+    "message": "通过 Algolia 搜索",
+    "description": "The ARIA label for Algolia mention"
+  },
+  "theme.SearchPage.noResultsText": {
+    "message": "未找到任何结果",
+    "description": "The paragraph for empty search result"
+  },
+  "theme.SearchPage.fetchingNewResults": {
+    "message": "正在获取新的搜索结果...",
+    "description": "The paragraph for fetching new search results"
+  },
+  "theme.SearchBar.label": {
+    "message": "搜索",
+    "description": "The ARIA label and placeholder for search button"
+  },
+  "theme.SearchModal.searchBox.resetButtonTitle": {
+    "message": "清除查询",
+    "description": "The label and ARIA label for search box reset button"
+  },
+  "theme.SearchModal.searchBox.cancelButtonText": {
+    "message": "取消",
+    "description": "The label and ARIA label for search box cancel button"
+  },
+  "theme.SearchModal.startScreen.recentSearchesTitle": {
+    "message": "最近搜索",
+    "description": "The title for recent searches"
+  },
+  "theme.SearchModal.startScreen.noRecentSearchesText": {
+    "message": "没有最近搜索",
+    "description": "The text when no recent searches"
+  },
+  "theme.SearchModal.startScreen.saveRecentSearchButtonTitle": {
+    "message": "保存这个搜索",
+    "description": "The label for save recent search button"
+  },
+  "theme.SearchModal.startScreen.removeRecentSearchButtonTitle": {
+    "message": "从历史记录中删除这个搜索",
+    "description": "The label for remove recent search button"
+  },
+  "theme.SearchModal.startScreen.favoriteSearchesTitle": {
+    "message": "收藏",
+    "description": "The title for favorite searches"
+  },
+  "theme.SearchModal.startScreen.removeFavoriteSearchButtonTitle": {
+    "message": "从收藏列表中删除这个搜索",
+    "description": "The label for remove favorite search button"
+  },
+  "theme.SearchModal.errorScreen.titleText": {
+    "message": "无法获取结果",
+    "description": "The title for error screen of search modal"
+  },
+  "theme.SearchModal.errorScreen.helpText": {
+    "message": "你可能需要检查网络连接。",
+    "description": "The help text for error screen of search modal"
+  },
+  "theme.SearchModal.footer.selectText": {
+    "message": "选中",
+    "description": "The explanatory text of the action for the enter key"
+  },
+  "theme.SearchModal.footer.selectKeyAriaLabel": {
+    "message": "Enter 键",
+    "description": "The ARIA label for the Enter key button that makes the selection"
+  },
+  "theme.SearchModal.footer.navigateText": {
+    "message": "导航",
+    "description": "The explanatory text of the action for the Arrow up and Arrow down key"
+  },
+  "theme.SearchModal.footer.navigateUpKeyAriaLabel": {
+    "message": "向上键",
+    "description": "The ARIA label for the Arrow up key button that makes the navigation"
+  },
+  "theme.SearchModal.footer.navigateDownKeyAriaLabel": {
+    "message": "向下键",
+    "description": "The ARIA label for the Arrow down key button that makes the navigation"
+  },
+  "theme.SearchModal.footer.closeText": {
+    "message": "关闭",
+    "description": "The explanatory text of the action for Escape key"
+  },
+  "theme.SearchModal.footer.closeKeyAriaLabel": {
+    "message": "Esc 键",
+    "description": "The ARIA label for the Escape key button that close the modal"
+  },
+  "theme.SearchModal.footer.searchByText": {
+    "message": "搜索提供",
+    "description": "The text explain that the search is making by Algolia"
+  },
+  "theme.SearchModal.noResultsScreen.noResultsText": {
+    "message": "没有结果：",
+    "description": "The text explains that there are no results for the following search"
+  },
+  "theme.SearchModal.noResultsScreen.suggestedQueryText": {
+    "message": "试试搜索",
+    "description": "The text for the suggested query when no results are found for the following search"
+  },
+  "theme.SearchModal.noResultsScreen.reportMissingResultsText": {
+    "message": "认为这个查询应该有结果？",
+    "description": "The text for the question where the user thinks there are missing results"
+  },
+  "theme.SearchModal.noResultsScreen.reportMissingResultsLinkText": {
+    "message": "请告知我们。",
+    "description": "The text for the link to report missing results"
+  },
+  "theme.SearchModal.placeholder": {
+    "message": "搜索文档",
+    "description": "The placeholder of the input of the DocSearch pop-up modal"
+  },
+  "theme.blog.post.plurals": {
+    "message": "{count} 篇博文",
+    "description": "Pluralized label for \"{count} posts\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
+  },
+  "theme.blog.tagTitle": {
+    "message": "{nPosts} 含有标签「{tagName}」",
+    "description": "The title of the page for a blog tag"
+  },
+  "theme.blog.author.pageTitle": {
+    "message": "{authorName} - {nPosts}",
+    "description": "The title of the page for a blog author"
+  },
+  "theme.blog.authorsList.pageTitle": {
+    "message": "作者",
+    "description": "The title of the authors page"
+  },
+  "theme.blog.authorsList.viewAll": {
+    "message": "查看所有作者",
+    "description": "The label of the link targeting the blog authors page"
+  },
+  "theme.blog.author.noPosts": {
+    "message": "该作者尚未撰写任何文章。",
+    "description": "The text for authors with 0 blog post"
+  },
+  "theme.contentVisibility.unlistedBanner.title": {
+    "message": "未列出页",
+    "description": "The unlisted content banner title"
+  },
+  "theme.contentVisibility.unlistedBanner.message": {
+    "message": "此页面未列出。搜索引擎不会对其索引，只有拥有直接链接的用户才能访问。",
+    "description": "The unlisted content banner message"
+  },
+  "theme.contentVisibility.draftBanner.title": {
+    "message": "草稿页",
+    "description": "The draft content banner title"
+  },
+  "theme.contentVisibility.draftBanner.message": {
+    "message": "此页面是草稿，仅在开发环境中可见，不会包含在正式版本中。",
+    "description": "The draft content banner message"
+  },
+  "theme.ErrorPageContent.tryAgain": {
+    "message": "重试",
+    "description": "The label of the button to try again rendering when the React error boundary captures an error"
+  },
+  "theme.common.skipToMainContent": {
+    "message": "跳到主要内容",
+    "description": "The skip to content label used for accessibility, allowing to rapidly navigate to main content with keyboard tab/enter navigation"
+  },
+  "theme.tags.tagsPageTitle": {
+    "message": "标签",
+    "description": "The title of the tag list page"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current.json
new file mode 100644
index 00000000000..3b38d89397c
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current.json
@@ -0,0 +1,58 @@
+{
+  "version.label": {
+    "message": "2.0.x 🚧",
+    "description": "The label for version current"
+  },
+  "sidebar.tutorialSidebar.category.Introduction": {
+    "message": "Introduction",
+    "description": "The label for category Introduction in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Installation & Configuration": {
+    "message": "Installation & Configuration",
+    "description": "The label for category Installation & Configuration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Migration": {
+    "message": "Migration",
+    "description": "The label for category Migration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Entities": {
+    "message": "Generating Entities",
+    "description": "The label for category Generating Entities in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Basic CRUD": {
+    "message": "Basic CRUD",
+    "description": "The label for category Basic CRUD in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Relations": {
+    "message": "Relations",
+    "description": "The label for category Relations in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Writing Tests": {
+    "message": "Writing Tests",
+    "description": "The label for category Writing Tests in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Advanced Queries": {
+    "message": "Advanced Queries",
+    "description": "The label for category Advanced Queries in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Schema Statement": {
+    "message": "Schema Statement",
+    "description": "The label for category Schema Statement in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.GraphQL Support": {
+    "message": "GraphQL Support",
+    "description": "The label for category GraphQL Support in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Admin Panel": {
+    "message": "Admin Panel",
+    "description": "The label for category Admin Panel in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Internal Design": {
+    "message": "Internal Design",
+    "description": "The label for category Internal Design in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.What's Next": {
+    "message": "What's Next",
+    "description": "The label for category What's Next in sidebar tutorialSidebar"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-index.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-index.md
new file mode 100644
index 00000000000..9befa891f3d
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-index.md
@@ -0,0 +1,149 @@
+# 索引
+
+## 介绍
+
+1. 介绍
+
+    1.1. [什么是 ORM](01-introduction/01-orm.md)
+
+    1.2. [Rust 中的异步编程](01-introduction/02-async.md)
+
+    1.3. [SeaORM 概念](01-introduction/03-sea-orm.md)
+
+    1.4. [教程与示例](01-introduction/04-tutorial.md)
+
+## 基础
+
+2. 安装与配置
+
+    2.1 [选择数据库与异步运行时](02-install-and-config/01-database-and-async-runtime.md)
+
+    2.2 [连接池](02-install-and-config/02-connection.md)
+
+    2.3 [调试日志](02-install-and-config/03-debug-log.md)
+
+3. 迁移
+
+    3.1 [设置迁移](03-migration/01-setting-up-migration.md)
+
+    3.2 [编写迁移](03-migration/02-writing-migration.md)
+
+    3.3 [运行迁移](03-migration/03-running-migration.md)
+
+    3.4 [数据填充](03-migration/04-seeding-data.md)
+
+4. 生成实体
+
+    4.1 [使用 `sea-orm-cli`](04-generate-entity/01-sea-orm-cli.md)
+
+    4.2 [实体结构](04-generate-entity/02-entity-format.md)
+
+    4.3 [列类型](04-generate-entity/03-column-types.md)
+
+    4.4 [枚举](04-generate-entity/04-enumeration.md)
+
+    4.5 [新类型](04-generate-entity/05-newtype.md)
+
+5. 基本 CRUD
+
+    5.1 [基本 Schema](05-basic-crud/01-basic-schema.md)
+
+    5.2 [SELECT: 查找、过滤、排序、分页](05-basic-crud/02-select.md)
+
+    5.3 [ActiveModel 与 ActiveValue](05-basic-crud/03-active-model.md)
+
+    5.4 [INSERT: 插入单个与插入多个](05-basic-crud/04-insert.md)
+
+    5.5 [UPDATE: 查找与保存，更新多个](05-basic-crud/05-update.md)
+
+    5.6 [SAVE: 插入或更新](05-basic-crud/06-save.md)
+
+    5.7 [DELETE: 删除单个与删除多个](05-basic-crud/07-delete.md)
+
+    5.8 [JSON](05-basic-crud/08-json.md)
+
+    5.9 [原始 SQL 查询](05-basic-crud/09-raw-sql.md)
+
+## 高级主题
+
+6. 关系
+
+    6.1 [一对一](06-relation/01-one-to-one.md)
+
+    6.2 [一对多](06-relation/02-one-to-many.md)
+
+    6.3 [多对多](06-relation/03-many-to-many.md)
+
+    6.4 [复杂关系](06-relation/04-complex-relations.md)
+
+    6.5 [自定义连接条件](06-relation/06-custom-join-condition.md)
+
+    6.6 [数据加载器](06-relation/07-data-loader.md)
+
+    6.7 [Bakery Schema](06-relation/08-bakery-schema.md)
+
+    6.8 [嵌套选择](06-relation/09-nested-selects.md)
+
+7. 编写测试
+
+    7.1 [健壮与正确](07-write-test/01-testing.md)
+
+    7.2 [模拟接口](07-write-test/02-mock.md)
+
+    7.3 [使用 SQLite](07-write-test/03-sqlite.md)
+
+8. 高级查询
+
+    8.1 [自定义选择](08-advanced-query/01-custom-select.md)
+
+    8.2 [条件表达式](08-advanced-query/02-conditional-expression.md)
+
+    8.3 [聚合函数](08-advanced-query/03-aggregate-function.md)
+
+    8.4 [高级连接](08-advanced-query/04-advanced-joins.md)
+
+    8.5 [子查询](08-advanced-query/05-subquery.md)
+
+    8.6 [事务](08-advanced-query/06-transaction.md)
+
+    8.7 [流式处理](08-advanced-query/07-streaming.md)
+
+    8.8 [自定义 Active Model](08-advanced-query/08-custom-active-model.md)
+
+    8.9 [错误处理](08-advanced-query/09-error-handling.md)
+
+9. Schema 语句
+
+    9.1 [创建表](09-schema-statement/01-create-table.md)
+
+    9.2 [创建枚举](09-schema-statement/02-create-enum.md)
+
+    9.3 [创建索引](09-schema-statement/03-create-index.md)
+
+10. GraphQL 支持
+
+    10.1 [🧭 Seaography](10-graph-ql/01-seaography-intro.md)
+
+    10.2 [入门](10-graph-ql/02-getting-started.md)
+
+11. 管理面板
+
+    11.1 [🖥️ SeaORM Pro](11-sea-orm-pro/01-sea-orm-pro-intro.md)
+
+    11.2 [入门](11-sea-orm-pro/02-getting-started.md)
+
+12. 内部设计
+
+    12.1 [特性与类型](12-internal-design/01-trait-and-type.md)
+
+    12.2 [派生宏](12-internal-design/02-derive-macro.md)
+
+    12.3 [与 Diesel 比较](12-internal-design/03-diesel.md)
+
+    12.4 [架构](12-internal-design/04-architecture.md)
+
+    12.5 [扩展实体格式](12-internal-design/05-expanded-entity-format.md)
+
+13. 下一步
+
+    13.1 [下一步](13-whats-next/01-whats-next.md)
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/01-orm.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/01-orm.md
new file mode 100644
index 00000000000..ae362a90241
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/01-orm.md
@@ -0,0 +1,13 @@
+# 什么是 ORM
+
+对象关系映射器（ORM）是一类编程库，用于帮助你在面向对象编程（OOP）语言中与关系数据库交互。
+
+数据库中的表和列会被映射到对象与属性，同时提供额外的方法，让你可以从数据库加载数据或将数据存储到数据库中。。
+
+使用 Rust 构建的服务具有以下特点：轻量（二进制文件小，内存使用率低）、安全（具有编译时保证）、正确（前提是单元测试设计良好）且快速（编译时优化能够最大限度地减少运行时开销）。
+
+由于 Rust 是一种静态类型、强类型、编译型、线程安全、非垃圾回收，并且面向对象方式不常规的语言，因此在 Rust 中 ORM 的使用与你熟悉的其他脚本语言中有所不同。
+
+SeaORM 旨在帮助你获得上述优势，同时规避在 Rust 中编程可能遇到的问题。
+
+让我们开始吧。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/02-async.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/02-async.md
new file mode 100644
index 00000000000..5e544422017
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/02-async.md
@@ -0,0 +1,12 @@
+# 异步编程
+
+Rust 的异步编程是最近才稳定的特性，直到 Rust [`1.39`](https://github.com/rust-lang/rust/releases/tag/1.39.0) 才正式引入。异步生态发展迅速，而 SeaORM 是最早从零开始就考虑异步支持的 crate 之一。
+
+
+首先需要了解的是 [`Future`](https://rust-lang.github.io/async-book/02_execution/02_future.html) trait。它是一个占位符，表示一个将来会计算并返回某个值的函数。它惰性求值，这意味着必须调用 `.await` 才会执行实际工作。`Future` 让我们能够以很少的编程成本实现并发，例如使用 [`future::join_all`](https://docs.rs/futures/latest/futures/future/fn.join_all.html) 来并行执行多个查询。
+
+其次，在多线程异步执行器中。一个`Future` 可能会在线程之间移动，因此异步函数体中使用的变量都必须能够在线程之间传递，即实现 [`Send`](https://doc.rust-lang.org/nomicon/send-and-sync.html) trait。
+
+第三，Rust 中有多个异步运行时。[`async-std`](https://crates.io/crates/async-std) 和 [`tokio`](https://crates.io/crates/tokio) 是其中最常用的两个。SeaORM 使用的底层驱动 [`SQLx`](https://crates.io/crates/sqlx) 同时支持这两者。
+
+理解这些概念对于你快速上手 Rust 异步编程至关重要。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/03-sea-orm.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/03-sea-orm.md
new file mode 100644
index 00000000000..c55c0f95a8a
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/03-sea-orm.md
@@ -0,0 +1,15 @@
+# SeaORM 概念
+
+在 SeaORM 中，包含多个表的数据库称为 `Schema`。
+
+每个表对应 SeaORM 中的一个 [`Entity`](04-generate-entity/02-entity-format.md#entity)，它帮助你对相关表执行 `CRUD`（创建、读取、更新和删除）操作。
+
+`Entity` trait 提供了一个 API，供你在运行时检查其属性（包括 [`Column`](04-generate-entity/02-entity-format.md#column)、[`Relation`](04-generate-entity/02-entity-format.md#relation) 和 [`PrimaryKey`](04-generate-entity/02-entity-format.md#primary-key)）。
+
+每个表都有多个列，这些列被称为 `attribute`。
+
+这些属性及其对应的值会被组合到一个 Rust 结构体中（即 [`Model`](12-internal-design/05-expanded-entity-format.md#model)），方便你进行操作。
+
+不过，`Model` 仅用于读取。要执行插入、更新或者删除，你需要使用 [`ActiveModel`](12-internal-design/05-expanded-entity-format.md#active-model)，它为每个属性上附加元数据。
+
+最后，SeaORM 中没有单例（全局上下文）的概念。应用程序代码需要负责管理 `DatabaseConnection` 的所有权。我们提供了一些与 Web 框架（包括 [Rocket](https://github.com/SeaQL/sea-orm/tree/master/examples/rocket_example)、[Actix](https://github.com/SeaQL/sea-orm/tree/master/examples/actix_example)、[axum](https://github.com/SeaQL/sea-orm/tree/master/examples/axum_example) 和 [poem](https://github.com/SeaQL/sea-orm/tree/master/examples/poem_example)）的集成示例，帮助你快速上手。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/04-tutorial.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/04-tutorial.md
new file mode 100644
index 00000000000..a3bb5a3bbbc
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/04-tutorial.md
@@ -0,0 +1,19 @@
+# 教程与示例
+
+如果你希望通过循序渐进的教程来学习 SeaORM程，可以查看我们官方的 [SeaORM 教程](https://www.sea-ql.org/sea-orm-tutorial/)。还有一些由社区编写的[优秀教程](https://github.com/SeaQL/sea-orm/blob/master/COMMUNITY.md#learning-resources)！
+
+你还可以查看 [SeaORM Cookbook](https://www.sea-ql.org/sea-orm-cookbook/)，这里收录了一些常见问题和使用 SeaORM 的推荐实践。
+
+如果你急于上手，SeaQL 维护了一系列由社区贡献的官方示例（我们欢迎更多贡献！）：
+
++ [Actix 示例](https://github.com/SeaQL/sea-orm/tree/master/examples/actix_example)
++ [Axum 示例](https://github.com/SeaQL/sea-orm/tree/master/examples/axum_example)
++ [GraphQL 示例](https://github.com/SeaQL/sea-orm/tree/master/examples/graphql_example)
++ [jsonrpsee 示例](https://github.com/SeaQL/sea-orm/tree/master/examples/jsonrpsee_example)
++ [Loco 示例](https://github.com/SeaQL/sea-orm/tree/master/examples/loco_example)
++ [Loco REST Starter 示例](https://github.com/SeaQL/sea-orm/tree/master/examples/loco_starter)
++ [Poem 示例](https://github.com/SeaQL/sea-orm/tree/master/examples/poem_example)
++ [Rocket 示例](https://github.com/SeaQL/sea-orm/tree/master/examples/rocket_example)
++ [Salvo 示例](https://github.com/SeaQL/sea-orm/tree/master/examples/salvo_example)
++ [Tonic 示例](https://github.com/SeaQL/sea-orm/tree/master/examples/tonic_example)
++ [Seaography 示例](https://github.com/SeaQL/sea-orm/tree/master/examples/seaography_example)
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/_category_.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/_category_.json
new file mode 100644
index 00000000000..16a97d6e429
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/01-introduction/_category_.json
@@ -0,0 +1,4 @@
+{
+  "label": "Introduction",
+  "collapsed": false
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/02-install-and-config/01-database-and-async-runtime.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/02-install-and-config/01-database-and-async-runtime.md
new file mode 100644
index 00000000000..bf8d2ff81ce
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/02-install-and-config/01-database-and-async-runtime.md
@@ -0,0 +1,63 @@
+# 数据库与异步运行时
+
+:::caution 我们需要你的支持！⭐
+感谢你使用 SeaORM。请为我们的 [GitHub 仓库](https://github.com/SeaQL/sea-orm) 标星！你的支持对 SeaORM 的持续开发和维护至关重要。
+:::
+
+首先，将 `sea-orm` 添加到 `Cargo.toml` 的 `[dependencies]` 中。
+
+```toml title="Cargo.toml"
+sea-orm = { version = "1.1.0", features = [ <DATABASE_DRIVER>, <ASYNC_RUNTIME>, "macros" ] }
+```
+
+你必须选择一个 `DATABASE_DRIVER` 和一个 `ASYNC_RUNTIME`。如果你使用 SeaORM 生成的实体，则需要 `macros`。
+
+## DATABASE_DRIVER
+
+你可以从下列选项中选择一个或多个：
+
++ `sqlx-mysql` - SQLx 的 MySQL 和 MariaDB 驱动
++ `sqlx-postgres` - SQLx 的 PostgreSQL 驱动
++ `sqlx-sqlite` - SQLx 的 SQLite 驱动
+
+另请参阅：[SQLx 文档](https://docs.rs/crate/sqlx/latest/features)。
+
+:::tip SQL Server (MSSQL) 后端
+
+有关 MSSQL 驱动程序的安装和配置，请参考[这里](https://www.sea-ql.org/SeaORM-X/docs/install-and-config/database-and-async-runtime/)
+
+:::
+
+## ASYNC_RUNTIME
+
+你必须从以下选项中选择一个：
+
+`runtime-async-std-native-tls`、`runtime-tokio-native-tls`、`runtime-async-std-rustls`、`runtime-tokio-rustls`
+
+基本格式为 `runtime-ASYNC_RUNTIME-TLS_LIB`：
+
++ `ASYNC_RUNTIME` 可以是 [`async-std`](https://crates.io/crates/async-std) 或 [`tokio`](https://crates.io/crates/tokio)
++ `TLS_LIB` 可以是 [`native-tls`](https://crates.io/crates/native-tls) 或 [`rustls`](https://crates.io/crates/rustls)
+
+1. 选择与你的 Rust Web 框架对应的 ASYNC_RUNTIME：
+
+| ASYNC_RUNTIME | Web 框架 |
+| :-----------: | :------------: |
+| `async-std` | [`Tide`](https://docs.rs/tide) |
+| `tokio` | [`Axum`](https://docs.rs/axum)、[`Actix`](https://actix.rs/)、[`Poem`](https://docs.rs/poem)、[`Rocket`](https://rocket.rs/) |
+
+2. `native-tls` 使用平台的原生安全设施，而 `rustls` 是一个（几乎）纯 Rust 的实现。
+
+## 额外功能
+
++ `debug-print` - 将每个 SQL 语句打印到日志
++ `mock` - 用于单元测试的模拟接口
++ `macros` - 方便的过程宏
++ `with-chrono` - [`chrono`](https://crates.io/crates/chrono) 类型支持
++ `with-time` - [`time`](https://crates.io/crates/time) 类型支持
++ `with-json` - [`serde-json`](https://crates.io/crates/serde-json) 类型支持
++ `with-rust_decimal` - [`rust_decimal`](https://crates.io/crates/rust_decimal) 类型支持
++ `with-bigdecimal` - [`bigdecimal`](https://crates.io/crates/bigdecimal) 类型支持
++ `with-uuid` - [`uuid`](https://crates.io/crates/uuid) 类型支持
++ `postgres-array` - 支持 Postgres 中的数组类型（当 `sqlx-postgres` 功能开启时自动启用）
++ `sea-orm-internal` - 选择性启用不稳定的内部 API（用于访问重新导出的 SQLx 类型）
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/02-install-and-config/02-connection.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/02-install-and-config/02-connection.md
new file mode 100644
index 00000000000..3792eef2d4d
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/02-install-and-config/02-connection.md
@@ -0,0 +1,103 @@
+# 数据库连接
+
+要获取数据库连接，请使用 [`Database`](https://docs.rs/sea-orm/*/sea_orm/struct.Database.html) 接口：
+
+```rust
+let db: DatabaseConnection = Database::connect("protocol://username:password@host/database").await?;
+```
+
+`protocol` 可以是 `mysql:`、`postgres:` 或 `sqlite:`。
+
+`host` 通常是 `localhost`、域名或 IP 地址。
+
+:::tip
+
+如果 `localhost` 无法工作，请尝试输入 IP 地址和端口号，例如 `127.0.0.1:3306` 甚至 `192.168.x.x`。
+
+:::
+
+在底层，它会创建一个 [`sqlx::Pool`](https://docs.rs/sqlx/0.5/sqlx/struct.Pool.html) 并由 [`DatabaseConnection`](https://docs.rs/sea-orm/*/sea_orm/enum.DatabaseConnection.html) 持有。
+
+每次调用 `execute` 或 `query_one/all` 时，都会从连接池中获取一个连接，并在完成后释放回连接池。
+
+当你 `await` 多个查询时，它们将并行执行。
+
+## 连接字符串
+
+以下是一些数据库特定选项的示例：
+
+### MySQL
+
+```
+mysql://username:password@host/database
+```
+
+### Postgres
+
+#### 指定 Schema
+
+```
+postgres://username:password@host/database?currentSchema=my_schema
+```
+
+### SQLite
+
+#### 内存模式
+
+```
+sqlite::memory:
+```
+
+#### 文件不存在时，创建文件
+
+```
+sqlite://path/to/db.sqlite?mode=rwc
+```
+
+#### 只读模式
+
+```
+sqlite://path/to/db.sqlite?mode=ro
+```
+
+## 连接选项
+
+要配置连接，请使用 [`ConnectOptions`](https://docs.rs/sea-orm/*/sea_orm/struct.ConnectOptions.html) 接口：
+
+```rust
+let mut opt = ConnectOptions::new("protocol://username:password@host/database");
+opt.max_connections(100)
+    .min_connections(5)
+    .connect_timeout(Duration::from_secs(8))
+    .acquire_timeout(Duration::from_secs(8))
+    .idle_timeout(Duration::from_secs(8))
+    .max_lifetime(Duration::from_secs(8))
+    .sqlx_logging(true)
+    .sqlx_logging_level(log::LevelFilter::Info)
+    .set_schema_search_path("my_schema"); // 设置默认 PostgreSQL schema
+
+let db = Database::connect(opt).await?;
+```
+
+## 检查连接是否有效
+
+检查与数据库的连接是否仍然有效的方法。
+
+```rust
+|db: DatabaseConnection| {
+    assert!(db.ping().await.is_ok());
+    db.clone().close().await;
+    assert!(matches!(db.ping().await, Err(DbErr::ConnectionAcquire)));
+}
+```
+
+## 关闭连接
+
+连接会在 drop 时自动关闭。要显式关闭连接，请调用 `close` 方法。
+
+```rust
+let db = Database::connect(url).await?;
+
+// 连接在此处关闭
+db.close().await?;
+```
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/02-install-and-config/03-debug-log.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/02-install-and-config/03-debug-log.md
new file mode 100644
index 00000000000..da8f170e618
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/02-install-and-config/03-debug-log.md
@@ -0,0 +1,39 @@
+# 调试日志
+
+SeaORM 通过 [`tracing`](https://crates.io/crates/tracing) crate 记录调试信息。
+
+你可以通过 `debug-print` 功能标志（feature flag）启用 SeaORM 的日志记录功能：
+
+```toml
+[dependencies.sea-orm]
+version = "1.1.0"
+features = ["debug-print"]
+```
+
+你需要设置 [`tracing-subscriber`](https://crates.io/crates/tracing-subscriber) 来捕获和查看调试日志。请参阅以下的代码片段和此处的[完整示例](https://github.com/SeaQL/sea-orm/blob/master/examples/actix_example/src/main.rs)。
+
+```rust
+pub async fn main() {
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::DEBUG)
+        .with_test_writer()
+        .init();
+
+    // ...
+}
+```
+
+SeaORM 的调试打印会将参数注入到 SQL 字符串中，使其更易于阅读。你会看到 `SELECT "chef"."name" FROM "chef" WHERE "chef"."id" = 100`，而不是 `SELECT "chef"."name" FROM "chef" WHERE "chef"."id" = $1`。
+
+## SQLx 日志记录
+
+SQLx 也默认记录日志。如果启用 SeaORM 的 `debug-print`，可以向 `connect()` 传递 [`ConnectOptions`](https://docs.rs/sea-orm/*/sea_orm/struct.ConnectOptions.html) 来禁用 SQLx 的日志。
+
+```rust
+let mut opt = ConnectOptions::new("protocol://username:password@host/database".to_owned());
+opt
+    .sqlx_logging(false) // 禁用 SQLx 日志
+    .sqlx_logging_level(log::LevelFilter::Info); // 或者设置 SQLx 日志级别
+
+let db = Database::connect(opt).await?;
+```
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/02-install-and-config/_category_.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/02-install-and-config/_category_.json
new file mode 100644
index 00000000000..45d86975adf
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/02-install-and-config/_category_.json
@@ -0,0 +1,4 @@
+{
+  "label": "Installation & Configuration",
+  "collapsed": false
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/01-setting-up-migration.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/01-setting-up-migration.md
new file mode 100644
index 00000000000..99638d897e8
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/01-setting-up-migration.md
@@ -0,0 +1,180 @@
+# 设置迁移
+
+:::tip Rustacean 贴纸包 🦀
+[我们的贴纸](https://www.sea-ql.org/sticker-pack/)采用优质防水乙烯基材料制成，具有独特的哑光质感。
+把它们贴在你的笔记本、记事本或任何设备上，展示你对 Rust 的热爱！
+:::
+
+如果你从一个全新的数据库开始，最好对数据库模式进行版本控制。SeaORM 附带了一个迁移工具，允许你使用 SeaQuery 或 SQL 编写迁移。
+
+如果你已经有一个包含表和数据的数据库，可以跳过本章，直接前往[生成 SeaORM 实体](04-generate-entity/01-sea-orm-cli.md)。
+
+## 迁移表
+
+数据库中将创建一个表来跟踪已应用的迁移。这个表会在运行迁移时自动创建。
+
+<details>
+    <summary>默认情况下，迁移表名称为 `seaql_migrations` 。你也可以自定义迁移表的名称。</summary>
+
+```rust
+#[async_trait::async_trait]
+impl MigratorTrait for Migrator {
+    // 覆盖迁移表的名称
+    fn migration_table_name() -> sea_orm::DynIden {
+        "override_migration_table_name".into_iden()
+    }
+    ..
+}
+```
+</details>
+
+## 创建迁移目录
+
+首先，使用 `cargo` 安装 `sea-orm-cli`。
+
+```shell
+cargo install sea-orm-cli@1.1.0
+```
+
+:::tip SQL Server (MSSQL) 后端
+
+支持 MSSQL 的 `sea-orm-cli` 的安装说明在[这里](https://www.sea-ql.org/SeaORM-X/docs/migration/setting-up-migration/)。
+
+:::
+
+然后，执行 `sea-orm-cli migrate init` 来设置迁移目录。
+
+```shell
+# 在 `./migration` 中设置迁移目录
+$ sea-orm-cli migrate init
+Initializing migration directory...
+Creating file `./migration/src/lib.rs`
+Creating file `./migration/src/m20220101_000001_create_table.rs`
+Creating file `./migration/src/main.rs`
+Creating file `./migration/Cargo.toml`
+Creating file `./migration/README.md`
+Done!
+
+# 如果你想在其他地方设置迁移目录
+$ sea-orm-cli migrate init -d ./other/migration/dir
+```
+
+你应该会看到如下结构的迁移目录。
+
+```
+migration
+├── Cargo.toml
+├── README.md
+└── src
+    ├── lib.rs                              # Migrator API，用于集成迁移
+    ├── m20220101_000001_create_table.rs    # 示例迁移文件
+    └── main.rs                             # Migrator CLI，用于手动运行迁移
+```
+
+请注意，如果你直接在 Git 仓库中设置迁移目录，还会创建一个 `.gitignore` 文件。
+
+## 工作区结构
+
+建议你按如下方式组织 cargo 工作区，以便在应用程序 crate 和迁移 crate 之间共享 SeaORM 实体。请查看[集成示例](https://github.com/SeaQL/sea-orm/tree/master/examples)以获取演示。
+
+### 迁移 crate
+
+导入 [`sea-orm-migration`](https://crates.io/crates/sea-orm-migration) 和 [`async-std`](https://crates.io/crates/async-std) crate。
+
+```toml title="migration/Cargo.toml"
+[dependencies]
+async-std = { version = "1", features = ["attributes", "tokio1"] }
+
+[dependencies.sea-orm-migration]
+version = "1.1.0"
+features = [
+  # 如果你想通过 CLI 运行迁移，请至少启用一个 `ASYNC_RUNTIME` 和 `DATABASE_DRIVER` 功能。
+  # 支持的特性列表见 https://www.sea-ql.org/SeaORM/docs/install-and-config/database-and-async-runtime
+  # 例如：
+  # "runtime-tokio-rustls",  # `ASYNC_RUNTIME` 功能
+  # "sqlx-postgres",         # `DATABASE_DRIVER` 功能
+]
+```
+
+让我们编写一个迁移。详细说明在下一节。
+
+```rust title="migration/src/m20220120_000001_create_post_table.rs"
+use sea_orm_migration::prelude::*;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        // 将下面的示例替换为你自己的迁移脚本
+        todo!();
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        // 将下面的示例替换为你自己的迁移脚本
+        todo!();
+    }
+}
+```
+
+### 实体 crate
+
+在你的根工作区中创建一个实体 crate。
+
+<details>
+    <summary>还没有定义 SeaORM 实体？</summary>
+
+你可以创建一个不包含任何实体文件的实体 crate。然后，编写并运行迁移以在数据库中创建表。最后，使用 `sea-orm-cli` [生成 SeaORM 实体](04-generate-entity/01-sea-orm-cli.md)并将实体文件输出到 `entity/src/entities` 文件夹。
+
+生成实体文件后，可以在 `entity/src/lib.rs` 中添加以下行来重新导出生成的实体：
+
+```rust
+mod entities;
+pub use entities::*;
+```
+</details>
+
+```
+entity
+├── Cargo.toml      # 包含 SeaORM 依赖
+└── src
+    ├── lib.rs      # 重新导出 SeaORM 和实体
+    └── post.rs     # 定义 `post` 实体
+```
+
+指定 SeaORM 依赖。
+
+```toml title="entity/Cargo.toml"
+[dependencies]
+sea-orm = { version = "1.1.0" }
+```
+
+### 应用程序 crate
+
+这是应用程序逻辑所在的地方。
+
+创建一个包含 app、entity 和 migration crate 的工作区，并在 app crate 中导入 entity crate。
+
+如果你想捆绑迁移工具到应用的中，你也可以导入 migration crate。
+
+```toml title="./Cargo.toml"
+[workspace]
+members = [".", "entity", "migration"]
+
+[dependencies]
+entity = { path = "entity" }
+migration = { path = "migration" } # 视你的需要而定
+
+[dependencies]
+sea-orm = { version = "1.1.0", features = [..] }
+```
+
+然后，在应用中，你可以在启动时运行迁移。
+
+```rust title="src/main.rs"
+use migration::{Migrator, MigratorTrait};
+
+let connection = sea_orm::Database::connect(&database_url).await?;
+Migrator::up(&connection, None).await?;
+```
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/02-writing-migration.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/02-writing-migration.md
new file mode 100644
index 00000000000..4c04413d6c3
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/02-writing-migration.md
@@ -0,0 +1,382 @@
+# 编写迁移
+
+每个迁移包含两个方法：`up` 和 `down`。`up` 方法用于更改数据库模式，例如添加新表、列或索引，而 `down` 方法则用于回滚 `up` 方法中执行的操作。
+
+SeaORM 迁移系统具有以下优点：
+
+1. 使用 SeaQuery 或 SQL 编写 DDL 语句
+2. 执行多个 DDL（带条件）
+3. 使用 SeaORM API 填充（seed）数据
+
+## 创建迁移
+
+通过执行 `sea-orm-cli migrate generate` 命令来生成新的迁移文件。
+
+如果你在文件名中使用空格，它会自动按约定进行转换。
+
+```shell
+sea-orm-cli migrate generate NAME_OF_MIGRATION [--local-time]
+
+# 例如，生成如下所示的 `migration/src/m20220101_000001_create_table.rs`
+sea-orm-cli migrate generate create_table
+
+# 这将创建与上述命令相同的迁移文件
+sea-orm-cli migrate generate "create table"
+```
+
+或者你可以使用下面的模板创建迁移文件。按照命名约定 `mYYYYMMDD_HHMMSS_migration_name.rs` 命名文件。
+
+```rust title="migration/src/m20220101_000001_create_table.rs"
+use sea_orm_migration::prelude::*;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .create_table( ... )
+            .await
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .drop_table( ... )
+            .await
+    }
+}
+```
+
+此外，你必须在 [`MigratorTrait::migrations`](https://docs.rs/sea-orm-migration/*/sea_orm_migration/migrator/trait.MigratorTrait.html#tymethod.migrations) 方法中包含新的迁移。迁移应按时间顺序排序。
+
+```rust title="migration/src/lib.rs"
+pub use sea_orm_migration::*;
+
+mod m20220101_000001_create_table;
+
+pub struct Migrator;
+
+#[async_trait]
+impl MigratorTrait for Migrator {
+    fn migrations() -> Vec<Box<dyn MigrationTrait>> {
+        vec![
+            Box::new(m20220101_000001_create_table::Migration),
+        ]
+    }
+}
+```
+
+## 定义迁移
+
+请参阅 [`SchemaManager`](https://docs.rs/sea-orm-migration/*/sea_orm_migration/manager/struct.SchemaManager.html) 获取 API 参考。
+
+### 使用 SeaQuery
+
+点击[此处](https://github.com/SeaQL/sea-query#table-create)快速了解 SeaQuery 的 DDL 语句。
+
+你可以使用 [`DeriveIden`](https://docs.rs/sea-orm/*/sea_orm/derive.DeriveIden.html) 宏来定义将在迁移中使用的标识符。
+
+```rust
+#[derive(DeriveIden)]
+enum Post {
+    Table, // 这是一个特殊情况；将映射到 `post`
+    Id,
+    Title,
+    #[sea_orm(iden = "full_text")] // 重命名标识符
+    Text,
+}
+
+assert_eq!(Post::Table.to_string(), "post");
+assert_eq!(Post::Id.to_string(), "id");
+assert_eq!(Post::Title.to_string(), "title");
+assert_eq!(Post::Text.to_string(), "full_text");
+```
+
+以下是一些你可能会觉得有用的常见 DDL 片段。
+
+#### Schema 创建方法
+- 创建表
+    ```rust
+    use sea_orm::{EnumIter, Iterable};
+
+    #[derive(DeriveIden)]
+    enum Post {
+        Table,
+        Id,
+        Title,
+        #[sea_orm(iden = "text")] // 重命名标识符
+        Text,
+        Category,
+    }
+
+    #[derive(Iden, EnumIter)]
+    pub enum Category {
+        #[iden = "Feed"]
+        Feed,
+        #[iden = "Story"]
+        Story,
+    }
+
+    // 记得将 `sea_orm_migration::schema::*` schema 助手导入作用域
+    use sea_orm_migration::{prelude::*, schema::*};
+
+    // 定义表 schema
+    manager
+        .create_table(
+            Table::create()
+                .table(Post::Table)
+                .if_not_exists()
+                .col(pk_auto(Post::Id))
+                .col(string(Post::Title))
+                .col(string(Post::Text))
+                .col(enumeration_null(Post::Category, "category", Category::iter()))
+        )
+        .await
+
+    // 上述等同于：
+    manager
+        .create_table(
+            Table::create()
+                .table(Post::Table)
+                .if_not_exists()
+                .col(ColumnDef::new(Post::Id)
+                        .integer()
+                        .not_null()
+                        .auto_increment()
+                        .primary_key()
+                )
+                .col(ColumnDef::new(Post::Title).string().not_null())
+                .col(ColumnDef::new(Post::Text).string().not_null())
+                .col(ColumnDef::new(Post::Category)
+                        .enumeration("category", Category::iter()))
+        )
+        .await
+    ```
+- 创建索引
+    ```rust
+    manager.create_index(sea_query::Index::create()..)
+    ```
+- 创建外键
+    ```rust
+    manager.create_foreign_key(sea_query::ForeignKey::create()..)
+    ```
+- 创建数据类型 (仅限 PostgreSQL)
+    ```rust
+    use sea_orm::{EnumIter, Iterable};
+    use sea_orm_migration::prelude::extension::postgres::Type;
+
+    #[derive(DeriveIden)]
+    struct CategoryEnum;
+
+    #[derive(DeriveIden, EnumIter)]
+    enum CategoryVariants {
+        Feed,
+        #[sea_orm(iden = "story")]
+        Story,
+    }
+
+    manager
+        .create_type(
+            Type::create()
+                .as_enum(CategoryEnum)
+                .values(CategoryVariants::iter())
+                .to_owned()
+        )
+        .await?;
+    ```
+
+#### Schema 变更方法
+- 删除表
+    ```rust
+    use entity::post;
+
+    manager.drop_table(sea_query::Table::drop()..)
+    ```
+- 更改表
+    ```rust
+    manager.alter_table(sea_query::Table::alter()..)
+    ```
+- 重命名表
+    ```rust
+    manager.rename_table(sea_query::Table::rename()..)
+    ```
+- 清空表
+    ```rust
+    manager.truncate_table(sea_query::Table::truncate()..)
+    ```
+- 删除索引
+    ```rust
+    manager.drop_index(sea_query::Index::drop()..)
+    ```
+- 删除外键
+    ```rust
+    manager.drop_foreign_key(sea_query::ForeignKey::drop()..)
+    ```
+- 更改数据类型 (仅限 PostgreSQL)
+    ```rust
+    manager.alter_type(sea_query::Type::alter()..)
+    ```
+- 删除数据类型 (仅限 PostgreSQL)
+    ```rust
+    manager.drop_type(sea_query::extension::postgres::Type()..)
+    ```
+
+#### Schema 检查方法
+
+- 检查表是否存在
+    ```rust
+    manager.has_table("table_name")
+    ```
+- 检查列是否存在
+    ```rust
+    manager.has_column("table_name", "column_name")
+    ```
+- 检查索引是否存在
+    ```rust
+    manager.has_index("table_name", "index_name")
+    ```
+
+### 使用原始 SQL
+
+你可以在迁移文件中使用原始 SQL，但这样会失去 SeaQuery 提供的多后端兼容性。
+
+```rust title="migration/src/m20220101_000001_create_table.rs"
+use sea_orm::Statement;
+use sea_orm_migration::prelude::*;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        let db = manager.get_connection();
+
+        // 如果 SQL 语句没有值绑定，则应使用 `execute_unprepared`
+        db.execute_unprepared(
+            "CREATE TABLE `cake` (
+                `id` int NOT NULL AUTO_INCREMENT PRIMARY KEY,
+                `name` varchar(255) NOT NULL
+            )"
+        )
+        .await?;
+
+        // 如果 SQL 包含值绑定，则应构造一个 `Statement`
+        let stmt = Statement::from_sql_and_values(
+            manager.get_database_backend(),
+            r#"INSERT INTO `cake` (`name`) VALUES (?)"#,
+            ["Cheese Cake".into()]
+        );
+        db.execute(stmt).await?;
+
+        Ok(())
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .get_connection()
+            .execute_unprepared("DROP TABLE `cake`")
+            .await?;
+
+        Ok(())
+    }
+}
+```
+
+## 技巧 1：在一个迁移中组合多个 schema 更改
+
+你可以在 up 和 down 迁移函数中组合多个更改。这是一个完整的示例：
+
+```rust
+// 记得将 `sea_orm_migration::schema::*` schema 助手导入作用域
+use sea_orm_migration::{prelude::*, schema::*};
+
+async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+
+    manager
+        .create_table(
+            sea_query::Table::create()
+                .table(Post::Table)
+                .if_not_exists()
+                .col(pk_auto(Post::Id))
+                .col(string(Post::Title))
+                .col(string(Post::Text))
+        )
+        .await?;
+
+    manager
+        .create_index(
+            Index::create()
+                .if_not_exists()
+                .name("idx-post_title")
+                .table(Post::Table)
+                .col(Post::Title)
+        )
+        .await?;
+
+    Ok(()) // 一切顺利！
+}
+```
+
+这是匹配的 down 函数：
+
+```rust
+async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+
+    manager.drop_index(Index::drop().name("idx-post-title"))
+    .await?;
+
+    manager.drop_table(Table::drop().table(Post::Table))
+    .await?;
+
+    Ok(()) // 一切顺利！
+}
+```
+
+## 技巧 2：`ADD COLUMN IF NOT EXISTS`
+
+由于 MySQL 不支持此语法，你可以这么做：
+
+```rust
+async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+    if !manager.has_column("my_table", "col_to_add").await? {
+        // ALTER TABLE `my_table` ADD COLUMN `col_to_add` ..
+    }
+
+    Ok(())
+}
+```
+
+## 技巧 3：使用实体填充数据
+
+```rust
+async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+    let db = manager.get_connection();
+
+    cake::ActiveModel {
+        name: Set("Cheesecake".to_owned()),
+        ..Default::default()
+    }
+    .insert(db)
+    .await?;
+
+    Ok(())
+}
+```
+
+[完整示例](https://github.com/SeaQL/sea-orm/blob/master/examples/seaography_example/migration/src/m20230102_000001_seed_bakery_data.rs)。
+
+## 原子迁移
+
+在 Postgres 中，迁移会以原子方式执行，这意味着迁移脚本将在事务内执行。如果迁移失败，对数据库所做的更改将回滚。但是，MySQL 和 SQLite 不支持原子迁移。
+
+你可以在迁移内启动事务，以执行诸如为新创建的表[填充示例数据](03-migration/04-seeding-data.md#seeding-data-transactionally)之类的操作。
+
+## Schema 优先还是实体优先？
+
+总体而言，我们推荐 schema 优先的方法：先编写迁移，然后从运行中的数据库生成实体
+
+但有时，你可能希望使用 [`create_*_from_entity`](09-schema-statement/01-create-table.md) 方法从手写的实体文件引导（bootstrap）数据库。
+
+如果你打算永远不修改实体的 schema，这完全没问题。或者，你可以保留原始实体并将其副本嵌入到迁移文件中。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/03-running-migration.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/03-running-migration.md
new file mode 100644
index 00000000000..b2a063c2613
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/03-running-migration.md
@@ -0,0 +1,112 @@
+# 运行迁移
+
+定义迁移后，你可以在终端或应用程序启动时应用或回滚迁移。
+
+## 命令行界面 (CLI)
+
+迁移可以在终端中手动运行。`DATABASE_URL` 必须在你的环境中设置，请按照[此处](04-generate-entity/01-sea-orm-cli.md#configure-environment)的说明进行配置。
+
+支持的命令：
+- `init`：初始化迁移目录
+- `generate`：生成新的迁移文件
+- `up`：应用所有待处理的迁移
+- `up -n 10`：应用 10 个待处理的迁移
+- `down`：回滚上次应用的迁移
+- `down -n 10`：回滚上次应用的 10 个迁移
+- `status`：检查所有迁移的状态
+- `fresh`：从数据库中删除所有表，然后重新应用所有迁移
+- `refresh`：回滚所有已应用的迁移，然后重新应用所有迁移
+- `reset`：回滚所有已应用的迁移
+
+### 通过 `sea-orm-cli`
+
+`sea-orm-cli` 将在底层执行 `cargo run --manifest-path ./migration/Cargo.toml -- COMMAND`。
+
+```shell
+$ sea-orm-cli migrate COMMAND
+```
+
+你可以自定义清单路径。
+
+```shell
+$ sea-orm-cli migrate COMMAND -d ./other/migration/dir
+```
+
+### 通过 SeaSchema Migrator CLI
+
+运行在 `migration/main.rs` 中定义的迁移器 CLI。
+
+```shell
+cd migration
+cargo run -- COMMAND
+```
+
+## 以编程方式迁移
+
+你可以在应用程序启动时使用 `Migrator` 执行迁移，`Migrator` 实现了 [`MigratorTrait`](https://docs.rs/sea-orm-migration/*/sea_orm_migration/migrator/trait.MigratorTrait.html)。
+
+```rust title="src/main.rs"
+use migration::{Migrator, MigratorTrait};
+
+/// 应用所有待处理的迁移
+Migrator::up(db, None).await?;
+
+/// 应用 10 个待处理的迁移
+Migrator::up(db, Some(10)).await?;
+
+/// 回滚所有已应用的迁移
+Migrator::down(db, None).await?;
+
+/// 回滚上次应用的 10 个迁移
+Migrator::down(db, Some(10)).await?;
+
+/// 检查所有迁移的状态
+Migrator::status(db).await?;
+
+/// 从数据库中删除所有表，然后重新应用所有迁移
+Migrator::fresh(db).await?;
+
+/// 回滚所有已应用的迁移，然后重新应用所有迁移
+Migrator::refresh(db).await?;
+
+/// 回滚所有已应用的迁移
+Migrator::reset(db).await?;
+```
+
+## 在任何 PostgreSQL Schema 上运行迁移
+
+默认情况下，迁移将在 `public` schema 上运行，你现在可以在 CLI 或以编程方式运行迁移时覆盖它。
+
+对于 CLI，你可以使用 `-s` / `--database_schema` 选项指定目标 schema：
+* 通过 sea-orm-cli：`sea-orm-cli migrate -u postgres://root:root@localhost/database -s my_schema`
+* 通过 SeaORM 迁移器：`cargo run -- -u postgres://root:root@localhost/database -s my_schema`
+
+你还可以以编程方式在目标 schema 上运行迁移：
+
+```rust
+let connect_options = ConnectOptions::new("postgres://root:root@localhost/database")
+    .set_schema_search_path("my_schema") // 覆盖默认 schema
+    .to_owned();
+
+let db = Database::connect(connect_options).await?
+
+migration::Migrator::up(&db, None).await?;
+```
+
+:::tip SQL Server (MSSQL) 后端
+
+在任何 MSSQL schema 上运行迁移的配置可以在[这里](https://www.sea-ql.org/SeaORM-X/docs/migration/running-migration/)找到。
+
+:::
+
+## 检查迁移状态
+
+你可以使用 `MigratorTrait::get_pending_migrations()` 和 `MigratorTrait::get_applied_migrations()` 来检索迁移列表。
+
+```rust
+let migrations = Migrator::get_pending_migrations(db).await?;
+assert_eq!(migrations.len(), 5);
+
+let migration = migrations[0];
+assert_eq!(migration.name(), "m20220118_000002_create_fruit_table");
+assert_eq!(migration.status(), MigrationStatus::Pending);
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/04-seeding-data.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/04-seeding-data.md
new file mode 100644
index 00000000000..fb166a7d5ec
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/04-seeding-data.md
@@ -0,0 +1,85 @@
+# 填充数据
+
+你可以从 `SchemaManager` 中检索 `DbConn` 并根据需要执行数据操作，例如填充数据。
+
+```rust
+use sea_orm_migration::sea_orm::{entity::*, query::*};
+
+// ...
+
+#[async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        let db = manager.get_connection();
+
+        cake::ActiveModel {
+            name: Set("Cheesecake".to_owned()),
+            ..Default::default()
+        }
+        .insert(db)
+        .await?;
+
+        Ok(())
+    }
+}
+```
+
+你还可以执行任何 SeaQuery 语句。
+
+```rust
+use sea_orm_migration::sea_orm::{entity::*, query::*};
+
+// ...
+
+#[async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        let stmt = Query::insert()
+            .into_table(Cake::Table)
+            .columns([Cake::Name])
+            .values_panic(["Tiramisu".into()])
+            .to_owned();
+
+        manager.execute(stmt).await?;
+
+        Ok(())
+    }
+}
+
+#[derive(DeriveIden)]
+pub enum Cake {
+    Table,
+    Id,
+    Name,
+}
+```
+
+## 事务性填充数据
+
+启动一个事务并在迁移的 up 和 down 中执行 SQL。
+
+```rust
+use sea_orm_migration::sea_orm::{entity::*, query::*};
+
+// ...
+
+#[async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        // 获取连接并启动事务
+        let db = manager.get_connection();
+        let txn = db.begin().await?;
+
+        cake::ActiveModel {
+            name: Set("Cheesecake".to_owned()),
+            ..Default::default()
+        }
+        .insert(&txn)
+        .await?;
+
+        // 提交
+        txn.commit().await?;
+
+        Ok(())
+    }
+}
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/_category_.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/_category_.json
new file mode 100644
index 00000000000..dd4e8384894
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/03-migration/_category_.json
@@ -0,0 +1,5 @@
+{
+    "label": "Migration",
+    "collapsed": false
+  }
+  
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/01-sea-orm-cli.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/01-sea-orm-cli.md
new file mode 100644
index 00000000000..25fa0d2ce29
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/01-sea-orm-cli.md
@@ -0,0 +1,72 @@
+# 使用 `sea-orm-cli`
+
+首先，使用 `cargo` 安装 `sea-orm-cli`。
+
+```shell
+cargo install sea-orm-cli@1.1.0
+```
+
+:::tip SQL Server (MSSQL) 后端
+
+支持 MSSQL 的 `sea-orm-cli` 的安装和使用可以在[这里](https://www.sea-ql.org/SeaORM-X/docs/generate-entity/sea-orm-cli/)找到。
+
+:::
+
+## 配置环境
+
+在你的环境中设置 `DATABASE_URL`，或者在你的项目根目录中创建一个 `.env` 文件。指定你的数据库连接。
+
+```env title=".env"
+DATABASE_URL=protocol://username:password@localhost/database
+```
+
+## 获取帮助
+
+在任何 CLI 命令或子命令上使用 `-h` 标志以获取帮助。
+
+```shell
+# 列出所有可用命令
+sea-orm-cli -h
+
+# 列出 `generate` 命令中所有可用的子命令
+sea-orm-cli generate -h
+
+# 显示如何使用 `generate entity` 子命令
+sea-orm-cli generate entity -h
+```
+
+## 生成实体文件
+
+发现数据库中的所有表，并为每个表生成相应的 SeaORM 实体文件。
+
+支持的数据库：
+- MySQL
+- PostgreSQL
+- SQLite
+
+命令行选项：
+- `-u` / `--database-url`：数据库 URL（默认：ENV 中指定的 DATABASE_URL）
+- `-s` / `--database-schema`：数据库 schema（默认：ENV 中指定的 DATABASE_SCHEMA）
+    - 对于 MySQL 和 SQLite，此参数将被忽略
+    - 对于 PostgreSQL，此参数是可选的，默认值为“public”
+- `-o` / `--output-dir`：实体文件输出目录（默认：当前目录）
+- `-v` / `--verbose`：打印调试消息
+- `-l` / `--lib`：将索引文件生成为 `lib.rs` 而不是 `mod.rs`
+- `--include-hidden-tables`：从隐藏表（名称以下划线开头的表默认隐藏并忽略）生成实体文件
+- `--ignore-tables`：跳过为指定表生成实体文件（默认：`seaql_migrations`）
+- `--compact-format`：生成[紧凑格式](04-generate-entity/02-entity-format.md)的实体文件（默认：true）
+- `--expanded-format`：生成[扩展格式](12-internal-design/05-expanded-entity-format.md)的实体文件
+- `--with-serde`：自动为实体派生 serde Serialize / Deserialize trait（`none`、`serialize`、`deserialize`、`both`）（默认：`none`）
+    - `--serde-skip-deserializing-primary-key`：生成带有主键字段标记为 `#[serde(skip_deserializing)]` 的实体模型
+    - `--serde-skip-hidden-column`：生成带有隐藏列（列名以下划线开头）字段标记为 `#[serde(skip)]` 的实体模型
+- `--date-time-crate`：用于生成实体的日期时间 crate（`chrono`、`time`）（默认：`chrono`）
+- `--max-connections`：连接池中要初始化的最大数据库连接数（默认：`1`）
+- `--model-extra-derives`：向生成的模型结构体追加额外的派生宏
+- `--model-extra-attributes`：向生成的模型结构体追加额外的属性
+- `--enum-extra-derives`：向生成的枚举追加额外的派生宏
+- `--enum-extra-attributes`：向生成的枚举追加额外的属性
+- `--seaography`：在实体中生成附加结构体以进行 seaography 集成
+
+```shell
+# 将数据库 `bakery` 的实体文件生成到 `entity/src`
+sea-orm-cli generate entity -u protocol://username:password@localhost/bakery -o entity/src
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/02-entity-format.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/02-entity-format.md
new file mode 100644
index 00000000000..cbf107fcf5e
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/02-entity-format.md
@@ -0,0 +1,260 @@
+# 实体格式
+
+让我们看一个简单的 [Cake](https://github.com/SeaQL/sea-orm/blob/master/src/tests_cfg/cake.rs) 实体。
+
+```rust
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "cake")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub name: String,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::fruit::Entity")]
+    Fruit,
+}
+
+impl Related<super::fruit::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Fruit.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}```
+
+:::info
+
+即使 `Relation` 枚举或 `ActiveModelBehavior` impl 块为空，也不要删除它们。
+:::
+
+## 实体
+
+`DeriveEntityModel` 宏完成了定义 `Entity` 以及关联 `Model`、`Column` 和 `PrimaryKey` 的所有繁重工作。
+
+### 表名
+
+`table_name` 属性指定数据库中对应的表。
+可选地，你还可以通过 `schema_name` 指定数据库 schema 或数据库名称。
+
+### 列名
+
+默认情况下，所有列名都假定为 snake_case。你可以通过指定 `rename_all` 属性来覆盖模型中所有列的此行为。
+
+```rust
+#[sea_orm(rename_all = "camelCase")]
+pub struct Model { ... }
+```
+
+<details>
+    <summary>你可以在此处找到 `rename_all` 属性的有效值列表</summary>
+
+- camelCase
+- kebab-case
+- mixed_case
+- SCREAMING_SNAKE_CASE
+- snake_case
+- title_case
+- UPPERCASE
+- lowercase
+- SCREAMING-KEBAB-CASE
+- PascalCase
+
+</details>
+
+## 列
+
+### 列名
+
+你可以通过指定 `column_name` 属性来覆盖列名。
+
+```rust
+#[derive(DeriveEntityModel)]
+#[sea_orm(table_name = "user", rename_all = "camelCase")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    id: i32,
+    first_name: String, // firstName
+    #[sea_orm(column_name = "lAsTnAmE")]
+    last_name: String, // lAsTnAmE
+}
+```
+
+### 列类型
+
+`column_type` 属性定义了支持该属性的数据库类型。通常你不必指定此项，因为它将从 rust 类型推断出来。例如，`i32` 默认映射到 `integer`，`String` 映射到 `varchar`。你可以在下一章中阅读有关类型映射的更多信息。
+
+```rust
+pub quantity: i32,  // 默认整数
+#[sea_orm(column_type = "Decimal(Some((16, 4)))")]
+pub price: Decimal, // 必须指定数字精度
+```
+
+由于 Postgres 不原生支持无符号整数类型，因此如果你想保持兼容性，不建议使用无符号类型（例如 `u64`）。
+
+### 附加属性
+
+你可以为列添加附加属性 `default_value`、`unique`、`indexed` 和 `nullable`。
+
+如果你为可选属性指定了自定义 `column_type`，则还必须指定 `nullable`。
+
+```rust
+#[sea_orm(column_type = "Text", default_value = "Sam", unique, indexed, nullable)]
+pub name: Option<String>
+```
+
+你可以定义跨多列的唯一键，以下将导致 `(order_id, cake_id)` 上的唯一索引。
+
+```rust
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "lineitem")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    #[sea_orm(unique_key = "item")]
+    pub order_id: i32,
+    #[sea_orm(unique_key = "item")]
+    pub cake_id: i32,
+}
+```
+
+这些属性用于 [create_table_from_entity](https://docs.rs/sea-orm/latest/sea_orm/schema/struct.Schema.html#method.create_table_from_entity) 以生成实体的表。
+
+### 在 Select 和 Save 上转换列类型
+
+如果你需要将列选择为一种类型，但将其保存到数据库中为另一种类型，你可以指定 `select_as` 和 `save_as` 属性来执行转换。一个典型的用例是将 `citext`（不区分大小写的文本）类型的列在 Rust 中选择为 `String`，并将其保存到数据库中为 `citext`。应该如下定义模型字段：
+
+```rust
+#[sea_orm(select_as = "text", save_as = "citext")]
+pub case_insensitive_text: String
+```
+
+### 忽略属性
+
+如果你想忽略某个特定的模型属性，使其不映射到任何数据库列，你可以使用 `ignore` 宏属性。
+
+```rust
+#[sea_orm(ignore)]
+pub ignore_me: String
+```
+
+## 主键
+
+使用 `primary_key` 属性将列标记为主键。
+
+```rust
+#[sea_orm(primary_key)]
+pub id: i32
+```
+
+### 自动递增
+
+默认情况下，`primary_key` 列隐含 `auto_increment`。通过指定 `false` 来覆盖它。
+
+```rust
+#[sea_orm(primary_key, auto_increment = false)]
+pub id: i32
+```
+
+### 复合键
+
+这通常发生在连接表中，其中两列元组用作主键。只需注释多列即可定义复合主键。复合键的 `auto_increment` 为 `false`。
+
+主键的最大元数为 12。
+
+```rust
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub cake_id: i32,
+    #[sea_orm(primary_key)]
+    pub fruit_id: i32,
+}
+```
+
+## 关系
+
+`DeriveRelation` 是一个宏，可帮助你实现 [`RelationTrait`](https://docs.rs/sea-orm/*/sea_orm/entity/trait.RelationTrait.html)。
+
+```rust
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::fruit::Entity")]
+    Fruit,
+}
+```
+
+如果没有关系，只需编写：
+
+```rust
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+```
+
+[Related](https://docs.rs/sea-orm/*/sea_orm/entity/trait.Related.html) trait 将实体连接在一起，以便你可以构建选择两个实体的查询。
+
+在[关系](06-relation/01-one-to-one.md)一章中了解更多关于关系的信息。
+
+## Active Model 行为
+
+`ActiveModel` 上不同操作的钩子。例如，你可以执行自定义验证逻辑或触发副作用。在事务内部，你甚至可以在操作完成后中止操作，防止其保存到数据库中。
+
+```rust
+#[async_trait]
+impl ActiveModelBehavior for ActiveModel {
+    /// 使用默认值创建新的 ActiveModel。也由 `Default::default()` 使用。
+    fn new() -> Self {
+        Self {
+            uuid: Set(Uuid::new_v4()),
+            ..ActiveModelTrait::default()
+        }
+    }
+
+    /// 将在插入/更新之前触发
+    async fn before_save<C>(self, db: &C, insert: bool) -> Result<Self, DbErr>
+    where
+        C: ConnectionTrait,
+    {
+        if self.price.as_ref() <= &0.0 {
+            Err(DbErr::Custom(format!(
+                "[before_save] Invalid Price, insert: {}",
+                insert
+            )))
+        } else {
+            Ok(self)
+        }
+    }
+
+    /// 将在插入/更新之后触发
+    async fn after_save<C>(model: Model, db: &C, insert: bool) -> Result<Model, DbErr>
+    where
+        C: ConnectionTrait,
+    {
+        Ok(model)
+    }
+
+    /// 将在删除之前触发
+    async fn before_delete<C>(self, db: &C) -> Result<Self, DbErr>
+    where
+        C: ConnectionTrait,
+    {
+        Ok(self)
+    }
+
+    /// 将在删除之后触发
+    async fn after_delete<C>(self, db: &C) -> Result<Self, DbErr>
+    where
+        C: ConnectionTrait,
+    {
+        Ok(self)
+    }
+}
+```
+
+如果不需要自定义，只需编写：
+
+```rust
+impl ActiveModelBehavior for ActiveModel {}
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/03-column-types.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/03-column-types.md
new file mode 100644
index 00000000000..834f6eec5b3
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/03-column-types.md
@@ -0,0 +1,150 @@
+# 列类型
+
+## 类型映射
+
+列类型将通过以下映射自动派生。
+
+:::tip SQL Server (MSSQL) 后端
+
+MSSQL 的类型映射可以在[这里](https://www.sea-ql.org/SeaORM-X/docs/generate-entity/entity-structure/)找到。
+
+:::
+
+Rust 原始数据类型的映射：
+
+| Rust 类型 | 数据库类型 <br/> ([`ColumnType`](https://docs.rs/sea-orm/*/sea_orm/entity/enum.ColumnType.html)) | SQLite <br/> 数据类型 | MySQL <br/> 数据类型 | PostgreSQL <br/> 数据类型 |
+| --------- | --------- | --------- | --------- | --------- |
+| `String` | Char | char | char | char |
+| `String` | String | varchar | varchar | varchar |
+| `i8` | TinyInteger | tinyint | tinyint | char |
+| `u8` | TinyUnsigned | tinyint  | tinyint unsigned | N/A |
+| `i16` | SmallInteger | smallint | smallint | smallint |
+| `u16` | SmallUnsigned | smallint | smallint unsigned | N/A |
+| `i32` | Integer | integer | int | integer |
+| `u32` | Unsigned | integer | int unsigned | N/A |
+| `i64` | BigInteger | bigint | bigint | bigint |
+| `u64` | BigUnsigned | bigint | bigint unsigned | N/A |
+| `f32` | Float | float | float | real |
+| `f64` | Double | double | double | double precision |
+| `bool` | Boolean | boolean | bool | bool |
+| `Vec<u8>` | Binary | blob | blob | bytea |
+
+Rust 非原始数据类型的映射。你可以查看 [`entity/prelude.rs`](https://github.com/SeaQL/sea-orm/blob/master/src/entity/prelude.rs) 以获取所有重新导出的类型。
+
+| Rust 类型 | 数据库类型 <br/> ([`ColumnType`](https://docs.rs/sea-orm/*/sea_orm/entity/enum.ColumnType.html)) | SQLite <br/> 数据类型 | MySQL <br/> 数据类型 | PostgreSQL <br/> 数据类型 |
+| --------- | --------- | --------- | --------- | --------- |
+| `Date`：chrono::NaiveDate <br/>`TimeDate`：time::Date | Date | date_text | date | date |
+| `Time`：chrono::NaiveTime <br/>`TimeTime`：time::Time | Time | time_text | time | time |
+| `DateTime`：chrono::NaiveDateTime <br/>`TimeDateTime`：time::PrimitiveDateTime | DateTime | datetime_text | datetime | timestamp |
+| `DateTimeLocal`：chrono::DateTime<Local> <br/>`DateTimeUtc`：chrono::DateTime<Utc> | Timestamp | timestamp_text | timestamp | N/A |
+| `DateTimeWithTimeZone`：chrono::DateTime<FixedOffset> <br/>`TimeDateTimeWithTimeZone`：time::OffsetDateTime | TimestampWithTimeZone | timestamp_with_timezone_text | timestamp | timestamp with time zone |
+| `Uuid`：uuid::Uuid, uuid::fmt::Braced, uuid::fmt::Hyphenated, uuid::fmt::Simple, uuid::fmt::Urn | Uuid | uuid_text | binary(16) | uuid |
+| `Json`：serde_json::Value | Json | json_text | json | json |
+| `Decimal`：rust_decimal::Decimal | Decimal | real | decimal | decimal |
+| `PgVector`：pgvector::Vector | Vector | N/A | N/A | vector |
+| `IpNetwork`：ipnetwork::IpNetwork | Inet | N/A | N/A | inet |
+
+你可以使用 `column_type` 属性覆盖 Rust 类型和 `ColumnType` 之间的默认映射。
+
+```rust
+#[sea_orm(column_type = "Text")]
+pub name: String
+```
+
+## JSON 列
+
+如果你需要将 JSON 字段反序列化为结构体。你需要为其派生 `FromJsonQueryResult`。
+
+```rust
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "json_struct")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    // JSON 列作为 `serde_json::Value`
+    pub json: Json,
+    // JSON 列作为自定义结构体
+    pub json_value: KeyValue,
+    // 可空 JSON 列作为自定义结构体，由 jsonb 支持（仅限 Postgres）
+    #[sea_orm(column_type = "JsonBinary")]
+    pub json_value_opt: Option<KeyValue>,
+    // 存储对象向量的 JSON 列
+    pub json_value_vec: Vec<KeyValue>,
+}
+
+// 自定义结构体必须派生 `FromJsonQueryResult`、`Serialize` 和 `Deserialize`
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, FromJsonQueryResult)]
+pub struct KeyValue {
+    pub id: i32,
+    pub name: String,
+    pub price: f32,
+    pub notes: Option<String>,
+}
+```
+
+如果你想要一种跨数据库实现数组列的方法，你可以用包装类型将其包装起来。
+
+```rust
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "json_string_vec")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    // 可空 JSON 列存储字符串向量
+    pub str_vec: Option<StringVec>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, FromJsonQueryResult)]
+pub struct StringVec(pub Vec<String>);
+```
+
+更多详细信息和示例在下一章。
+
+## Postgres 数组
+
+数组数据类型是 Postgres 独有的功能。你可以定义一个 SeaORM 已支持的原始类型向量。
+
+```rust
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "collection")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub integers: Vec<i32>,
+    pub integers_opt: Option<Vec<i32>>,
+    pub floats: Vec<f32>,
+    pub doubles: Vec<f64>,
+    pub strings: Vec<String>,
+}
+```
+
+## Postgres 向量
+
+自 `1.1.6` 起，添加了 PgVector 支持。需要 `postgres-vector` 功能标志。
+
+```rust
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "image_model")]
+pub struct Model {
+    #[sea_orm(primary_key, auto_increment = false)]
+    pub id: i32,
+    pub embedding: PgVector,
+}
+```
+
+有关完整示例，请参阅 [embedding_tests](https://github.com/SeaQL/sea-orm/blob/1.1.x/tests/embedding_tests.rs)。
+
+## IpNetwork (Postgres)
+
+自 `1.1.8` 起，添加了 IpNetwork 支持。需要 `with-ipnetwork` 功能标志。
+
+```rust
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "host_network")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub ipaddress: IpNetwork,
+    #[sea_orm(column_type = "Cidr")]
+    pub network: IpNetwork,
+}
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/04-enumeration.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/04-enumeration.md
new file mode 100644
index 00000000000..5f20bc90529
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/04-enumeration.md
@@ -0,0 +1,298 @@
+# ActiveEnum
+
+你可以在模型中使用 Rust 枚举，其中值映射到数据库字符串、整数或原生枚举。
+
+## 字符串
+
+对于字符串枚举，除了能够为每个变体指定字符串值之外，你还可以为枚举指定 `rename_all` 属性，如果所有值都应基于大小写转换具有字符串值。
+
+```rust
+#[derive(EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "String(StringLen::None)", rename_all = "camelCase")]
+pub enum Category {
+    BigTask,
+    SmallWork,
+}
+```
+
+上述等同于：
+
+```rust
+#[derive(EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "String(StringLen::None)")]
+pub enum Category {
+    #[sea_orm(string_value = "bigTask")]
+    BigTask,
+    #[sea_orm(string_value = "smallBreak")]
+    SmallWork,
+}
+```
+
+它使用 `string_value` 手动指定字符串值。
+
+<details>
+    <summary>你可以在此处找到 `rename_all` 属性的有效值列表：</summary>
+
+- camelCase
+- kebab-case
+- mixed_case
+- SCREAMING_SNAKE_CASE
+- snake_case
+- title_case
+- UPPERCASE
+- lowercase
+- SCREAMING-KEBAB-CASE
+- PascalCase
+
+</details>
+
+### 简单枚举字符串
+
+`DeriveValueType` 添加了对枚举的支持。它为由字符串数据库类型支持的客户端枚举提供了 `DeriveActiveEnum` 的更简单替代方案。
+你必须提供自定义的 `from_str` 和 `to_str` 实现。
+
+```rust
+#[derive(DeriveValueType)]
+#[sea_orm(value_type = "String")]
+pub enum Category {
+    BigTask,
+    SmallWork,
+}
+```
+
+阅读下一章了解更多详情。
+
+## 整数
+
+```rust
+#[derive(EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "i32", db_type = "Integer")]
+pub enum Color {
+    #[sea_orm(num_value = 0)]
+    Black,
+    #[sea_orm(num_value = 1)]
+    White,
+}
+```
+或者，你可以编写：
+```rust
+#[derive(EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "i32", db_type = "Integer")]
+pub enum Color {
+    Black = 0,
+    White = 1,
+}
+```
+
+## 原生数据库枚举
+
+```rust
+#[derive(EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "tea")]
+pub enum Tea {
+    #[sea_orm(string_value = "EverydayTea")]
+    EverydayTea,
+    #[sea_orm(string_value = "BreakfastTea")]
+    BreakfastTea,
+}
+```
+
+## MySQL
+
+MySQL 枚举只是列定义的一部分，不能用于不同的表。
+
+```rust
+Table::create()
+    .table(Posts::TableName)
+    .col(ColumnDef::new(Posts::ColumnName)
+            .enumeration("tea", ["EverydayTea", "BreakfastTea"]))
+
+"CREATE TABLE `table_name` (`column_name` ENUM('EverydayTea', 'BreakfastTea'))",
+```
+
+## Postgres
+
+如果你使用 Postgres，枚举必须在迁移中以单独的 `Type` 语句创建，你可以使用以下方式创建它：
+
+### 1. `TYPE` 语句
+
+[完整示例](https://github.com/SeaQL/sea-orm/blob/master/sea-orm-migration/tests/common/migration/m20220118_000004_create_tea_enum.rs)。
+
+```rust
+// 在迁移中运行：
+
+manager
+    .create_type(
+        // CREATE TYPE "tea" AS ENUM ('EverydayTea', 'BreakfastTea')
+        Type::create()
+            .as_enum("tea")
+            .values(["EverydayTea", "BreakfastTea"])
+            .to_owned(),
+    )
+    .await?;
+```
+
+### 2. `create_enum_from_active_enum`
+此方法将提供一个接口，用于将类型添加到数据库、将类型用于表列以及在填充数据时将此类型的值添加到行。
+
+1. 定义一个 `ActiveEnum`
+
+```rust
+#[derive(EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "tea_type")]
+pub enum TeaType {
+    #[sea_orm(string_value = "EverydayTea")]
+    EverydayTea,
+    #[sea_orm(string_value = "BreakfastTea")]
+    BreakfastTea,
+}
+```
+
+2. 在数据库中创建类型
+
+```rust
+use sea_orm::{Schema, DbBackend};
+
+// 在迁移中：
+let schema = Schema::new(DbBackend::Postgres);
+
+manager
+    .create_type(
+        // CREATE TYPE "tea_type" AS ENUM ('EverydayTea', 'BreakfastTea')
+        schema.create_enum_from_active_enum::<TeaType>(),
+    )
+    .await?;
+```
+
+3. 在创建表时将类型用作表列类型
+
+```rust diff
+// 在迁移中：
+
+manager::create()
+    .table(Tea::Table)
+    .if_not_exists()
+    .col(Column::new(Tea::Type).custom(TeaType::name())) // 将类型用于表列
+    // ... 更多列
+```
+> 另请参阅 [Schema 创建方法 - 创建表](https://www.sea-ql.org/SeaORM/docs/migration/writing-migration/#schema-creation-methods)
+
+4. 在填充数据库时使用类型
+
+```rust
+// 在迁移中
+
+let insert = Query::insert()
+    .into_table(Tea::Table)
+    .columns([Tea::TeaType])
+    .values_panic([TeaType::EverydayTea.as_enum()]) // 调用 `as_enum` 将变体转换为 SimpleExpr
+    .to_owned();
+
+manager.execute(insert).await?;
+// ...
+```
+> 另请参阅 [填充数据 - 使用 sea_query 语句](https://www.sea-ql.org/SeaORM/docs/migration/seeding-data/#:~:text=write%20SeaQuery%20statement%20to%20seed%20the%20table)
+
+## Trait 实现
+
+[`DeriveActiveEnum`](https://docs.rs/sea-orm/*/sea_orm/derive.DeriveActiveEnum.html) 宏在底层实现了 [`ActiveEnum`](https://docs.rs/sea-orm/*/sea_orm/entity/trait.ActiveEnum.html) trait。
+
+```rust
+use sea_orm::entity::prelude::*;
+
+#[derive(Debug, PartialEq, Eq, EnumIter, DeriveActiveEnum)]
+#[sea_orm(
+    rs_type = "String",
+    db_type = "String(StringLen::N(1))",
+    enum_name = "category"
+)]
+pub enum Category {
+    #[sea_orm(string_value = "B")]
+    Big,
+    #[sea_orm(string_value = "S")]
+    Small,
+}
+```
+
+<details>
+  <summary>为了说明目的，这大致是宏实现的内容：</summary>
+  <div>
+
+```rust
+use sea_orm::entity::prelude::*;
+
+#[derive(Debug, PartialEq, Eq, EnumIter)]
+pub enum Category {
+    Big,
+    Small,
+}
+
+// 手动实现
+impl ActiveEnum for Category {
+    // 宏属性 `rs_type` 在此处粘贴
+    type Value = String;
+
+    // 默认情况下，如果未明确提供 `enum_name`，则 Rust 枚举的名称为驼峰式
+    fn name() -> String {
+        "category".to_owned()
+    }
+
+    // 将 Rust 枚举变体映射到相应的 `num_value` 或 `string_value`
+    fn to_value(&self) -> Self::Value {
+        match self {
+            Self::Big => "B",
+            Self::Small => "S",
+        }
+        .to_owned()
+    }
+
+    // 将 `num_value` 或 `string_value` 映射到相应的 Rust 枚举变体
+    fn try_from_value(v: &Self::Value) -> Result<Self, DbErr> {
+        match v.as_ref() {
+            "B" => Ok(Self::Big),
+            "S" => Ok(Self::Small),
+            _ => Err(DbErr::Type(format!(
+                "unexpected value for Category enum: {}",
+                v
+            ))),
+        }
+    }
+
+    // 宏属性 `db_type` 在此处粘贴
+    fn db_type() -> ColumnDef {
+        ColumnType::String(Some(1)).def()
+    }
+}
+```
+  </div>
+</details>
+
+## 在模型上使用 ActiveEnum
+
+```rust
+use sea_orm::entity::prelude::*;
+
+// 定义 `Category` 活动枚举
+#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "String(StringLen::N(1))")]
+pub enum Category {
+    #[sea_orm(string_value = "B")]
+    Big,
+    #[sea_orm(string_value = "S")]
+    Small,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "active_enum")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    // 表示使用 `Category` 活动枚举的数据库列
+    pub category: Category,
+    pub category_opt: Option<Category>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+impl ActiveModelBehavior for ActiveModel {}
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/05-newtype.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/05-newtype.md
new file mode 100644
index 00000000000..952cec0f918
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/05-newtype.md
@@ -0,0 +1,310 @@
+# 新类型
+
+你可以定义一个新类型 (`T`) 并将其用作模型字段。必须实现以下 trait。
+
+1. 为 [`sea_query::Value`](https://docs.rs/sea-query/*/sea_query/value/enum.Value.html) 实现 `From<T>`
+2. 为 `T` 实现 [`sea_orm::TryGetable`](https://docs.rs/sea-orm/*/sea_orm/trait.TryGetable.html)
+3. 为 `T` 实现 [`sea_query::ValueType`](https://docs.rs/sea-query/*/sea_query/value/trait.ValueType.html)
+4. 为 `T` 实现 [`sea_query::Nullable`](https://docs.rs/sea-query/*/sea_query/value/trait.Nullable.html)
+
+## 包装类型
+
+你可以创建包装 SeaORM 支持的任何类型的新类型。
+
+```rust
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "custom_value_type")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub number: Integer,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveValueType)]
+pub struct Integer(i32);
+```
+
+<details>
+    <summary>其中 `Integer` 展开为：</summary>
+
+```rust
+#[automatically_derived]
+impl std::convert::From<Integer> for sea_orm::Value {
+    fn from(source: Integer) -> Self {
+        source.0.into()
+    }
+}
+
+#[automatically_derived]
+impl sea_orm::TryGetable for Integer {
+    fn try_get_by<I: sea_orm::ColIdx>(res: &sea_orm::QueryResult, idx: I)
+        -> std::result::Result<Self, sea_orm::TryGetError> {
+        <i32 as sea_orm::TryGetable>::try_get_by(res, idx).map(|v| Integer(v))
+    }
+}
+
+#[automatically_derived]
+impl sea_orm::sea_query::ValueType for Integer {
+    fn try_from(v: sea_orm::Value) -> std::result::Result<Self, sea_orm::sea_query::ValueTypeErr> {
+        <i32 as sea_orm::sea_query::ValueType>::try_from(v).map(|v| Integer(v))
+    }
+
+    fn type_name() -> std::string::String {
+        stringify!(Integer).to_owned()
+    }
+
+    fn array_type() -> sea_orm::sea_query::ArrayType {
+        sea_orm::sea_query::ArrayType::Int
+    }
+
+    fn column_type() -> sea_orm::sea_query::ColumnType {
+        sea_orm::sea_query::ColumnType::Integer
+    }
+}
+
+#[automatically_derived]
+impl sea_orm::sea_query::Nullable for Integer {
+    fn null() -> sea_orm::Value {
+        <i32 as sea_orm::sea_query::Nullable>::null()
+    }
+}
+```
+</details>
+
+### 将包装类型用作主键
+
+:::tip 自 `2.0.0` 起
+:::
+
+```rust
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "custom_value_type")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: Integer,
+}
+```
+
+仅适用于 `i8` / `i16` / `i32` / `i64` / `u8` / `u16` / `u32` / `u64`。
+
+## 包装 `Vec<T>` (仅限 Postgres)
+
+```rust
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "custom_vec_type")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub str_vec: StringVec,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveValueType)]
+pub struct StringVec(pub Vec<String>);
+```
+
+<details>
+    <summary>其中 `StringVec` 展开为：</summary>
+
+```rust
+#[automatically_derived]
+impl std::convert::From<StringVec> for Value {
+    fn from(source: StringVec) -> Self {
+        source.0.into()
+    }
+}
+
+#[automatically_derived]
+impl sea_orm::TryGetable for StringVec {
+    fn try_get_by<I: sea_orm::ColIdx>(res: &QueryResult, idx: I) -> Result<Self, sea_orm::TryGetError> {
+        <Vec<String> as sea_orm::TryGetable>::try_get_by(res, idx).map(|v| StringVec(v))
+    }
+}
+
+#[automatically_derived]
+impl sea_orm::sea_query::ValueType for StringVec {
+    fn try_from(v: Value) -> Result<Self, sea_orm::sea_query::ValueTypeErr> {
+        <Vec<String> as sea_orm::sea_query::ValueType>::try_from(v).map(|v| StringVec(v))
+    }
+
+    fn type_name() -> String {
+        stringify!(StringVec).to_owned()
+    }
+
+    fn array_type() -> sea_orm::sea_query::ArrayType {
+        sea_orm::sea_query::ArrayType::String
+    }
+
+    fn column_type() -> sea_orm::sea_query::ColumnType {
+        sea_orm::sea_query::ColumnType::String(StringLen::None)
+    }
+}
+
+#[automatically_derived]
+impl sea_orm::sea_query::Nullable for Integer {
+    fn null() -> sea_orm::Value {
+        <Vec<String> as sea_orm::sea_query::Nullable>::null()
+    }
+}
+```
+</details>
+
+## 包装 `Vec<T>` (后端通用)
+
+你还可以通过将对象序列化/反序列化为 JSON 来定义后端通用的 `Vec<T>` 字段：
+
+```rust
+use sea_orm::entity::prelude::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "json_vec_type")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub json_vec: ObjectVec,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, FromJsonQueryResult)]
+pub struct ObjectVec(pub Vec<MyObject>);
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct MyObject {
+    ..
+}
+```
+
+<details>
+    <summary>其中 `ObjectVec` 展开为：</summary>
+
+```rust
+impl sea_orm::TryGetableFromJson for ObjectVec {}
+
+impl std::convert::From<ObjectVec> for sea_orm::Value {
+    fn from(source: ObjectVec) -> Self {
+        sea_orm::Value::Json(serde_json::to_value(&source).ok().map(|s| std::boxed::Box::new(s)))
+    }
+}
+
+impl sea_orm::sea_query::ValueType for ObjectVec {
+    fn try_from(v: sea_orm::Value) -> Result<Self, sea_orm::sea_query::ValueTypeErr> {
+        match v {
+            sea_orm::Value::Json(Some(json)) => Ok(
+                serde_json::from_value(*json).map_err(|_| sea_orm::sea_query::ValueTypeErr)?,
+            ),
+            _ => Err(sea_orm::sea_query::ValueTypeErr),
+        }
+    }
+
+    fn type_name() -> String {
+        stringify!(ObjectVec).to_owned()
+    }
+
+    fn array_type() -> sea_orm::sea_query::ArrayType {
+        sea_orm::sea_query::ArrayType::Json
+    }
+
+    fn column_type() -> sea_orm::sea_query::ColumnType {
+        sea_orm::sea_query::ColumnType::Json
+    }
+}
+
+impl sea_orm::sea_query::Nullable for ObjectVec {
+    fn null() -> sea_orm::Value {
+        sea_orm::Value::Json(None)
+    }
+}
+```
+</details>
+
+## 枚举字符串
+
+自 `1.1.8` 起，`DeriveValueType` 也支持 `enum` 类型。它为由字符串数据库类型支持的客户端枚举提供了 `DeriveActiveEnum` 的更简单替代方案。
+
+```rust
+#[derive(DeriveValueType)]
+#[sea_orm(value_type = "String")]
+pub enum Tag {
+    Hard,
+    Soft,
+}
+
+// `from_str` 默认为 `std::str::FromStr::from_str`
+impl std::str::FromStr for Tag {
+    type Err = sea_orm::sea_query::ValueTypeErr;
+    fn from_str(s: &str) -> Result<Self, Self::Err> { .. }
+}
+
+// `to_str` 默认为 `std::string::ToString::to_string`。
+impl std::fmt::Display for Tag {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { .. }
+}
+```
+
+<details>
+    <summary>其中 `Tag` 展开为：</summary>
+
+```rust
+#[automatically_derived]
+impl std::convert::From<Tag> for sea_orm::Value {
+    fn from(source: Tag) -> Self {
+        std::string::ToString::to_string(&source).into()
+    }
+}
+
+#[automatically_derived]
+impl sea_orm::TryGetable for Tag {
+    fn try_get_by<I: sea_orm::ColIdx>(res: &sea_orm::QueryResult, idx: I)
+        -> std::result::Result<Self, sea_orm::TryGetError> {
+        let string = String::try_get_by(res, idx)?;
+        std::str::FromStr::from_str(&string).map_err(|err| sea_orm::TryGetError::DbErr(sea_orm::DbErr::Type(format!("{err:?}"))))
+    }
+}
+
+#[automatically_derived]
+impl sea_orm::sea_query::ValueType for Tag {
+    fn try_from(v: sea_orm::Value) -> std::result::Result<Self, sea_orm::sea_query::ValueTypeErr> {
+        let string = <String as sea_orm::sea_query::ValueType>::try_from(v)?;
+        std::str::FromStr::from_str(&string).map_err(|_| sea_orm::sea_query::ValueTypeErr)
+    }
+
+    fn type_name() -> std::string::String {
+        stringify!(Tag).to_owned()
+    }
+
+    fn array_type() -> sea_orm::sea_query::ArrayType {
+        sea_orm::sea_query::ArrayType::String
+    }
+
+    fn column_type() -> sea_orm::sea_query::ColumnType {
+        sea_orm::sea_query::ColumnType::String(sea_orm::sea_query::StringLen::None)
+    }
+}
+
+#[automatically_derived]
+impl sea_orm::sea_query::Nullable for Tag {
+    fn null() -> sea_orm::Value {
+        sea_orm::Value::String(None)
+    }
+}
+```
+</details>
+
+你可以使用自定义函数覆盖 `from_str` 和 `to_str`，这在你使用 [`strum::Display`](https://docs.rs/strum/latest/strum/derive.Display.html) 和 [`strum::EnumString`](https://docs.rs/strum/latest/strum/derive.EnumString.html) 或手动实现方法时特别有用：
+
+```rust
+#[derive(DeriveValueType)]
+#[sea_orm(value_type = "String", from_str = "Tag::from_str", to_str = "Tag::to_str")]
+pub enum Tag {
+    Color,
+    Grey,
+}
+
+impl Tag {
+    fn from_str(s: &str) -> Result<Self, ValueTypeErr> { .. }
+
+    fn to_str(&self) -> &'static str { .. }
+}
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/_category_.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/_category_.json
new file mode 100644
index 00000000000..300b9eddb52
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/04-generate-entity/_category_.json
@@ -0,0 +1,4 @@
+{
+  "label": "Generating Entities",
+  "collapsed": false
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/01-basic-schema.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/01-basic-schema.md
new file mode 100644
index 00000000000..0825d058fdf
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/01-basic-schema.md
@@ -0,0 +1,9 @@
+# 基本 Schema
+
+我们将使用这个[基本 schema](https://github.com/SeaQL/sea-orm/tree/master/src/tests_cfg) 进行演示：
+
++ `cake` 一对多 `fruit`
++ `cake` 多对多 `filling`
++ `cake_filling` 是 `cake` 和 `filling` 之间的连接表
+
+![基本 Schema](https://raw.githubusercontent.com/SeaQL/sea-orm/master/src/tests_cfg/basic_schema.svg)
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/02-select.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/02-select.md
new file mode 100644
index 00000000000..b25799746c8
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/02-select.md
@@ -0,0 +1,164 @@
+# 选择
+
+定义实体后，你就可以从数据库中检索数据了。数据库中的每一行数据都对应一个 `Model`。
+
+默认情况下，SeaORM 将选择 `Column` 枚举中定义的所有列。
+
+## 按主键查找
+
+通过主键查找模型，它可以是单个键或复合键。我们首先在 [`Entity`](https://docs.rs/sea-orm/*/sea_orm/entity/trait.EntityTrait.html) 上调用 [`find_by_id`](https://docs.rs/sea-orm/*/sea_orm/entity/trait.EntityTrait.html#method.find_by_id)，它帮助你自动构建选择查询和条件。然后，使用 `one` 方法从数据库中获取单个模型。
+
+```rust
+use super::cake::Entity as Cake;
+use super::cake_filling::Entity as CakeFilling;
+
+// 按主键查找
+let cheese: Option<cake::Model> = Cake::find_by_id(1).one(db).await?;
+
+// 按复合主键查找
+let vanilla: Option<cake_filling::Model> = CakeFilling::find_by_id((6, 8)).one(db).await?;
+```
+
+## 带条件和排序的查找
+
+除了通过主键检索模型之外，你还可以按特定顺序检索匹配特定条件的一个或多个模型。[`find`](https://docs.rs/sea-orm/*/sea_orm/entity/trait.EntityTrait.html#method.find) 方法允许你访问 SeaORM 中的查询构建器。它支持构建所有常见的选择表达式，如 `where` 和 `order by`。它们可以分别使用 [`filter`](https://docs.rs/sea-orm/*/sea_orm/query/trait.QueryFilter.html#method.filter) 和 [`order_by_*`](https://docs.rs/sea-orm/*/sea_orm/query/trait.QueryOrder.html#method.order_by) 方法构建。
+
+> 阅读更多关于[条件表达式](08-advanced-query/02-conditional-expression.md)的信息。
+
+```rust
+let chocolate: Vec<cake::Model> = Cake::find()
+    .filter(cake::Column::Name.contains("chocolate"))
+    .order_by_asc(cake::Column::Name)
+    .all(db)
+    .await?;
+```
+
+## 查找相关模型
+
+> 阅读更多关于[关系](06-relation/01-one-to-one.md)一章的内容。
+
+### 延迟加载
+
+使用 [`find_related`](https://docs.rs/sea-orm/*/sea_orm/entity/trait.ModelTrait.html#method.find_related) 方法。
+
+相关模型在你请求时按需加载，如果你想根据某些应用程序逻辑加载相关模型，则更可取。请注意，与急切加载相比，延迟加载会增加数据库往返次数。
+
+```rust
+// 首先查找一个蛋糕模型
+let cheese: Option<cake::Model> = Cake::find_by_id(1).one(db).await?;
+let cheese: cake::Model = cheese.unwrap();
+
+// 然后，查找此蛋糕的所有相关水果
+let fruits: Vec<fruit::Model> = cheese.find_related(Fruit).all(db).await?;
+```
+
+### 急切加载
+
+所有相关模型一次性加载。与延迟加载相比，这提供了最少的数据库往返次数。
+
+#### 一对一
+
+使用 [`find_also_related`](https://docs.rs/sea-orm/*/sea_orm/query/struct.Select.html#method.find_also_related) 方法。
+
+```rust
+let fruits_and_cakes: Vec<(fruit::Model, Option<cake::Model>)> = Fruit::find().find_also_related(Cake).all(db).await?;
+```
+
+#### 一对多 / 多对多
+
+使用 [`find_with_related`](https://docs.rs/sea-orm/*/sea_orm/query/struct.Select.html#method.find_with_related) 方法，相关模型将按父模型分组。此方法处理 1-N 和 M-N 两种情况，并且在涉及连接表时将执行 2 次连接。
+
+```rust
+let cake_with_fruits: Vec<(cake::Model, Vec<fruit::Model>)> = Cake::find()
+    .find_with_related(Fruit)
+    .all(db)
+    .await?;
+```
+
+### 批量加载
+
+自 0.11 起，我们引入了 [LoaderTrait](https://docs.rs/sea-orm/*/sea_orm/query/trait.LoaderTrait.html) 以批量加载相关实体。
+
+与急切加载相比，它以一次（或两次，在多对多情况下）更多的数据库往返为代价节省了带宽（考虑一对多情况，一侧的行可能会重复）。
+
+#### 一对一
+
+使用 [load_one](https://docs.rs/sea-orm/*/sea_orm/query/trait.LoaderTrait.html#tymethod.load_one) 方法。
+
+```rust
+let fruits: Vec<fruit::Model> = Fruit::find().all(db).await?;
+let cakes: Vec<Option<cake::Model>> = fruits.load_one(Cake, db).await?;
+```
+
+#### 一对多
+
+使用 [load_many](https://docs.rs/sea-orm/*/sea_orm/query/trait.LoaderTrait.html#tymethod.load_many) 方法。
+
+```rust
+let cakes: Vec<cake::Model> = Cake::find().all(db).await?;
+let fruits: Vec<Vec<fruit::Model>> = cakes.load_many(Fruit, db).await?;
+```
+
+#### 多对多
+
+使用 [load_many_to_many](https://docs.rs/sea-orm/*/sea_orm/query/trait.LoaderTrait.html#tymethod.load_many_to_many) 方法。你必须提供连接实体。
+
+```rust
+let cakes: Vec<cake::Model> = Cake::find().all(db).await?;
+let fillings: Vec<Vec<filling::Model>> = cakes.load_many_to_many(Filling, CakeFilling, db).await?;
+```
+
+## 分页结果
+
+使用自定义页面大小将任何 SeaORM 选择转换为[分页器](https://docs.rs/sea-orm/*/sea_orm/struct.Paginator.html)。
+
+```rust
+use sea_orm::{entity::*, query::*, tests_cfg::cake};
+let mut cake_pages = cake::Entity::find()
+    .order_by_asc(cake::Column::Id)
+    .paginate(db, 50);
+
+while let Some(cakes) = cake_pages.fetch_and_next().await? {
+    // 对 cakes: Vec<cake::Model> 执行操作
+}
+```
+
+## 光标分页
+
+如果你想根据主键等列对行进行分页，请使用光标分页。
+
+```rust
+use sea_orm::{entity::*, query::*, tests_cfg::cake};
+// 创建一个按 `cake`.`id` 排序的光标
+let mut cursor = cake::Entity::find().cursor_by(cake::Column::Id);
+
+// 按 `cake`.`id` > 1 AND `cake`.`id` < 100 过滤分页结果
+cursor.after(1).before(100);
+
+// 获取前 10 行（按 `cake`.`id` 升序排序）
+for cake in cursor.first(10).all(db).await? {
+    // 对 cake: cake::Model 执行操作
+}
+
+// 获取后 10 行（按 `cake`.`id` 降序排序，但行按升序返回）
+for cake in cursor.last(10).all(db).await? {
+    // 对 cake: cake::Model 执行操作
+}
+```
+
+基于复合主键的分页也可用。
+
+```rust
+use sea_orm::{entity::*, query::*, tests_cfg::cake_filling};
+let rows = cake_filling::Entity::find()
+    .cursor_by((cake_filling::Column::CakeId, cake_filling::Column::FillingId))
+    .after((0, 1))
+    .before((10, 11))
+    .first(3)
+    .all(&db)
+    .await?;
+```
+
+## 选择自定义
+
+如果你想选择自定义列和表达式，请阅读[自定义选择](08-advanced-query/01-custom-select.md)部分。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/03-active-model.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/03-active-model.md
new file mode 100644
index 00000000000..e905b400f66
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/03-active-model.md
@@ -0,0 +1,124 @@
+# ActiveModel
+
+在深入了解插入和更新操作之前，我们必须介绍 `ActiveValue` 和 `ActiveModel`。
+
+## ActiveValue
+
+`ActiveModel` 中字段的状态。
+
+有三种可能的状态，由三个枚举变体表示：
+
+- `Set` - 由应用程序显式设置并发送到数据库的 `Value`。
+    用于插入或设置特定值。
+
+    编辑现有值时，你可以使用 [`set_if_not_equal`](https://docs.rs/sea-orm/*/sea_orm/entity/enum.ActiveValue.html#method.set_if_not_equals)
+    在新值与旧值相同时保留 `Unchanged` 状态。
+    然后你可以有意义地使用 [`ActiveModelTrait::is_changed`](https://docs.rs/sea-orm/*/sea_orm/entity/trait.ActiveModelTrait.html#method.is_changed) 等方法。
+- `Unchanged` - 数据库中现有且未更改的 `Value`。
+
+    当你从数据库中查询现有 `Model` 并将其转换为 `ActiveModel` 时，你会得到这些。
+- `NotSet` - 未定义的 `Value`。没有内容发送到数据库。
+
+    当你创建新的 `ActiveModel` 时，其字段默认是 `NotSet`。
+
+    这在以下情况下很有用：
+
+     - 你插入新记录并希望数据库生成默认值（例如，id）。
+     - 在 `UPDATE` 语句中，你不想更新某些字段。
+
+这些状态之间的差异在构建 `INSERT` 和 `UPDATE` SQL 语句时很有用（请参阅下面的示例）。
+它对于了解记录中哪些字段已更改也很有用。
+
+### 示例
+
+```rust
+use sea_orm::tests_cfg::{cake, fruit};
+use sea_orm::{DbBackend, entity::*, query::*};
+
+// 在这里，我们使用 `NotSet` 让数据库自动生成 `id`。
+// 这与显式将 `cake_id` 设置为 `NULL` 的 `Set(None)` 不同。
+assert_eq!(
+    Insert::one(fruit::ActiveModel {
+        id: ActiveValue::NotSet,
+        name: ActiveValue::Set("Orange".to_owned()),
+        cake_id: ActiveValue::Set(None),
+    })
+    .build(DbBackend::Postgres)
+    .to_string(),
+    r#"INSERT INTO "fruit" ("name", "cake_id") VALUES ('Orange', NULL)"#
+);
+
+// 在这里，我们更新记录，将 `cake_id` 设置为新值
+// 并使用 `NotSet` 避免更新 `name` 字段。
+// `id` 是主键，因此它用于条件中，并且不更新。
+assert_eq!(
+    Update::one(fruit::ActiveModel {
+        id: ActiveValue::Unchanged(1),
+        name: ActiveValue::NotSet,
+        cake_id: ActiveValue::Set(Some(2)),
+    })
+    .build(DbBackend::Postgres)
+    .to_string(),
+    r#"UPDATE "fruit" SET "cake_id" = 2 WHERE "fruit"."id" = 1"#
+);
+```
+
+## ActiveModel
+
+`ActiveModel` 具有 `Model` 的所有属性，并包装在 `ActiveValue` 中。
+
+你可以使用 `ActiveModel` 插入一行，其中设置了列的子集。
+
+```rust
+let cheese: Option<cake::Model> = Cake::find_by_id(1).one(db).await?;
+
+// 获取模型
+let model: cake::Model = cheese.unwrap();
+assert_eq!(model.name, "Cheese Cake".to_owned());
+
+// 转换为 ActiveModel
+let active_model: cake::ActiveModel = model.into();
+assert_eq!(active_model.name, ActiveValue::unchanged("Cheese Cake".to_owned()));
+```
+
+### 检查 ActiveModel 是否已更改
+
+你可以使用 [`is_changed`](https://docs.rs/sea-orm/*/sea_orm/entity/prelude/trait.ActiveModelTrait.html#method.is_changed) 方法检查 `ActiveModel` 中的任何字段是否已 `Set`。
+
+```rust
+let mut fruit: fruit::ActiveModel = Default::default();
+assert!(!fruit.is_changed());
+
+fruit.set(fruit::Column::Name, "apple".into());
+assert!(fruit.is_changed());
+```
+
+### 将 ActiveModel 转换回 Model
+
+使用 [`try_into_model`](https://docs.rs/sea-orm/*/sea_orm/entity/trait.TryIntoModel.html#tymethod.try_into_model) 方法可以将 ActiveModel 转换回 Model。
+
+```rust
+assert_eq!(
+    ActiveModel {
+        id: Set(2),
+        name: Set("Apple".to_owned()),
+        cake_id: Set(Some(1)),
+    }
+    .try_into_model()
+    .unwrap(),
+    Model {
+        id: 2,
+        name: "Apple".to_owned(),
+        cake_id: Some(1),
+    }
+);
+
+assert_eq!(
+    ActiveModel {
+        id: Set(1),
+        name: NotSet,
+        cake_id: Set(None),
+    }
+    .try_into_model(),
+    Err(DbErr::AttrNotSet(String::from("name")))
+);
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/04-insert.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/04-insert.md
new file mode 100644
index 00000000000..88cb696cd37
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/04-insert.md
@@ -0,0 +1,256 @@
+# 插入
+
+## 插入一条
+
+插入一个活动模型并返回一个新的 `Model`。其值从数据库中检索，因此任何自动生成的字段都将被填充。
+
+```rust
+let pear = fruit::ActiveModel {
+    name: Set("Pear".to_owned()),
+    ..Default::default() // 所有其他属性都是 `NotSet`
+};
+
+let pear: fruit::Model = pear.insert(db).await?;
+```
+
+插入一个活动模型并返回最后插入的 id。其类型与模型的主键类型匹配，因此如果模型具有复合主键，它可能是一个元组。
+
+```rust
+let pear = fruit::ActiveModel {
+    name: Set("Pear".to_owned()),
+    ..Default::default() // 所有其他属性都是 `NotSet`
+};
+
+let res: InsertResult = fruit::Entity::insert(pear).exec(db).await?;
+assert_eq!(res.last_insert_id, 28)
+```
+
+:::tip SQL Server (MSSQL) 后端
+
+MSSQL 的 `IDENTITY INSERT` [此处](https://www.sea-ql.org/SeaORM-X/docs/basic-crud/insert/)有文档说明。
+
+:::
+
+## 插入多条
+
+插入多个活动模型并返回最后插入的 id。
+
+```rust
+let apple = fruit::ActiveModel {
+    name: Set("Apple".to_owned()),
+    ..Default::default()
+};
+
+let orange = fruit::ActiveModel {
+    name: Set("Orange".to_owned()),
+    ..Default::default()
+};
+
+let res: InsertResult = Fruit::insert_many([apple, orange]).exec(db).await?;
+assert_eq!(res.last_insert_id, 30)
+```
+
+向 `insert_many` 方法提供空集将导致错误。但是，你可以使用 `on_empty_do_nothing` 更改行为，它将 `InsertResult` 包装在 `TryInsertResult` 中。
+
+```rust
+let res = Bakery::insert_many(std::iter::empty())
+    .on_empty_do_nothing()
+    .exec(db)
+    .await;
+
+assert!(matches!(res, Ok(TryInsertResult::Empty)));
+```
+
+## 冲突时
+
+插入具有冲突行为的活动模型。
+
+```rust
+let orange = cake::ActiveModel {
+    id: ActiveValue::set(2),
+    name: ActiveValue::set("Orange".to_owned()),
+};
+
+assert_eq!(
+    cake::Entity::insert(orange.clone())
+        .on_conflict(
+            // 冲突时不做任何操作
+            sea_query::OnConflict::column(cake::Column::Name)
+                .do_nothing()
+                .to_owned()
+        )
+        .build(DbBackend::Postgres)
+        .to_string(),
+    r#"INSERT INTO "cake" ("id", "name") VALUES (2, 'Orange') ON CONFLICT ("name") DO NOTHING"#,
+);
+
+assert_eq!(
+    cake::Entity::insert(orange)
+        .on_conflict(
+            // 冲突时更新
+            sea_query::OnConflict::column(cake::Column::Name)
+                .update_column(cake::Column::Name)
+                .to_owned()
+        )
+        .build(DbBackend::Postgres)
+        .to_string(),
+    r#"INSERT INTO "cake" ("id", "name") VALUES (2, 'Orange') ON CONFLICT ("name") DO UPDATE SET "name" = "excluded"."name""#,
+);
+```
+
+执行 upsert 语句而不插入或更新任何行将导致 `DbErr::RecordNotInserted` 错误。
+
+```rust
+// 当 `id` 列有冲突值时，不做任何操作
+let on_conflict = OnConflict::column(Column::Id).do_nothing().to_owned();
+
+// 将 `1`、`2`、`3` 插入到表中
+let res = Entity::insert_many([
+    ActiveModel { id: Set(1) },
+    ActiveModel { id: Set(2) },
+    ActiveModel { id: Set(3) },
+])
+.on_conflict(on_conflict.clone())
+.exec(db)
+.await;
+
+assert_eq!(res?.last_insert_id, 3);
+
+// 将 `4` 和之前的 3 行一起插入到表中
+let res = Entity::insert_many([
+    ActiveModel { id: Set(1) },
+    ActiveModel { id: Set(2) },
+    ActiveModel { id: Set(3) },
+    ActiveModel { id: Set(4) },
+])
+.on_conflict(on_conflict.clone())
+.exec(db)
+.await;
+
+assert_eq!(res?.last_insert_id, 4);
+
+// 重复上次插入。由于所有 4 行都已存在，这实际上没有做任何操作。
+// 将抛出 `DbErr::RecordNotInserted` 错误。
+let res = Entity::insert_many([
+    ActiveModel { id: Set(1) },
+    ActiveModel { id: Set(2) },
+    ActiveModel { id: Set(3) },
+    ActiveModel { id: Set(4) },
+])
+.on_conflict(on_conflict)
+.exec(db)
+.await;
+
+assert_eq!(res.err(), Some(DbErr::RecordNotInserted));
+```
+
+如果你希望 `RecordNotInserted` 是 `Ok` 而不是错误，请调用 `.do_nothing()`：
+
+```rust
+let res = Entity::insert_many([..])
+    .on_conflict(on_conflict)
+    .do_nothing()
+    .exec(db)
+    .await;
+
+assert!(matches!(res, Ok(TryInsertResult::Conflicted)));
+```
+
+### MySQL 支持
+
+在主键 `ON CONFLICT` 上设置 `DO NOTHING`，但使用 MySQL 特定的 polyfill。
+
+```rust
+let orange = cake::ActiveModel {
+    id: ActiveValue::set(2),
+    name: ActiveValue::set("Orange".to_owned()),
+};
+
+assert_eq!(
+    cake::Entity::insert(orange.clone())
+        .on_conflict_do_nothing()
+        .build(DbBackend::MySql)
+        .to_string(),
+    r#"INSERT INTO `cake` (`id`, `name`) VALUES (2, 'Orange') ON DUPLICATE KEY UPDATE `id` = `id`"#,
+);
+assert_eq!(
+    cake::Entity::insert(orange.clone())
+        .on_conflict_do_nothing()
+        .build(DbBackend::Postgres)
+        .to_string(),
+    r#"INSERT INTO "cake" ("id", "name") VALUES (2, 'Orange') ON CONFLICT ("id") DO NOTHING"#,
+);
+assert_eq!(
+    cake::Entity::insert(orange)
+        .on_conflict_do_nothing()
+        .build(DbBackend::Sqlite)
+        .to_string(),
+    r#"INSERT INTO "cake" ("id", "name") VALUES (2, 'Orange') ON CONFLICT ("id") DO NOTHING"#,
+);
+```
+
+## 返回插入的模型
+
+Postgres 和 SQLite 支持，以下在插入后返回新插入的模型。
+
+```rust
+assert_eq!(
+    cake::Entity::insert(cake::ActiveModel {
+        id: NotSet,
+        name: Set("Apple Pie".to_owned()),
+    })
+    .exec_with_returning(&db)
+    .await?,
+    cake::Model {
+        id: 1,
+        name: "Apple Pie".to_owned(),
+    }
+);
+```
+
+```rust
+assert_eq!(
+    cake::Entity::insert_many([
+        cake::ActiveModel {
+            id: NotSet,
+            name: Set("Apple Pie".to_owned()),
+        },
+        cake::ActiveModel {
+            id: NotSet,
+            name: Set("Choco Pie".to_owned()),
+        },
+    ])
+    .exec_with_returning(&db)
+    .await?,
+    [
+        cake::Model {
+            id: 1,
+            name: "Apple Pie".to_owned(),
+        },
+        cake::Model {
+            id: 2,
+            name: "Choco Pie".to_owned(),
+        }
+    ]
+);
+```
+
+如果你只需要插入后的主键，还有一个 `exec_with_returning_keys`。
+
+```rust
+assert_eq!(
+    cakes_bakers::Entity::insert_many([
+        cakes_bakers::ActiveModel {
+            cake_id: Set(1),
+            baker_id: Set(2),
+        },
+        cakes_bakers::ActiveModel {
+            cake_id: Set(2),
+            baker_id: Set(1),
+        },
+    ])
+    .exec_with_returning_keys(db)
+    .await
+    .unwrap(),
+    [(1, 2), (2, 1)]
+);
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/05-update.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/05-update.md
new file mode 100644
index 00000000000..0bcbf858d87
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/05-update.md
@@ -0,0 +1,75 @@
+# 更新
+
+## 更新一条
+
+你将从查找结果中获得一个 `Model`。如果你想将模型保存回数据库，你需要*首先*将其转换为 `ActiveModel`。生成的查询将只包含 `Set` 属性。
+
+```rust
+let pear: Option<fruit::Model> = Fruit::find_by_id(28).one(db).await?;
+
+// 转换为 ActiveModel
+let mut pear: fruit::ActiveModel = pear.unwrap().into();
+
+// 更新名称属性
+pear.name = Set("Sweet pear".to_owned());
+
+// SQL: `UPDATE "fruit" SET "name" = 'Sweet pear' WHERE "id" = 28`
+let pear: fruit::Model = pear.update(db).await?;```
+
+要更新所有属性，你可以将 `Unchanged` 转换为 `Set`。
+
+```rust
+// 转换为 ActiveModel
+let mut pear: fruit::ActiveModel = pear.into();
+
+// 更新名称属性
+pear.name = Set("Sweet pear".to_owned());
+
+// 将特定属性设置为“脏”（强制更新）
+pear.reset(fruit::Column::CakeId);
+// 或者，将所有属性设置为“脏”（强制更新）
+pear.reset_all();
+
+// SQL: `UPDATE "fruit" SET "name" = 'Sweet pear', "cake_id" = 10 WHERE "id" = 28`
+let pear: fruit::Model = pear.update(db).await?;
+```
+
+## 更新多条
+
+你还可以更新数据库中的多行，而无需使用 SeaORM select 查找每个 `Model`。
+
+```rust
+// 使用 ActiveModel 批量设置属性
+let update_result: UpdateResult = Fruit::update_many()
+    .set(pear)
+    .filter(fruit::Column::Id.eq(1))
+    .exec(db)
+    .await?;
+
+// UPDATE `fruit` SET `cake_id` = 1 WHERE `fruit`.`name` LIKE '%Apple%'
+Fruit::update_many()
+    .col_expr(fruit::Column::CakeId, Expr::value(1))
+    .filter(fruit::Column::Name.contains("Apple"))
+    .exec(db)
+    .await?;
+```
+
+## 返回更新的模型
+
+仅 Postgres 支持，SQLite 需要 `sqlite-use-returning-for-3_35` 功能标志。
+
+```rust
+let fruits: Vec<fruit::Model> = Fruit::update_many()
+    .col_expr(fruit::Column::CakeId, Expr::value(1))
+    .filter(fruit::Column::Name.contains("Apple"))
+    .exec_with_returning(db)
+    .await?;
+
+assert_eq!(
+    fruits[0],
+    fruit::Model {
+        id: 2,
+        name: "Apple".to_owned(),
+        cake_id: Some(1),
+    }
+);
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/06-save.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/06-save.md
new file mode 100644
index 00000000000..d75c3b80b41
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/06-save.md
@@ -0,0 +1,31 @@
+# 保存
+
+这是一个帮助方法，用于将 `ActiveModel` 保存（插入/更新）到数据库中。
+
+## 保存行为
+
+保存 `ActiveModel` 时，它将根据主键属性执行插入或更新：
+
+- 如果主键是 `NotSet`，则插入
+- 如果主键是 `Set` 或 `Unchanged`，则更新
+
+## 用法
+
+调用 `save` 插入或更新 `ActiveModel`。
+
+```rust
+use sea_orm::ActiveValue::NotSet;
+
+let banana = fruit::ActiveModel {
+    id: NotSet, // 主键是 NotSet
+    name: Set("Banana".to_owned()),
+    ..Default::default() // 所有其他属性都是 `NotSet`
+};
+
+// 插入，因为主键 `id` 是 `NotSet`
+let banana: fruit::ActiveModel = banana.save(db).await?;
+
+banana.name = Set("Banana Mongo".to_owned());
+
+// 更新，因为主键 `id` 是 `Unchanged`
+let banana: fruit::ActiveModel = banana.save(db).await?;
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/07-delete.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/07-delete.md
new file mode 100644
index 00000000000..2ccc61c3977
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/07-delete.md
@@ -0,0 +1,65 @@
+# 删除
+
+## 删除一条
+
+从数据库中查找 `Model`，然后从数据库中删除相应的行。
+
+```rust
+use sea_orm::entity::ModelTrait;
+
+let orange: Option<fruit::Model> = Fruit::find_by_id(30).one(db).await?;
+let orange: fruit::Model = orange.unwrap();
+
+let res: DeleteResult = orange.delete(db).await?;
+assert_eq!(res.rows_affected, 1);
+```
+
+## 按主键删除
+
+除了从数据库中选择 `Model` 然后删除它之外。你还可以直接通过主键从数据库中删除一行。
+
+```rust
+let res: DeleteResult = Fruit::delete_by_id(38).exec(db).await?;
+assert_eq!(res.rows_affected, 1);
+```
+
+## 删除多条
+
+你还可以从数据库中删除多行，而无需使用 SeaORM select 查找每个 `Model`。
+
+```rust
+// DELETE FROM `fruit` WHERE `fruit`.`name` LIKE '%Orange%'
+let res: DeleteResult = fruit::Entity::delete_many()
+    .filter(fruit::Column::Name.contains("Orange"))
+    .exec(db)
+    .await?;
+
+assert_eq!(res.rows_affected, 2);
+```
+
+## 返回已删除的模型
+
+仅 Postgres 支持，SQLite 需要 `sqlite-use-returning-for-3_35` 功能标志。
+
+```rust
+assert_eq!(
+    fruit::Entity::delete(ActiveModel {
+        id: Set(3),
+        ..Default::default()
+    })
+    .exec_with_returning(db)
+    .await?,
+    Some(fruit::Model {
+        id: 3,
+        name: "Apple".to_owned(),
+    })
+);
+```
+
+```rust
+let deleted_models: Vec<order::Model> = order::Entity::delete_many()
+    .filter(order::Column::CustomerId.eq(22))
+    .exec_with_returning(db)
+    .await?
+
+assert_eq!(deleted_models.len(), 2); // 删除两项
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/08-json.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/08-json.md
new file mode 100644
index 00000000000..33dcd727aee
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/08-json.md
@@ -0,0 +1,130 @@
+# JSON
+
+## 选择 JSON 结果
+
+所有 SeaORM 选择都能够返回 `serde_json::Value`。
+
+```rust
+// 按 id 查找
+let cake: Option<serde_json::Value> = Cake::find_by_id(1)
+    .into_json()
+    .one(db)
+    .await?;
+
+assert_eq!(
+    cake,
+    Some(serde_json::json!({
+        "id": 1,
+        "name": "Cheese Cake"
+    }))
+);
+
+// 带过滤器的查找
+let cakes: Vec<serde_json::Value> = Cake::find()
+    .filter(cake::Column::Name.contains("chocolate"))
+    .order_by_asc(cake::Column::Name)
+    .into_json()
+    .all(db)
+    .await?;
+
+assert_eq!(
+    cakes,
+    [
+        serde_json::json!({
+            "id": 2,
+            "name": "Chocolate Forest"
+        }),
+        serde_json::json!({
+            "id": 8,
+            "name": "Chocolate Cupcake"
+        }),
+    ]
+);
+
+// 分页 JSON 结果
+let cake_pages: Paginator<_> = Cake::find()
+    .filter(cake::Column::Name.contains("chocolate"))
+    .order_by_asc(cake::Column::Name)
+    .into_json()
+    .paginate(db, 50);
+
+while let Some(cakes) = cake_pages.fetch_and_next().await? {
+    // 对 cakes: Vec<serde_json::Value> 执行操作
+}
+```
+
+## 从原始 SQL 中选择 JSON
+
+```rust
+let result: Vec<JsonValue> = JsonValue::find_by_statement(Statement::from_sql_and_values(
+        DbBackend::Postgres,
+        r#"SELECT "cake"."name" FROM "cake" GROUP BY "cake"."name"#,
+        [],
+    ))
+    .all(&db)
+    .await?;
+```
+
+## 将 JSON 转换为 ActiveModel
+
+如果你想将用户输入保存到数据库中，你可以轻松地将 JSON 值转换为 `ActiveModel`。你可能希望[跳过反序列化](https://serde.rs/attr-skip-serializing.html)一些不需要的属性。
+
+:::tip 自 `2.0.0` 起
+
+模型的所有字段都不需要存在于 JSON 输入中，未定义的字段将简单地变为 `ActiveValue::NotSet`。
+
+:::
+
+```rust
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel, Serialize, Deserialize)]
+#[sea_orm(table_name = "fruit")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub name: String,
+    pub cake_id: Option<i32>,
+}
+```
+
+使用 `set_from_json` 方法设置 `ActiveModel` 中的属性。
+
+```rust
+// 带有主键的 ActiveModel
+let mut fruit = fruit::ActiveModel {
+    id: ActiveValue::Set(1),
+    name: ActiveValue::NotSet,
+    cake_id: ActiveValue::NotSet,
+};
+
+// 请注意，此方法不会更改 ActiveModel 中的主键值
+fruit.set_from_json(json!({
+    "id": 8,
+    "name": "Apple",
+    "cake_id": 1,
+}))?;
+
+assert_eq!(
+    fruit,
+    fruit::ActiveModel {
+        id: ActiveValue::Set(1),
+        name: ActiveValue::Set("Apple".to_owned()),
+        cake_id: ActiveValue::Set(Some(1)),
+    }
+);
+```
+
+你还可以使用 `from_json` 方法从 JSON 值创建新的 `ActiveModel`。
+
+```rust
+let fruit = fruit::ActiveModel::from_json(json!({
+    "name": "Apple",
+}))?;
+
+assert_eq!(
+    fruit,
+    fruit::ActiveModel {
+        id: ActiveValue::NotSet,
+        name: ActiveValue::Set("Apple".to_owned()),
+        cake_id: ActiveValue::NotSet,
+    }
+);
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/09-raw-sql.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/09-raw-sql.md
new file mode 100644
index 00000000000..158dbcf1e29
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/09-raw-sql.md
@@ -0,0 +1,137 @@
+# 原始 SQL
+
+:::tip 自 `2.0.0` 起
+
+新增了 `raw_sql` 宏，它具有许多简洁的特性，使编写原始 SQL 查询更加符合人体工程学。
+
+特别是，你可以使用 `({..ids})` 将数组扩展为 `(?, ?, ?)`。
+
+在 [SeaQuery 刚刚让编写原始 SQL 变得更加愉快](https://www.sea-ql.org/blog/2025-08-15-sea-query-raw-sql/) 中了解更多。
+
+:::
+
+## 通过原始 SQL 查找模型
+
+```rust
+let id = 1;
+
+let cake: Option<cake::Model> = cake::Entity::find()
+    .from_raw_sql(raw_sql!(
+        Postgres,
+        r#"SELECT "cake"."id", "cake"."name" FROM "cake" WHERE "id" = {id}"#
+    ))
+    .one(&db)
+    .await?;
+```
+
+## 通过原始 SQL 选择到自定义结构体
+
+这里也演示了嵌套选择。
+
+```rust
+#[derive(FromQueryResult)]
+struct Cake {
+    name: String,
+    #[sea_orm(nested)]
+    bakery: Option<Bakery>,
+}
+
+#[derive(FromQueryResult)]
+struct Bakery {
+    #[sea_orm(alias = "bakery_name")]
+    name: String,
+}
+
+let cake_ids = [2, 3, 4];
+
+let cake: Option<Cake> = Cake::find_by_statement(raw_sql!(
+    Sqlite,
+    r#"SELECT "cake"."name", "bakery"."name" AS "bakery_name"
+       FROM "cake"
+       LEFT JOIN "bakery" ON "cake"."bakery_id" = "bakery"."id"
+       WHERE "cake"."id" IN ({..cake_ids})"#
+))
+.one(db)
+.await?;
+```
+
+## 分页原始 SQL 查询
+
+你可以对 [`SelectorRaw`](https://docs.rs/sea-orm/*/sea_orm/struct.SelectorRaw.html) 进行分页并批量获取 `Model`。
+
+```rust
+let ids = vec![1, 2, 3, 4];
+
+let mut cake_pages = cake::Entity::find()
+    .from_raw_sql(raw_sql!(
+        Postgres,
+        r#"SELECT "cake"."id", "cake"."name" FROM "cake" WHERE "id" IN ({..ids})"#
+    ))
+    .paginate(db, 10);
+
+while let Some(cakes) = cake_pages.fetch_and_next().await? {
+    // 对 cakes: Vec<cake::Model> 进行操作
+}
+```
+
+## 从查询中检查原始 SQL
+
+在任何 CRUD 操作上使用 `build` 和 `to_string` 方法来获取特定于数据库的原始 SQL，用于调试目的。
+
+```rust
+use sea_orm::{DbBackend, QueryTrait};
+
+assert_eq!(
+    cake_filling::Entity::find_by_id((6, 8))
+        .build(DbBackend::MySql)
+        .to_string(),
+    [
+        "SELECT `cake_filling`.`cake_id`, `cake_filling`.`filling_id` FROM `cake_filling`",
+        "WHERE `cake_filling`.`cake_id` = 6 AND `cake_filling`.`filling_id` = 8",
+    ].join(" ")
+);
+```
+
+## 使用原始查询和执行接口
+
+你可以使用 `sea-query` 构建 SQL 语句，并直接在 SeaORM 内部的 `DatabaseConnection` 接口上查询/执行它。
+
+### 使用 `query_one` 和 `query_all` 方法获取自定义结果
+
+```rust
+let query_res: Option<QueryResult> = db
+    .query_one_raw(Statement::from_string(
+        DbBackend::MySql,
+        "SELECT * FROM `cake`;",
+    ))
+    .await?;
+let query_res = query_res.unwrap();
+let id: i32 = query_res.try_get("", "id")?;
+
+let query_res_vec: Vec<QueryResult> = db
+    .query_all_raw(Statement::from_string(
+        DbBackend::MySql,
+        "SELECT * FROM `cake`;",
+    ))
+    .await?;
+```
+
+### 使用 `execute` 方法执行查询
+
+```rust
+let exec_res: ExecResult = db
+    .execute(Statement::from_string(
+        DbBackend::MySql,
+        "DROP DATABASE IF EXISTS `sea`;",
+    ))
+    .await?;
+assert_eq!(exec_res.rows_affected(), 1);
+```
+
+## 执行未预处理的 SQL 语句
+
+你可以使用 [`ConnectionTrait::execute_unprepared`](https://docs.rs/sea-orm/*/sea_orm/trait.ConnectionTrait.html#tymethod.execute_unprepared) 执行未预处理的 SQL 语句。
+
+```rust
+let exec_res: ExecResult =
+    db.execute_unprepared("CREATE EXTENSION IF NOT EXISTS citext").await?;
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/_category_.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/_category_.json
new file mode 100644
index 00000000000..14ef5126e1c
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/05-basic-crud/_category_.json
@@ -0,0 +1,4 @@
+{
+  "label": "Basic CRUD",
+  "collapsed": false
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/01-one-to-one.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/01-one-to-one.md
new file mode 100644
index 00000000000..9222702816e
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/01-one-to-one.md
@@ -0,0 +1,118 @@
+# 一对一关系
+
+:::tip Rustacean 贴纸包 🦀
+[我们的贴纸](https://www.sea-ql.org/sticker-pack/) 采用优质防水乙烯基材料制成，具有独特的哑光表面。
+将它们贴在你的笔记本电脑、记事本或任何小工具上，以展示你对 Rust 的热爱！
+:::
+
+一对一关系是最基本的数据库关系类型。假设一个 `Cake` 实体最多有一个 `Fruit` 配料。
+
+## 定义关系
+
+在 `Cake` 实体上，定义关系：
+1. 向 `Relation` 枚举添加一个新的变体 `Fruit`。
+2. 使用 `has_one` 定义它。
+3. 实现 `Related<Entity>` trait。
+
+```rust title="entity/cake.rs"
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_one = "super::fruit::Entity")]
+    Fruit,
+}
+
+impl Related<super::fruit::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Fruit.def()
+    }
+}
+```
+
+<details>
+    <summary>它展开为：</summary>
+
+```rust {3,9,16} title="entity/cake.rs"
+#[derive(Copy, Clone, Debug, EnumIter)]
+pub enum Relation {
+    Fruit,
+}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        match self {
+            Self::Fruit => Entity::has_one(super::fruit::Entity).into(),
+        }
+    }
+}
+
+impl Related<super::fruit::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Fruit.def()
+    }
+}
+```
+</details>
+
+或者，可以使用 `DeriveRelation` 宏缩短定义，
+其中以下内容消除了对上述 `RelationTrait` 实现的需求：
+
+## 定义反向关系
+
+在 `Fruit` 实体上，其 `cake_id` 属性引用 `Cake` 实体的主键。
+
+:::tip
+
+经验法则是，始终在外键 `xxx_id` 的实体上定义 `belongs_to`。
+
+:::
+
+要定义反向关系：
+1. 向 `Fruit` 实体添加一个新的枚举变体 `Relation::Cake`。
+2. 使用 `Entity::belongs_to()` 方法编写其定义，我们始终使用此方法定义反向关系。
+3. 实现 `Related<cake::Entity>` trait。
+
+```rust title="entity/fruit.rs"
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::cake::Entity",
+        from = "Column::CakeId",
+        to = "super::cake::Column::Id"
+    )]
+    Cake,
+}
+
+impl Related<super::cake::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Cake.def()
+    }
+}
+```
+
+<details>
+    <summary>它展开为：</summary>
+
+```rust
+#[derive(Copy, Clone, Debug, EnumIter)]
+pub enum Relation {
+    Cake,
+}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        match self {
+            Self::Cake => Entity::belongs_to(super::cake::Entity)
+                .from(Column::CakeId)
+                .to(super::cake::Column::Id)
+                .into(),
+        }
+    }
+}
+
+impl Related<super::cake::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Cake.def()
+    }
+}
+```
+</details>
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/02-one-to-many.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/02-one-to-many.md
new file mode 100644
index 00000000000..b5469151d9a
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/02-one-to-many.md
@@ -0,0 +1,96 @@
+# 一对多关系
+
+一对多关系类似于一对一关系。在上一节中，我们举例说明了“一个 `Cake` 实体最多有一个 `Fruit` 配料”。为了使其成为一对多关系，我们删除了“最多一个”的约束。因此，我们有一个 `Cake` 实体，它可能有许多 `Fruit` 配料。
+
+## 定义关系
+
+这与定义一对一关系几乎相同；唯一的区别是我们在这里使用 `Entity::has_many()` 方法。
+
+```rust title="entity/cake.rs"
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::fruit::Entity")]
+    Fruit,
+}
+
+impl Related<super::fruit::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Fruit.def()
+    }
+}
+```
+
+<details>
+    <summary>它展开为：</summary>
+
+```rust {3,9,16}
+#[derive(Copy, Clone, Debug, EnumIter)]
+pub enum Relation {
+    Fruit,
+}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        match self {
+            Self::Fruit => Entity::has_many(super::fruit::Entity).into(),
+        }
+    }
+}
+
+impl Related<super::fruit::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Fruit.def()
+    }
+}
+```
+</details>
+
+## 定义反向关系
+
+它与定义一对一反向关系相同。
+
+```rust title="entity/fruit.rs"
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::cake::Entity",
+        from = "Column::CakeId",
+        to = "super::cake::Column::Id"
+    )]
+    Cake,
+}
+
+impl Related<super::cake::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Cake.def()
+    }
+}
+```
+
+<details>
+    <summary>它展开为：</summary>
+
+```rust
+#[derive(Copy, Clone, Debug, EnumIter)]
+pub enum Relation {
+    Cake,
+}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        match self {
+            Self::Cake => Entity::belongs_to(super::cake::Entity)
+                .from(Column::CakeId)
+                .to(super::cake::Column::Id)
+                .into(),
+        }
+    }
+}
+
+impl Related<super::cake::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Cake.def()
+    }
+}
+```
+</details>
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/03-many-to-many.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/03-many-to-many.md
new file mode 100644
index 00000000000..2280e8f5a16
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/03-many-to-many.md
@@ -0,0 +1,132 @@
+# 多对多关系
+
+多对多关系由三张表组成，其中两张表通过一张连接表关联。例如，一个 `Cake` 有许多 `Filling`，而 `Filling` 通过一个中间实体 `CakeFilling` 被许多 `Cake` 共享。
+
+## 定义关系
+
+在 `Cake` 实体上，实现 `Related<filling::Entity>` trait。
+
+SeaORM 中的 `Relation` 是一个箭头：它有 `from` 和 `to`。`cake_filling::Relation::Cake` 定义了 `CakeFilling -> Cake`。调用 [`rev`](https://docs.rs/sea-orm/*/sea_orm/entity/prelude/struct.RelationDef.html#method.rev) 将其反转为 `Cake -> CakeFilling`。
+
+将其与定义 `CakeFilling -> Filling` 的 `cake_filling::Relation::Filling` 链接起来，结果是 `Cake -> CakeFilling -> Filling`。
+
+```rust {4,10} title="entity/cake.rs"
+impl Related<super::filling::Entity> for Entity {
+    // 最终关系是 Cake -> CakeFilling -> Filling
+    fn to() -> RelationDef {
+        super::cake_filling::Relation::Filling.def()
+    }
+
+    fn via() -> Option<RelationDef> {
+        // 原始关系是 CakeFilling -> Cake，
+        // 在 `rev` 之后变为 Cake -> CakeFilling
+        Some(super::cake_filling::Relation::Cake.def().rev())
+    }
+}
+```
+
+类似地，在 `Filling` 实体上，实现 `Related<cake::Entity>` trait。首先，通过 `via` 中间表的 `cake_filling::Relation::Filling` 关系的反向连接，然后通过 `cake_filling::Relation::Cake` 关系连接到 `Cake` 实体。
+
+```rust {3,7} title="entity/filling.rs"
+impl Related<super::cake::Entity> for Entity {
+    fn to() -> RelationDef {
+        super::cake_filling::Relation::Cake.def()
+    }
+
+    fn via() -> Option<RelationDef> {
+        Some(super::cake_filling::Relation::Filling.def().rev())
+    }
+}
+```
+
+## 定义反向关系
+
+在 `CakeFilling` 实体上，其 `cake_id` 属性引用 `Cake` 实体的主键，其 `filling_id` 属性引用 `Filling` 实体的主键。
+
+要定义反向关系：
+1. 向 `Relation` 枚举添加两个新的变体 `Cake` 和 `Filling`。
+2. 使用 `Entity::belongs_to()` 定义这两个关系。
+
+```rust title="entity/cake_filling.rs"
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::cake::Entity",
+        from = "Column::CakeId",
+        to = "super::cake::Column::Id"
+    )]
+    Cake,
+    #[sea_orm(
+        belongs_to = "super::filling::Entity",
+        from = "Column::FillingId",
+        to = "super::filling::Column::Id"
+    )]
+    Filling,
+}
+```
+
+<details>
+    <summary>它展开为：</summary>
+
+```rust
+#[derive(Copy, Clone, Debug, EnumIter)]
+pub enum Relation {
+    Cake,
+    Filling,
+}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        match self {
+            Self::Cake => Entity::belongs_to(super::cake::Entity)
+                .from(Column::CakeId)
+                .to(super::cake::Column::Id)
+                .into(),
+            Self::Filling => Entity::belongs_to(super::filling::Entity)
+                .from(Column::FillingId)
+                .to(super::filling::Column::Id)
+                .into(),
+        }
+    }
+}
+```
+</details>
+
+## 代码生成器的限制
+
+请注意，如果存在通过中间表的多个路径，则不会生成带有 `via` 和 `to` 方法的 `Related` 实现。
+
+例如，在下面定义的模式中，存在两条路径：
++ 路径 1. `users <-> users_votes <-> bills`
++ 路径 2. `users <-> users_saved_bills <-> bills`
+
+因此，不会生成 `Related<R>` 的实现。
+
+```sql
+CREATE TABLE users
+(
+  id uuid  PRIMARY KEY  DEFAULT uuid_generate_v1mc(),
+  email TEXT UNIQUE NOT NULL,
+  ...
+);
+``````sql
+CREATE TABLE bills
+(
+  id uuid  PRIMARY KEY  DEFAULT uuid_generate_v1mc(),
+  ...
+);
+``````sql
+CREATE TABLE users_votes
+(
+  user_id uuid REFERENCES users (id) ON UPDATE CASCADE ON DELETE CASCADE,
+  bill_id uuid REFERENCES bills (id) ON UPDATE CASCADE ON DELETE CASCADE,
+  vote boolean NOT NULL,
+  CONSTRAINT users_bills_pkey PRIMARY KEY (user_id, bill_id)
+);
+``````sql
+CREATE TABLE users_saved_bills
+(
+  user_id uuid REFERENCES users (id) ON UPDATE CASCADE ON DELETE CASCADE,
+  bill_id uuid REFERENCES bills (id) ON UPDATE CASCADE ON DELETE CASCADE,
+  CONSTRAINT users_saved_bills_pkey PRIMARY KEY (user_id, bill_id)
+);
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/04-complex-relations.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/04-complex-relations.md
new file mode 100644
index 00000000000..7af09a7384d
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/04-complex-relations.md
@@ -0,0 +1,193 @@
+# 复杂关系
+
+## 链接
+
+`Related` trait 是我们在实体关系图上绘制的箭头（1-1、1-N、M-N）的表示。[`Linked`](https://docs.rs/sea-orm/*/sea_orm/entity/trait.Linked.html) 由关系链组成，在以下情况下很有用：
+
+1. 一对实体之间存在多个连接路径，导致无法实现 `Related`
+2. 在关系查询中跨多个实体进行连接
+
+实现 `Linked` trait 是完全可选的，因为 SeaORM 中还有其他进行关系查询的方法，这将在后面的章节中解释。
+实现 `Linked` 后，可以使用多个 `find_*_linked` 辅助方法，并且可以在一个地方定义关系。
+
+### 定义链接
+
+以 [此](https://github.com/SeaQL/sea-orm/blob/1.1.x/src/tests_cfg/entity_linked.rs) 为例，我们通过中间 `cake_filling` 表连接蛋糕和馅料。
+
+```rust title="entity/links.rs"
+pub struct CakeToFilling;
+
+impl Linked for CakeToFilling {
+    type FromEntity = cake::Entity;
+
+    type ToEntity = filling::Entity;
+
+    fn link(&self) -> Vec<RelationDef> {
+        vec![
+            cake_filling::Relation::Cake.def().rev(),
+            cake_filling::Relation::Filling.def(),
+        ]
+    }
+}
+```
+
+或者，`RelationDef` 可以在运行时定义，以下内容与上述内容等效：
+
+```rust
+pub struct CakeToFilling;
+
+impl Linked for CakeToFilling {
+    type FromEntity = cake::Entity;
+
+    type ToEntity = filling::Entity;
+
+    fn link(&self) -> Vec<RelationDef> {
+        vec![
+            cake_filling::Relation::Cake.def().rev(),
+            cake_filling::Entity::belongs_to(filling::Entity)
+                .from(cake_filling::Column::FillingId)
+                .to(filling::Column::Id)
+                .into(),
+        ]
+    }
+}
+```
+
+### 延迟加载
+
+使用 [`find_linked`](https://docs.rs/sea-orm/*/sea_orm/entity/prelude/trait.ModelTrait.html#method.find_linked) 方法查找可以填充到蛋糕中的馅料。
+
+```rust
+let cake_model = cake::Model {
+    id: 12,
+    name: "".to_owned(),
+};
+
+assert_eq!(
+    cake_model
+        .find_linked(cake::CakeToFilling)
+        .build(DbBackend::MySql)
+        .to_string(),
+    [
+        "SELECT `filling`.`id`, `filling`.`name`, `filling`.`vendor_id`",
+        "FROM `filling`",
+        "INNER JOIN `cake_filling` AS `r0` ON `r0`.`filling_id` = `filling`.`id`",
+        "INNER JOIN `cake` AS `r1` ON `r1`.`id` = `r0`.`cake_id`",
+        "WHERE `r1`.`id` = 12",
+    ]
+    .join(" ")
+);
+```
+
+### 急切加载
+
+[`find_also_linked`](https://docs.rs/sea-orm/*/sea_orm/entity/prelude/struct.Select.html#method.find_also_linked) 是 `find_also_related` 的对偶；[`find_with_linked`](https://docs.rs/sea-orm/*/sea_orm/entity/prelude/struct.Select.html#method.find_with_linked) 是 `find_with_related` 的对偶；：
+
+```rust
+assert_eq!(
+    cake::Entity::find()
+        .find_also_linked(links::CakeToFilling)
+        .build(DbBackend::MySql)
+        .to_string(),
+    [
+        r#"SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,"#,
+        r#"`r1`.`id` AS `B_id`, `r1`.`name` AS `B_name`, `r1`.`vendor_id` AS `B_vendor_id`"#,
+        r#"FROM `cake`"#,
+        r#"LEFT JOIN `cake_filling` AS `r0` ON `cake`.`id` = `r0`.`cake_id`"#,
+        r#"LEFT JOIN `filling` AS `r1` ON `r0`.`filling_id` = `r1`.`id`"#,
+    ]
+    .join(" ")
+);
+```
+
+## 自引用关系
+
+`Link` trait 也可以定义自引用关系。
+
+以下示例定义了一个引用自身的实体。
+
+```rust
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "self_join")]
+pub struct Model {
+    #[sea_orm(primary_key, auto_increment = false)]
+    pub uuid: Uuid,
+    pub uuid_ref: Option<Uuid>,
+    pub time: Option<Time>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(belongs_to = "Entity", from = "Column::UuidRef", to = "Column::Uuid")]
+    SelfReferencing,
+}
+
+pub struct SelfReferencingLink;
+
+impl Linked for SelfReferencingLink {
+    type FromEntity = Entity;
+
+    type ToEntity = Entity;
+
+    fn link(&self) -> Vec<RelationDef> {
+        vec![Relation::SelfReferencing.def()]
+    }
+}
+```
+
+## 菱形关系
+
+有时一对实体之间存在多个关系。这里我们举一个最简单的例子，`Cake` 可以有多个 `Fruit`。
+
+```rust
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "cake")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub name: String,
+    pub topping: i32,
+    pub filling: i32,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::fruit::Entity",
+        from = "Column::Topping",
+        to = "super::fruit::Column::Id"
+    )]
+    Topping,
+    #[sea_orm(
+        belongs_to = "super::fruit::Entity",
+        from = "Column::Filling",
+        to = "super::fruit::Column::Id"
+    )]
+    Filling,
+}
+```
+
+我们如何定义 `Fruit` 实体？
+默认情况下，`has_many` 调用 `Related` trait 来定义关系。
+因此，在没有 `Related` 实现的情况下无法定义关系。
+
+这里我们必须使用 `via` 属性手动指定关系变体。
+
+```rust
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "fruit")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub name: String,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::cake::Entity", via = "Relation::Topping")]
+    CakeTopping,
+    #[sea_orm(has_many = "super::cake::Entity", via = "Relation::Filling")]
+    CakeFilling,
+}
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/06-custom-join-condition.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/06-custom-join-condition.md
new file mode 100644
index 00000000000..158a8b0b845
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/06-custom-join-condition.md
@@ -0,0 +1,235 @@
+# 自定义连接条件
+
+有时你可能希望使用自定义条件连接到另一个表，例如：
+
+```sql
+SELECT
+    `cake`.`id`,
+    `cake`.`name`
+FROM
+    `cake`
+    LEFT JOIN `fruit` ON `cake`.`id` = `fruit`.`cake_id`
+    AND `fruit`.`name` LIKE '%tropical%' -- 自定义连接条件
+```
+
+这可以通过几种方式完成。
+
+## 关系
+
+将你的附加连接条件直接添加到关系枚举中。最简单的方法是通过 `on_condition` 过程宏属性提供 `sea_query::SimpleExpr`。
+
+```rust
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::fruit::Entity")]
+    Fruit,
+    #[sea_orm(
+        has_many = "super::fruit::Entity",
+        // 附加的 on_condition，接受任何实现 `sea_query::IntoCondition` 的内容
+        on_condition = r#"super::fruit::Column::Name.like("%tropical%")"#
+    )]
+    TropicalFruit,
+}```
+
+上面的过程宏将扩展为：
+
+```rust
+#[derive(Copy, Clone, Debug, EnumIter)]
+pub enum Relation {
+    Fruit,
+    TropicalFruit,
+}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        match self {
+            Self::Fruit => Entity::has_many(super::fruit::Entity).into(),
+            Self::TropicalFruit => Entity::has_many(super::fruit::Entity)
+                .on_condition(|_left, _right| {
+                    super::fruit::Column::Name.like("%tropical%")
+                        .into_condition()
+                })
+                .into(),
+        }
+    }
+}
+```
+
+生成的 SQL 将是：
+
+```rust
+assert_eq!(
+    cake::Entity::find()
+        .join(JoinType::LeftJoin, cake::Relation::TropicalFruit.def())
+        .build(DbBackend::MySql)
+        .to_string(),
+    [
+        "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
+        "LEFT JOIN `fruit` ON `cake`.`id` = `fruit`.`cake_id` AND `fruit`.`name` LIKE '%tropical%'",
+    ]
+    .join(" ")
+);
+```
+
+## 链接
+
+你还可以在 `Linked` 上定义自定义连接条件。
+
+```rust
+#[derive(Debug)]
+pub struct CheeseCakeToFillingVendor;
+
+impl Linked for CheeseCakeToFillingVendor {
+    type FromEntity = super::cake::Entity;
+
+    type ToEntity = super::vendor::Entity;
+
+    fn link(&self) -> Vec<RelationDef> {
+        vec![
+            super::cake_filling::Relation::Cake
+                .def()
+                // `on_condition` 方法接受一个闭包，其参数表示连接表达式中的左侧和右侧表。
+                .on_condition(|left, _right| {
+                    Expr::col((left, super::cake::Column::Name))
+                        .like("%cheese%")
+                        .into_condition()
+                })
+                .rev(),
+            super::cake_filling::Relation::Filling.def(),
+            super::filling::Relation::Vendor.def(),
+        ]
+    }
+}
+```
+
+生成的 SQL 将是：
+
+```rust
+assert_eq!(
+    cake::Entity::find()
+        .find_also_linked(entity_linked::CheeseCakeToFillingVendor)
+        .build(DbBackend::MySql)
+        .to_string(),
+    [
+        r#"SELECT `cake`.`id` AS `A_id`, `cake`.`name` AS `A_name`,"#,
+        r#"`r2`.`id` AS `B_id`, `r2`.`name` AS `B_name`"#,
+        r#"FROM `cake`"#,
+        r#"LEFT JOIN `cake_filling` AS `r0` ON `cake`.`id` = `r0`.`cake_id` AND `cake`.`name` LIKE '%cheese%'"#,
+        r#"LEFT JOIN `filling` AS `r1` ON `r0`.`filling_id` = `r1`.`id`"#,
+        r#"LEFT JOIN `vendor` AS `r2` ON `r1`.`vendor_id` = `r2`.`id`"#,
+    ]
+    .join(" ")
+);
+```
+
+## 动态
+
+最后，可以在构建连接表达式时定义自定义连接条件。
+
+```rust
+assert_eq!(
+    cake::Entity::find()
+        .join(JoinType::LeftJoin, cake::Relation::TropicalFruit.def())
+        .join(
+            JoinType::LeftJoin,
+            cake_filling::Relation::Cake
+                .def()
+                .rev()
+                .on_condition(|_left, right| {
+                    Expr::col((right, cake_filling::Column::CakeId))
+                        .gt(10)
+                        .into_condition()
+                })
+        )
+        .join(
+            JoinType::LeftJoin,
+            cake_filling::Relation::Filling
+                .def()
+                .on_condition(|_left, right| {
+                    Expr::col((right, filling::Column::Name))
+                        .like("%lemon%")
+                        .into_condition()
+                })
+        )
+        .join(JoinType::LeftJoin, filling::Relation::Vendor.def())
+        .build(DbBackend::MySql)
+        .to_string(),
+    [
+        "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
+        "LEFT JOIN `fruit` ON `cake`.`id` = `fruit`.`cake_id` AND `fruit`.`name` LIKE '%tropical%'",
+        "LEFT JOIN `cake_filling` ON `cake`.`id` = `cake_filling`.`cake_id` AND `cake_filling`.`cake_id` > 10",
+        "LEFT JOIN `filling` ON `cake_filling`.`filling_id` = `filling`.`id` AND `filling`.`name` LIKE '%lemon%'",
+        "LEFT JOIN `vendor` ON `filling`.`vendor_id` = `vendor`.`id`",
+    ]
+    .join(" ")
+);
+```
+
+你可以在连接语句中指定表别名：
+
+```rust
+let cf = "cf";
+
+assert_eq!(
+    cake::Entity::find()
+        .join_as(
+            JoinType::LeftJoin,
+            cake_filling::Relation::Cake.def().rev(),
+            cf.clone()
+        )
+        .join(
+            JoinType::LeftJoin,
+            cake_filling::Relation::Filling.def().from_alias(cf)
+        )
+        .build(DbBackend::MySql)
+        .to_string(),
+    [
+        "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
+        "LEFT JOIN `cake_filling` AS `cf` ON `cake`.`id` = `cf`.`cake_id`",
+        "LEFT JOIN `filling` ON `cf`.`filling_id` = `filling`.`id`",
+    ]
+    .join(" ")
+);```
+
+## `OR` 条件
+
+```rust {6}
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        has_many = "super::fruit::Entity",
+        on_condition = r#"super::fruit::Column::Name.like("%tropical%")"#
+        condition_type = "any",
+    )]
+    OrTropicalFruit,
+}```
+
+```rust {7,12}
+assert_eq!(
+    cake::Entity::find()
+        .column_as(
+            Expr::col(("cake_filling_alias", cake_filling::Column::CakeId)),
+            "cake_filling_cake_id"
+        )
+        .join(JoinType::LeftJoin, cake::Relation::OrTropicalFruit.def())
+        .join_as_rev(
+            JoinType::LeftJoin,
+            cake_filling::Relation::Cake
+                .def()
+                .condition_type(ConditionType::Any)
+                .on_condition(|left, _right| {
+                    Expr::col((left, cake_filling::Column::CakeId))
+                        .gt(10)
+                        .into_condition()
+                }),
+            "cake_filling_alias"
+        )
+        .build(DbBackend::MySql)
+        .to_string(),
+    [
+        "SELECT `cake`.`id`, `cake`.`name`, `cake_filling_alias`.`cake_id` AS `cake_filling_cake_id` FROM `cake`",
+        "LEFT JOIN `fruit` ON `cake`.`id` = `fruit`.`cake_id` OR `fruit`.`name` LIKE '%tropical%'",
+        "LEFT JOIN `cake_filling` AS `cake_filling_alias` ON `cake_filling_alias`.`cake_id` = `cake`.`id` OR `cake_filling_alias`.`cake_id` > 10",
+    ]
+    .join(" ")
+);
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/07-data-loader.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/07-data-loader.md
new file mode 100644
index 00000000000..3124ef7a95d
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/07-data-loader.md
@@ -0,0 +1,59 @@
+# 数据加载器
+
+[LoaderTrait](https://docs.rs/sea-orm/*/sea_orm/query/trait.LoaderTrait.html) 提供了一个 API，用于批量加载相关实体。
+
+考虑以下一对多关系：
+
+```rust
+let cake_with_fruits: Vec<(cake::Model, Vec<fruit::Model>)> = Cake::find()
+    .find_with_related(Fruit)
+    .all(db)
+    .await?;
+```
+
+生成的 SQL 查询是：
+
+```sql
+SELECT
+    "cake"."id" AS "A_id",
+    "cake"."name" AS "A_name",
+    "fruit"."id" AS "B_id",
+    "fruit"."name" AS "B_name",
+    "fruit"."cake_id" AS "B_cake_id"
+FROM "cake"
+LEFT JOIN "fruit" ON "cake"."id" = "fruit"."cake_id"
+ORDER BY "cake"."id" ASC
+```
+
+这很好，但是如果 N 是一个很大的数字，1 端（Cake）的数据会被大量复制。这会导致更多数据通过网络传输。在多对多关系中，两端都可能重复。使用数据加载器将确保每个模型只传输一次。
+
+以下加载与上述相同的数据，但使用两个查询：
+
+```rust
+let cakes: Vec<cake::Model> = Cake::find().all(db).await?;
+let fruits: Vec<Vec<fruit::Model>> = cakes.load_many(Fruit, db).await?;
+
+for (cake, fruits) in cakes.into_iter().zip(fruits.into_iter()) { .. }
+```
+
+```sql
+SELECT "cake"."id", "cake"."name" FROM "cake"
+SELECT "fruit"."id", "fruit"."name", "fruit"."cake_id" FROM "fruit" WHERE "fruit"."cake_id" IN (..)
+```
+
+你可以将它们堆叠在一起：
+
+```rust
+let cakes: Vec<cake::Model> = Cake::find().all(db).await?;
+let fruits: Vec<Vec<fruit::Model>> = cakes.load_many(Fruit, db).await?;
+let fillings: Vec<Vec<filling::Model>> = cakes.load_many_to_many(Filling, CakeFilling, db).await?;
+```
+
+在高级用例中，你可以对相关实体应用过滤器：
+
+```rust
+let fruits_in_stock: Vec<Vec<fruit::Model>> = cakes.load_many(
+    fruit::Entity::find().filter(fruit::Column::Stock.gt(0i32)),
+    db
+).await?;
+```
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/08-bakery-schema.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/08-bakery-schema.md
new file mode 100644
index 00000000000..386fd726388
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/08-bakery-schema.md
@@ -0,0 +1,5 @@
+# 面包店模式
+
+![面包店模式 ERD](https://raw.githubusercontent.com/SeaQL/sea-orm/master/tests/common/bakery_chain/bakery_chain_erd.svg)
+
+有关包含不同数据类型和关系的更复杂模式的示例，你可以参考 SeaORM 测试套件的[面包店模式](https://github.com/SeaQL/sea-orm/tree/master/tests/common/bakery_chain)。这些实体将在下一章中引用。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/09-nested-selects.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/09-nested-selects.md
new file mode 100644
index 00000000000..fe7a43b62e7
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/09-nested-selects.md
@@ -0,0 +1,375 @@
+# 嵌套查询
+
+`FromQueryResult` 和 `DerivePartialModel` 宏允许你轻松地嵌套对象，从而简化复杂查询的构建。
+
+## 嵌套 FromQueryResult
+
+作为一个简单的第一个例子，我们想选择带有 `Bakery` 的 `Cake`：
+
+```rust
+#[derive(FromQueryResult)]
+struct Cake {
+    id: i32,
+    name: String,
+    #[sea_orm(nested)]
+    bakery: Option<Bakery>,
+}
+
+#[derive(FromQueryResult)]
+struct Bakery {
+    #[sea_orm(alias = "bakery_id")]
+    id: i32,
+    #[sea_orm(alias = "bakery_name")]
+    brand: String,
+}
+
+let cake: Cake = cake::Entity::find()
+    .select_only()
+    .column(cake::Column::Id)
+    .column(cake::Column::Name)
+    .column_as(bakery::Column::Id, "bakery_id")
+    .column_as(bakery::Column::Name, "bakery_name")
+    .left_join(bakery::Entity)
+    .order_by_asc(cake::Column::Id)
+    .into_model()
+    .one(db)
+    .await?
+    .unwrap();
+
+assert_eq!(
+    cake,
+    Cake {
+        id: 1,
+        name: "Basque cheesecake".to_string(),
+        bakery: Some(Bakery {
+            id: 20,
+            brand: "Super Baker".to_string(),
+        })
+    }
+);
+```
+
+因为 `cake` 和 `bakery` 表有一些重复的列名，我们必须进行自定义选择。这里的 `select_only` 清除了默认的选择列表，我们使用 [`column_as`](https://docs.rs/sea-orm/latest/sea_orm/query/trait.QuerySelect.html#method.column_as) 应用别名。然后，在 `FromQueryResult` 中，我们使用 `alias` 将查询结果映射回嵌套结构。
+
+## 嵌套模型
+
+[`DerivePartialModel`](https://docs.rs/sea-orm/latest/sea_orm/derive.DerivePartialModel.html) 允许你省略自定义选择和别名。前面的例子可以写成：
+```rust
+#[derive(DerivePartialModel)]
+#[sea_orm(entity = "cake::Entity")]
+struct Cake {
+    id: i32,
+    name: String,
+    #[sea_orm(nested)]
+    bakery: Option<Bakery>,
+}
+
+#[derive(DerivePartialModel)]
+#[sea_orm(entity = "bakery::Entity")]
+struct Bakery {
+    id: i32,
+    #[sea_orm(from_col = "Name")]
+    brand: String,
+}
+
+// 与前面的例子相同，但没有自定义选择
+let cake: Cake = cake::Entity::find()
+    .left_join(bakery::Entity)
+    .order_by_asc(cake::Column::Id)
+    .into_partial_model()
+    .one(db)
+    .await?
+    .unwrap();
+```
+
+在底层，`bakery_` 前缀将被添加到 SQL 查询中的列别名。
+
+```sql
+SELECT
+    "cake"."id" AS "id",
+    "cake"."name" AS "name",
+    "bakery"."id" AS "bakery_id",
+    "bakery"."name" AS "bakery_brand"
+FROM "cake"
+LEFT JOIN "bakery" ON "cake"."bakery_id" = "bakery"."id"
+ORDER BY "cake"."id" ASC LIMIT 1
+```
+
+### 常规模型可以嵌套！
+
+:::tip 自 `2.0.0` 版本起
+:::
+
+所以前面的例子也可以是：
+
+```rust
+#[derive(DerivePartialModel)]
+#[sea_orm(entity = "cake::Entity")]
+struct Cake {
+    id: i32,
+    name: String,
+    #[sea_orm(nested)]
+    bakery: Option<bakery::Model>, // <- 一个常规的完整模型
+}
+```
+
+其中选择了嵌套模型的所有列。
+
+### 带别名的连接
+
+当同一个表在同一个查询中多次连接时，需要使用别名。你可以使用 `alias` 属性从别名中选择列。
+
+```rust
+#[derive(DerivePartialModel)]
+#[sea_orm(entity = "cake::Entity")]
+struct CakeFactory {
+    id: i32,
+    name: String,
+    #[sea_orm(nested, alias = "factory")]
+    bakery: Option<Factory>,
+}
+
+#[derive(DerivePartialModel)]
+#[sea_orm(entity = "bakery::Entity")]
+struct Factory {
+    id: i32,
+    #[sea_orm(from_col = "name")]
+    plant: String,
+}
+
+let cake_factory: CakeFactory = cake::Entity::find()
+    .join_as(
+        JoinType::LeftJoin,
+        cake::Relation::Bakery.def(),
+        "factory",
+    )
+    .order_by_asc(cake::Column::Id)
+    .into_partial_model()
+    .one(db)
+    .await?
+    .unwrap();
+```
+
+结果是：
+
+```sql
+SELECT
+    "cake"."id" AS "id",
+    "cake"."name" AS "name",
+    "factory"."id" AS "bakery_id",
+    "factory"."name" AS "bakery_plant"
+FROM "cake"
+LEFT JOIN "bakery" AS "factory" ON "cake"."bakery_id" = "factory"."id"
+ORDER BY "cake"."id" ASC LIMIT 1
+```
+
+:::tip
+
+你可以通过两个关系将同一个实体连接两次，并在同一个查询中为它们设置不同的别名。
+
+```rust
+#[derive(DerivePartialModel)]
+#[sea_orm(entity = "bakery::Entity")]
+struct Bakery {
+    name: String,
+    #[sea_orm(nested, alias = "manager")]
+    manager: Worker,
+    #[sea_orm(nested, alias = "cashier")]
+    cashier: Worker,
+}
+
+let bakery: Bakery = bakery::Entity::find()
+    .join_as(
+        sea_orm::JoinType::LeftJoin,
+        bakery::Relation::Manager.def(),
+        "manager",
+    )
+    .join_as(
+        sea_orm::JoinType::LeftJoin,
+        bakery::Relation::Cashier.def(),
+        "cashier",
+    )
+    ..
+```
+
+:::
+
+## 三向连接
+
+我们的连接计划从 Order 开始：
+
+```rust
+Order -> Customer
+      -> LineItem -> Cake
+```
+
+```rust
+#[derive(Debug, DerivePartialModel, PartialEq)]
+#[sea_orm(entity = "order::Entity")]
+struct Order {
+    id: i32,
+    total: Decimal,
+    #[sea_orm(nested)]
+    customer: Customer,
+    #[sea_orm(nested)]
+    line: LineItem,
+}
+
+#[derive(Debug, DerivePartialModel, PartialEq)]
+#[sea_orm(entity = "customer::Entity")]
+struct Customer {
+    name: String,
+}
+
+#[derive(Debug, DerivePartialModel, PartialEq)]
+#[sea_orm(entity = "lineitem::Entity")]
+struct LineItem {
+    price: Decimal,
+    quantity: i32,
+    #[sea_orm(nested)]
+    cake: Cake,
+}
+
+#[derive(Debug, DerivePartialModel, PartialEq)]
+#[sea_orm(entity = "cake::Entity")]
+struct Cake {
+    name: String,
+}
+
+let items: Vec<Order> = order::Entity::find()
+    .left_join(customer::Entity)
+    .left_join(lineitem::Entity)
+    .join(JoinType::LeftJoin, lineitem::Relation::Cake.def())
+    .order_by_asc(order::Column::Id)
+    .order_by_asc(lineitem::Column::Id)
+    .into_partial_model()
+    .all(db)
+    .await?;
+
+assert_eq!(
+    items,
+    [
+        Order {
+            id: 101,
+            total: Decimal::from(10),
+            customer: Customer {
+                name: "Bob".to_owned()
+            },
+            line: LineItem {
+                cake: Cake {
+                    name: "Cheesecake".to_owned()
+                },
+                price: Decimal::from(2),
+                quantity: 2,
+            }
+        },
+        ..
+    ]
+);
+```
+
+由于 Cake 是 LineItem 的相关实体，而不是 Order 的相关实体，因此它不满足 `left_join` 的 trait 约束。因此，有必要使用更灵活的 `join` 方法。
+
+### 替代结构
+
+在上面，我们使嵌套结构类似于连接计划的拓扑。但没有限制。实际上，SQL 将选择展平为一个平面表，因此只要能找到所有列，我们就可以自由地安排结果数据结构。
+
+```rust
+#[derive(Debug, DerivePartialModel, PartialEq)]
+#[sea_orm(entity = "order::Entity")]
+struct OrderItem {
+    #[sea_orm(nested)]
+    order: Order,
+    #[sea_orm(nested)]
+    customer: Customer,
+    #[sea_orm(nested)]
+    line: LineItem,
+    #[sea_orm(nested)]
+    cake: Cake,
+}
+
+#[derive(Debug, DerivePartialModel, PartialEq)]
+#[sea_orm(entity = "order::Entity")]
+struct Order {
+    #[sea_orm(from_col = "id")]
+    order_id: i32,
+    total: Decimal,
+}
+
+#[derive(Debug, DerivePartialModel, PartialEq)]
+#[sea_orm(entity = "customer::Entity")]
+struct Customer {
+    name: String,
+}
+
+#[derive(Debug, DerivePartialModel, PartialEq)]
+#[sea_orm(entity = "lineitem::Entity")]
+struct LineItem {
+    price: Decimal,
+    quantity: i32,
+}
+
+#[derive(Debug, DerivePartialModel, PartialEq)]
+#[sea_orm(entity = "cake::Entity")]
+struct Cake {
+    name: String,
+}
+
+// 完全相同的选择查询
+
+assert_eq!(
+    items,
+    [
+        OrderItem {
+            order: Order {
+                order_id: 101,
+                total: Decimal::from(10),
+            },
+            customer: Customer {
+                name: "Bob".to_owned()
+            },
+            line: LineItem {
+                price: Decimal::from(2),
+                quantity: 2,
+            },
+            cake: Cake {
+                name: "Cheesecake".to_owned()
+            },
+        },
+        ..
+    ]
+);
+```
+
+## 三模型选择
+
+```rust
+Order -> Lineitem -> Cake
+```
+
+```rust
+let items: Vec<(order::Model, Option<lineitem::Model>, Option<cake::Model>)> =
+    order::Entity::find()
+        .find_also_related(lineitem::Entity)
+        .and_also_related(cake::Entity)
+        .order_by_asc(order::Column::Id)
+        .order_by_asc(lineitem::Column::Id)
+        .all(db)
+        .await?;
+```
+
+`find_also_related` 基于第一个实体的关系。
+`and_also_related` 基于第二个实体的关系。
+
+要改为这样做，你可以这样写：
+
+```rust
+Order -> Customer
+      -> LineItem
+```
+
+```rust
+order::Entity::find()
+    .find_also_related(customer::Entity)
+    .find_also_related(lineitem::Entity)
+```
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/_category_.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/_category_.json
new file mode 100644
index 00000000000..e8bf4c2e029
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/06-relation/_category_.json
@@ -0,0 +1,4 @@
+{
+  "label": "关系",
+  "collapsed": false
+}
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/07-write-test/01-testing.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/07-write-test/01-testing.md
new file mode 100644
index 00000000000..3295884c61d
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/07-write-test/01-testing.md
@@ -0,0 +1,64 @@
+# 健壮与正确
+
+测试是 Rust 编程不可或缺的一部分。[`cargo test`](https://doc.rust-lang.org/cargo/commands/cargo-test.html) 是内置的。
+
+如果你不使用 `unsafe` 并且你的代码能够编译，那么你的 Rust 程序是 *安全* 的。然而，它并不会自动变得 *健壮*。如果你在错误处理上不够小心，你的程序仍然可能意外崩溃。
+
+即使你的程序没有崩溃，也并不意味着它是 *正确* 的。它仍然可能出现异常行为并导致数据混乱。
+
+你可以通过编写足够的测试来提高程序的正确性。
+
+## 错误类型
+
+首先，让我们对数据驱动应用程序中不同错误原因进行分类：
+
+### 1. 类型错误
+
+1. 拼写错误或不存在的符号（表或列）名称
+1. 对数据使用不兼容的函数或运算符（例如，添加两个字符串）
+1. 无效的 SQL 查询
+	- 例如，`JOIN` 查询中存在歧义符号
+	- 例如，忘记在非空列中插入数据
+	- 例如，忘记在 `GROUP BY` 查询中聚合所有列
+
+### 2. 事务错误
+
+1. 未能维护实体关系
+1. 未能维护数据一致性和约束
+
+### 3. 行为错误
+
+1. 在错误的条件下进行连接或过滤
+1. 不完整或不正确的查询结果
+1. 插入、更新或删除操作产生未知的副作用
+1. 任何其他不符合预期的行为
+
+> 关于“未知副作用”的说明：除非关系严格为父子关系，否则不要使用 `CASCADE`
+
+## 缓解措施
+
+现在，让我们看看如何缓解这些错误：
+
+### 1. 类型错误
+
+使用 Rust 可以自动避免拼写错误。
+
+使用 *完全静态* 的查询构建器可以消除所有此类错误。然而，它要求每个参数都在编译时静态定义并可用。这是一个 *严苛* 的要求，因为总有一些东西是你直到程序启动（环境变量）和运行（运行时配置更改）后才能知道的。如果你来自类型系统一直是动态的脚本语言背景，这会特别尴尬。
+
+因此，SeaORM 不会尝试在编译时检查这些问题。我们打算（仍在开发中）针对动态生成的查询提供运行时 linting，以解决上述问题，你可以在单元测试中启用它，但在生产环境中禁用。
+
+### 2. 事务错误
+
+这些问题无法消除。它通常表明你的代码存在一些逻辑错误。当它们发生时，为时已晚，你唯一的选择是中止。相反，必须积极预防它们：在尝试数据操作之前，预先检查约束。
+
+你应该编写大量的单元测试，以拒绝不良数据并防止其进入数据库。你的单元测试还应该验证每个 *事务*（在你的应用程序领域，不一定是数据库事务）都是健全的。
+
+SeaORM 帮助你使用 `Mock` 数据库接口编写这些单元测试。
+
+### 3. 行为错误
+
+这基本上是在领域层面测试你的整个程序，要求你提供种子数据并模拟常见的用户操作。通常，你会在 CI 中针对真实数据库进行此操作。然而，SeaORM 鼓励你缩小这些测试的范围，以便最重要的数据流可以通过 Cargo 的[集成测试](https://doc.rust-lang.org/rust-by-example/testing/integration_testing.html)进行测试。
+
+由于 SeaORM 抽象了 MySQL、PostgreSQL 和 SQLite，你可以使用 SQLite 作为后端来测试程序的行为。它足够轻量，可以在本地和 CI 上频繁运行。问题是，SQLite 缺少 MySQL 或 PostgreSQL 的一些高级功能，因此根据你对数据库特定功能的使用情况，并非所有逻辑都可以在 SQLite 中进行测试。
+
+我们正在寻找可以模拟 MySQL 和 PostgreSQL 更高级功能的 SQLite 替代方案。
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/07-write-test/02-mock.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/07-write-test/02-mock.md
new file mode 100644
index 00000000000..d0d3599e30b
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/07-write-test/02-mock.md
@@ -0,0 +1,217 @@
+# 模拟接口
+
+你可以使用模拟数据库接口对应用程序逻辑进行单元测试。
+
+:::info
+你需要在 `Cargo.toml` 中启用 `mock` 功能标志。
+:::
+
+模拟数据库中没有任何数据，因此你必须定义在执行 CRUD 操作时要返回的预期数据。
+- 应提供查询结果以支持选择操作
+- 应提供执行结果以支持插入、更新和删除操作
+
+为确保应用程序逻辑的正确性，你还可以验证模拟数据库中的事务日志。
+
+在此处查看我们如何使用模拟连接编写单元测试[此处](https://github.com/SeaQL/sea-orm/blob/master/src/executor/paginator.rs#L250)。
+
+## 模拟查询结果
+
+我们使用 `MockDatabase::new(DatabaseBackend::Postgres)` 为 PostgreSQL 创建一个模拟数据库。然后，使用 `append_query_results` 方法准备查询结果。请注意，我们向其传递一个向量的向量，表示多个查询结果，每个结果都有多个模型。最后，我们将其转换为连接，并像正常的实时连接一样使用它来执行 CRUD 操作。
+
+关于 `MockDatabase` 的一件特别之处是你可以检查其事务日志。在模拟数据库上运行的任何 SQL 查询都将被记录下来；你可以验证每个日志以确保应用程序逻辑的正确性。
+
+```rust
+#[cfg(test)]
+mod tests {
+    use sea_orm::{
+        entity::prelude::*, entity::*, tests_cfg::*,
+        DatabaseBackend, MockDatabase, Transaction,
+    };
+
+    #[async_std::test]
+    async fn test_find_cake() -> Result<(), DbErr> {
+        // 使用模拟查询结果创建 MockDatabase
+        let db = MockDatabase::new(DatabaseBackend::Postgres)
+            .append_query_results([
+                // 第一个查询结果
+                vec![cake::Model {
+                    id: 1,
+                    name: "New York Cheese".to_owned(),
+                }],
+                // 第二个查询结果
+                vec![
+                    cake::Model {
+                        id: 1,
+                        name: "New York Cheese".to_owned(),
+                    },
+                    cake::Model {
+                        id: 2,
+                        name: "Chocolate Forest".to_owned(),
+                    },
+                ],
+            ])
+            .append_query_results([
+                // 第三个查询结果
+                [(
+                    cake::Model {
+                        id: 1,
+                        name: "Apple Cake".to_owned(),
+                    },
+                    fruit::Model {
+                        id: 2,
+                        name: "Apple".to_owned(),
+                        cake_id: Some(1),
+                    },
+                )],
+            ])
+            .into_connection();
+
+        // 从 MockDatabase 中查找蛋糕
+        // 返回第一个查询结果
+        assert_eq!(
+            cake::Entity::find().one(&db).await?,
+            Some(cake::Model {
+                id: 1,
+                name: "New York Cheese".to_owned(),
+            })
+        );
+
+        // 从 MockDatabase 中查找所有蛋糕
+        // 返回第二个查询结果
+        assert_eq!(
+            cake::Entity::find().all(&db).await?,
+            [
+                cake::Model {
+                    id: 1,
+                    name: "New York Cheese".to_owned(),
+                },
+                cake::Model {
+                    id: 2,
+                    name: "Chocolate Forest".to_owned(),
+                },
+            ]
+        );
+
+        // 查找所有蛋糕及其相关水果
+        assert_eq!(
+            cake::Entity::find()
+                .find_also_related(fruit::Entity)
+                .all(&db)
+                .await?,
+            [(
+                cake::Model {
+                    id: 1,
+                    name: "Apple Cake".to_owned(),
+                },
+                Some(fruit::Model {
+                    id: 2,
+                    name: "Apple".to_owned(),
+                    cake_id: Some(1),
+                })
+            )]
+        );
+
+        // 检查事务日志
+        assert_eq!(
+            db.into_transaction_log(),
+            [
+                Transaction::from_sql_and_values(
+                    DatabaseBackend::Postgres,
+                    r#"SELECT "cake"."id", "cake"."name" FROM "cake" LIMIT $1"#,
+                    [1u64.into()]
+                ),
+                Transaction::from_sql_and_values(
+                    DatabaseBackend::Postgres,
+                    r#"SELECT "cake"."id", "cake"."name" FROM "cake""#,
+                    []
+                ),
+                Transaction::from_sql_and_values(
+                    DatabaseBackend::Postgres,
+                    r#"SELECT "cake"."id" AS "A_id", "cake"."name" AS "A_name", "fruit"."id" AS "B_id", "fruit"."name" AS "B_name", "fruit"."cake_id" AS "B_cake_id" FROM "cake" LEFT JOIN "fruit" ON "cake"."id" = "fruit"."cake_id""#,
+                    []
+                ),
+            ]
+        );
+
+        Ok(())
+    }
+}
+```
+
+## 模拟执行结果
+
+这与模拟查询结果非常相似，不同之处在于我们在这里使用 `append_exec_results` 方法，并且我们在单元测试中执行插入、更新和删除操作。`append_exec_results` 方法接受一个 `MockExecResult` 的向量，每个都表示相应操作的执行结果。
+
+```rust
+#[cfg(test)]
+mod tests {
+    use sea_orm::{
+        entity::prelude::*, entity::*, tests_cfg::*,
+        DatabaseBackend, MockDatabase, MockExecResult, Transaction,
+    };
+
+    #[async_std::test]
+    async fn test_insert_cake() -> Result<(), DbErr> {
+        // 使用模拟执行结果创建 MockDatabase
+        let db = MockDatabase::new(DatabaseBackend::Postgres)
+            .append_query_results([
+                [cake::Model {
+                    id: 15,
+                    name: "Apple Pie".to_owned(),
+                }],
+                [cake::Model {
+                    id: 16,
+                    name: "Apple Pie".to_owned(),
+                }],
+            ])
+            .append_exec_results([
+                MockExecResult {
+                    last_insert_id: 15,
+                    rows_affected: 1,
+                },
+                MockExecResult {
+                    last_insert_id: 16,
+                    rows_affected: 1,
+                },
+            ])
+            .into_connection();
+
+        // 准备 ActiveModel
+        let apple = cake::ActiveModel {
+            name: Set("Apple Pie".to_owned()),
+            ..Default::default()
+        };
+
+        // 将 ActiveModel 插入 MockDatabase
+        assert_eq!(
+            apple.clone().insert(&db).await?,
+            cake::Model {
+                id: 15,
+                name: "Apple Pie".to_owned()
+            }
+        );
+
+        // 如果要检查最后插入的 id
+        let insert_result = cake::Entity::insert(apple).exec(&db).await?;
+        assert_eq!(insert_result.last_insert_id, 16);
+
+        // 检查事务日志
+        assert_eq!(
+            db.into_transaction_log(),
+            [
+                Transaction::from_sql_and_values(
+                    DatabaseBackend::Postgres,
+                    r#"INSERT INTO "cake" ("name") VALUES ($1) RETURNING "id", "name""#,
+                    ["Apple Pie".into()]
+                ),
+                Transaction::from_sql_and_values(
+                    DatabaseBackend::Postgres,
+                    r#"INSERT INTO "cake" ("name") VALUES ($1) RETURNING "id""#,
+                    ["Apple Pie".into()]
+                ),
+            ]
+        );
+
+        Ok(())
+    }
+}
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/07-write-test/03-sqlite.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/07-write-test/03-sqlite.md
new file mode 100644
index 00000000000..bbd4a565dc8
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/07-write-test/03-sqlite.md
@@ -0,0 +1,83 @@
+# 使用 SQLite
+
+如果你想测试不需要特定数据库功能的应用程序逻辑，SQLite 将是一个不错的选择。
+
+请在此处查看一个简单示例：[here](https://github.com/SeaQL/sea-orm/blob/master/tests/basic.rs)。
+
+## 集成测试
+
+建议在[集成测试](https://doc.rust-lang.org/rust-by-example/testing/integration_testing.html)中执行更复杂的测试用例。以下代码片段说明了连接到数据库、设置模式和执行测试的步骤。
+
+```rust
+async fn main() -> Result<(), DbErr> {
+    // Connecting SQLite
+    let db = Database::connect("sqlite::memory:").await?;
+
+    // Setup database schema
+    setup_schema(&db).await?;
+
+    // Performing tests
+    testcase(&db).await?;
+
+    Ok(())
+}
+```
+
+## 设置数据库模式
+
+为了在 SQLite 数据库中创建用于测试的表，你可以不手动编写 [`TableCreateStatement`](https://docs.rs/sea-query/*/sea_query/table/struct.TableCreateStatement.html)，而是使用 [`Schema::create_table_from_entity`](https://docs.rs/sea-orm/*/sea_orm/schema/struct.Schema.html#method.create_table_from_entity) 从 `Entity` 派生它。
+
+```rust
+async fn setup_schema(db: &DbConn) {
+
+    // Setup Schema helper
+    let schema = Schema::new(DbBackend::Sqlite);
+
+    // Derive from Entity
+    let stmt: TableCreateStatement = schema.create_table_from_entity(MyEntity);
+
+    // Or setup manually
+    assert_eq!(
+        stmt.build(SqliteQueryBuilder),
+        Table::create()
+            .table(MyEntity)
+            .col(integer(MyEntity::Column::Id))
+            //...
+            .build(SqliteQueryBuilder)
+    );
+
+    // Execute create table statement
+    let result = db
+        .execute(db.get_database_backend().build(&stmt))
+        .await;
+}
+```
+
+## 执行测试
+
+执行测试用例并对结果进行断言。
+
+```rust
+async fn testcase(db: &DbConn) -> Result<(), DbErr> {
+
+    let baker_bob = baker::ActiveModel {
+        name: Set("Baker Bob".to_owned()),
+        contact_details: Set(serde_json::json!({
+            "mobile": "+61424000000",
+            "home": "0395555555",
+            "address": "12 Test St, Testville, Vic, Australia"
+        })),
+        bakery_id: Set(2),
+        ..Default::default()
+    };
+
+    let baker_insert_res = Baker::insert(baker_bob)
+        .exec(db)
+        .await
+        .expect("could not insert baker");
+
+    assert_eq!(baker_insert_res.last_insert_id, 1);
+
+    Ok(())
+}
+```
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/07-write-test/_category_.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/07-write-test/_category_.json
new file mode 100644
index 00000000000..5c07ef1dfe7
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/07-write-test/_category_.json
@@ -0,0 +1,4 @@
+{
+  "label": "Writing Tests",
+  "collapsed": false
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/01-custom-select.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/01-custom-select.md
new file mode 100644
index 00000000000..14a064a2eb4
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/01-custom-select.md
@@ -0,0 +1,232 @@
+# 自定义选择
+
+:::caution 我们需要你的支持！⭐
+感谢你使用 SeaORM。请给我们的 [GitHub 仓库](https://github.com/SeaQL/sea-orm) 点赞！你的支持对 SeaORM 的持续开发和维护至关重要。
+:::
+
+默认情况下，SeaORM 将选择 `Column` 枚举中定义的所有列。如果你只想选择某些列，可以覆盖默认设置。
+
+```rust
+// Selecting all columns
+assert_eq!(
+    cake::Entity::find()
+        .build(DbBackend::Postgres)
+        .to_string(),
+    r#"SELECT "cake"."id", "cake"."name" FROM "cake""#
+);
+```
+
+## 选择部分属性
+
+通过调用 `select_only` 方法清除默认选择。然后，你可以选择部分属性或自定义表达式。
+
+```rust
+// Selecting the name column only
+assert_eq!(
+    cake::Entity::find()
+        .select_only()
+        .column(cake::Column::Name)
+        .build(DbBackend::Postgres)
+        .to_string(),
+    r#"SELECT "cake"."name" FROM "cake""#
+);
+```
+
+如果你想一次选择多个属性，可以提供一个数组。
+
+```rust
+assert_eq!(
+    cake::Entity::find()
+        .select_only()
+        .columns([cake::Column::Id, cake::Column::Name])
+        .build(DbBackend::Postgres)
+        .to_string(),
+    r#"SELECT "cake"."id", "cake"."name" FROM "cake""#
+);
+```
+
+高级示例：有条件地选择除特定列之外的所有列。
+
+```rust
+assert_eq!(
+    cake::Entity::find()
+        .select_only()
+        .columns(cake::Column::iter().filter(|col| match col {
+            cake::Column::Id => false,
+            _ => true,
+        }))
+        .build(DbBackend::Postgres)
+        .to_string(),
+    r#"SELECT "cake"."name" FROM "cake""#
+);
+```
+
+### 可选字段
+
+从 0.12 版本开始，SeaORM 支持 `Option<T>` 模型字段的部分选择。当选择结果不包含 `Option<T>` 字段时，将填充 `None` 值，而不会抛出错误。
+
+```rust
+customer::ActiveModel {
+    name: Set("Alice".to_owned()),
+    notes: Set(Some("Want to communicate with Bob".to_owned())),
+    ..Default::default()
+}
+.save(db)
+.await?;
+
+// `notes` 字段被有意省略
+let customer = Customer::find()
+    .select_only()
+    .column(customer::Column::Id)
+    .column(customer::Column::Name)
+    .one(db)
+    .await
+    .unwrap();
+
+// 选择结果不包含 `notes` 字段。
+// 由于它是 `Option<String>` 类型，它将是 `None` 并且不会抛出错误。
+assert_eq!(customers.notes, None);
+```
+
+## 选择自定义表达式
+
+使用 `column_as` / `expr_as` 方法选择任何自定义表达式，它接受任何 [`sea_query::SimpleExpr`](https://docs.rs/sea-query/*/sea_query/expr/enum.SimpleExpr.html) 和一个别名。使用 [`sea_query::Expr`](https://docs.rs/sea-query/*/sea_query/expr/struct.Expr.html) 助手构建 `SimpleExpr`。
+
+```rust
+use sea_query::{Alias, Expr, Func};
+
+assert_eq!(
+    cake::Entity::find()
+        .column_as(Expr::col(cake::Column::Id).max().sub(Expr::col(cake::Column::Id)), "id_diff")
+        .column_as(Expr::cust("CURRENT_TIMESTAMP"), "current_time")
+        .build(DbBackend::Postgres)
+        .to_string(),
+    r#"SELECT "cake"."id", "cake"."name", MAX("id") - "id" AS "id_diff", CURRENT_TIMESTAMP AS "current_time" FROM "cake""#
+);
+
+assert_eq!(
+    cake::Entity::find()
+        .expr_as(Func::upper(Expr::col((cake::Entity, cake::Column::Name))), "name_upper")
+        .build(DbBackend::MySql)
+        .to_string(),
+    "SELECT `cake`.`id`, `cake`.`name`, UPPER(`cake`.`name`) AS `name_upper` FROM `cake`"
+);
+```
+
+## 处理选择结果
+
+### 自定义结构体
+
+你可以使用从 `FromQueryResult` trait 派生的自定义 `struct` 来处理复杂查询的结果。这在处理无法直接转换为模型的自定义列或多个连接时特别有用。它可用于接收任何查询的结果，甚至是原始 SQL。
+
+```rust
+use sea_orm::{FromQueryResult, JoinType, RelationTrait};
+use sea_query::Expr;
+
+#[derive(FromQueryResult)]
+struct CakeAndFillingCount {
+    id: i32,
+    name: String,
+    count: i32,
+}
+
+let cake_counts: Vec<CakeAndFillingCount> = cake::Entity::find()
+    .column_as(filling::Column::Id.count(), "count")
+    .join_rev(
+        // 动态构建 `RelationDef`
+        JoinType::InnerJoin,
+        cake_filling::Entity::belongs_to(cake::Entity)
+            .from(cake_filling::Column::CakeId)
+            .to(cake::Column::Id)
+            .into()
+    )
+    // 重用现有实体中的 `Relation`
+    .join(JoinType::InnerJoin, cake_filling::Relation::Filling.def())
+    .group_by(cake::Column::Id)
+    .into_model::<CakeAndFillingCount>()
+    .all(db)
+    .await?;
+```
+
+### 非结构化元组
+
+你可以使用 `into_tuple` 方法选择一个元组（或单个值）。
+
+```rust
+use sea_orm::{entity::*, query::*, tests_cfg::cake, DeriveColumn, EnumIter};
+
+let res: Vec<(String, i64)> = cake::Entity::find()
+    .select_only()
+    .column(cake::Column::Name)
+    .column(cake::Column::Id.count())
+    .group_by(cake::Column::Name)
+    .into_tuple()
+    .all(&db)
+    .await?;
+```
+
+## 选择部分模型
+
+在 `0.12` 版本中，我们引入了一个新的 trait `PartialModelTrait` 和配对宏 `DerivePartialModel`，以改善自定义选择的人体工程学。
+
+而不是：
+
+```rust
+use user::Entity as User;
+
+#[derive(FromQueryResult)]
+struct PartialUser {
+    pub id: i32,
+    pub avatar: String,
+    pub unique_id: Uuid,
+}
+
+let query = User::find()
+    .select_only()
+    .column(Column::Id)
+    .column(Column::Avatar)
+    .column(Column::UniqueId)
+    .into_model::<PartialUser>();
+```
+
+你可以定义一个部分模型，相应的列将自动选择：
+
+```rust
+#[derive(DerivePartialModel)]
+#[sea_orm(entity = "User")]
+struct PartialUser {
+    pub id: i32,
+    pub avatar: String,
+    pub unique_id: Uuid,
+}
+
+let query = User::find().into_partial_model::<PartialUser>();
+```
+
+:::tip 自 `1.0.0` 起
+`DerivePartialModel` 宏属性 `entity` 支持复杂类型
+```rust
+#[sea_orm(entity = "<entity::Model as ModelTrait>::Entity")]
+struct PartialUser {
+    ..
+}
+```
+:::
+
+高级用法包括列重映射和自定义表达式：
+
+```rust
+#[derive(DerivePartialModel)]
+#[sea_orm(entity = "User")]
+struct PartialRow {
+    #[sea_orm(from_col = "id")]
+    user_id: i32,
+    #[sea_orm(from_expr = "Expr::col(user::Column::Id).add(1)")]
+    next_id: i32,
+}
+
+// 上述等同于：
+User::find()
+    .column_as(user::Column::Id, "user_id")
+    .column_as(Expr::col(user::Column::Id).add(1), "next_id")
+```
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/02-conditional-expression.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/02-conditional-expression.md
new file mode 100644
index 00000000000..a42476654b8
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/02-conditional-expression.md
@@ -0,0 +1,95 @@
+# 条件表达式
+
+你可以使用 `filter` 方法向 SeaORM 查询添加条件。你还可以使用 `having` 方法限制聚合结果。两者都接受 [`sea_query::Condition`](https://docs.rs/sea-query/*/sea_query/query/struct.Condition.html) 作为参数。
+
+## AND 条件
+
+使用 `Condition::all` 方法构造 AND 条件表达式，并使用 `add` 方法附加任何以 [`sea_query::SimpleExpr`](https://docs.rs/sea-query/*/sea_query/expr/enum.SimpleExpr.html) 表示的条件。
+
+```rust
+assert_eq!(
+    cake::Entity::find()
+        .filter(
+            Condition::all()
+                .add(cake::Column::Id.gte(1))
+                .add(cake::Column::Name.like("%Cheese%"))
+        )
+        .build(DbBackend::MySql)
+        .to_string(),
+    [
+        "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
+        "WHERE `cake`.`id` >= 1 AND `cake`.`name` LIKE '%Cheese%'",
+    ].join(" ")
+);
+```
+
+## OR 条件
+
+使用 `Condition::any` 方法构造 OR 条件表达式，并使用 `add` 方法附加任何以 [`sea_query::SimpleExpr`](https://docs.rs/sea-query/*/sea_query/expr/enum.SimpleExpr.html) 表示的条件。
+
+```rust
+assert_eq!(
+    cake::Entity::find()
+        .filter(
+            Condition::any()
+                .add(cake::Column::Id.eq(4))
+                .add(cake::Column::Id.eq(5))
+        )
+        .build(DbBackend::MySql)
+        .to_string(),
+    [
+        "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
+        "WHERE `cake`.`id` = 4 OR `cake`.`id` = 5",
+    ].join(" ")
+);
+```
+
+## 嵌套条件
+
+`add` 方法也可以接受另一个条件表达式。通过这样做，我们可以灵活地构造复杂的嵌套条件。
+
+```rust
+assert_eq!(
+    cake::Entity::find()
+        .filter(
+            Condition::any()
+                .add(
+                    Condition::all()
+                        .add(cake::Column::Id.lte(30))
+                        .add(cake::Column::Name.like("%Chocolate%"))
+                )
+                .add(
+                    Condition::all()
+                        .add(cake::Column::Id.gte(1))
+                        .add(cake::Column::Name.like("%Cheese%"))
+                )
+        )
+        .build(DbBackend::MySql)
+        .to_string(),
+    [
+        "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
+        "WHERE (`cake`.`id` <= 30 AND `cake`.`name` LIKE '%Chocolate%') OR",
+        "(`cake`.`id` >= 1 AND `cake`.`name` LIKE '%Cheese%')",
+    ].join(" ")
+);
+```
+
+## 流式条件查询
+
+如果给定的 `Option<T>` 是 `Some(_)`，则对 QueryStatement 应用操作。它使你的查询表达式保持流畅！
+
+```rust
+use sea_orm::{entity::*, query::*, tests_cfg::cake, DbBackend};
+
+assert_eq!(
+    cake::Entity::find()
+        .apply_if(Some(3), |mut query, v| {
+            query.filter(cake::Column::Id.eq(v))
+        })
+        .apply_if(Some(100), QuerySelect::limit)
+        .apply_if(None, QuerySelect::offset::<Option<u64>>) // no-op
+        .build(DbBackend::Postgres)
+        .to_string(),
+    r#"SELECT "cake"."id", "cake"."name" FROM "cake" WHERE "cake"."id" = 3 LIMIT 100"#
+);
+```
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/03-aggregate-function.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/03-aggregate-function.md
new file mode 100644
index 00000000000..273f43c1b2e
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/03-aggregate-function.md
@@ -0,0 +1,63 @@
+# 聚合函数
+
+你可以使用 `group_by` 方法对从 SeaORM find 中选择的结果进行分组。如果你希望进一步限制分组结果集，`having` 方法可以帮助你实现这一点。
+
+## 分组 (Group By)
+
+`group_by` 方法可以接受实体的一个列或一个复杂的 [`sea_query::SimpleExpr`](https://docs.rs/sea-query/*/sea_query/expr/enum.SimpleExpr.html)。
+
+```rust
+assert_eq!(
+    cake::Entity::find()
+        .select_only()
+        .column(cake::Column::Name)
+        .group_by(cake::Column::Name)
+        .build(DbBackend::Postgres)
+        .to_string(),
+    r#"SELECT "cake"."name" FROM "cake" GROUP BY "cake"."name""#
+);
+
+assert_eq!(
+    cake::Entity::find()
+        .select_only()
+        .column_as(cake::Column::Id.count(), "count")
+        .column_as(cake::Column::Id.sum(), "sum_of_id")
+        .group_by(cake::Column::Name)
+        .build(DbBackend::Postgres)
+        .to_string(),
+    r#"SELECT COUNT("cake"."id") AS "count", SUM("cake"."id") AS "sum_of_id" FROM "cake" GROUP BY "cake"."name""#
+);
+```
+
+## 筛选 (Having)
+
+`having` 方法可以接受上一节中介绍的任何条件表达式。
+
+```rust
+assert_eq!(
+    cake::Entity::find()
+        .having(cake::Column::Id.eq(4))
+        .having(cake::Column::Id.eq(5))
+        .build(DbBackend::MySql)
+        .to_string(),
+    "SELECT `cake`.`id`, `cake`.`name` FROM `cake` HAVING `cake`.`id` = 4 AND `cake`.`id` = 5"
+);
+
+assert_eq!(
+    cake::Entity::find()
+        .select_only()
+        .column_as(cake::Column::Id.count(), "count")
+        .column_as(cake::Column::Id.sum(), "sum_of_id")
+        .group_by(cake::Column::Name)
+        .having(Expr::col("count").gt(6))
+        .build(DbBackend::MySql)
+        .to_string(),
+    "SELECT COUNT(`cake`.`id`) AS `count`, SUM(`cake`.`id`) AS `sum_of_id` FROM `cake` GROUP BY `cake`.`name` HAVING `count` > 6"
+);
+```
+
+:::info
+
+聚合函数，例如 `max`、`min`、`sum`、`count`，在 [`ColumnTrait`](https://docs.rs/sea-orm/*/sea_orm/entity/prelude/trait.ColumnTrait.html) 中可用。
+
+:::
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/04-advanced-joins.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/04-advanced-joins.md
new file mode 100644
index 00000000000..b4cf6c5f179
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/04-advanced-joins.md
@@ -0,0 +1,360 @@
+# 高级连接
+
+一个包含多个连接和自定义选择的复杂关系查询的剖析。
+
+## 模式
+
+假设我们有一个 `BaseProduct` -> `ComplexProduct`，`BaseProduct` -> `ProductTypes` 的模式设计。
+
+#### `BaseProduct`
+
+```rust
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq)]
+#[sea_orm(table_name = "base_product")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i64,
+    #[sea_orm(unique)]
+    pub name: String,
+    pub type_id: i32, // 链接到 product_type
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_one = "super::complex_product::Entity")]
+    ComplexProduct,
+    #[sea_orm(has_many = "super::product_history::Entity")]
+    ProductHistory,
+    #[sea_orm(
+        belongs_to = "super::product_type::Entity",
+        from = "Column::TypeId",
+        to = "super::product_type::Column::Id",
+        on_update = "NoAction",
+        on_delete = "NoAction"
+    )]
+    ProductType,
+}
+```
+
+#### `ComplexProduct`
+
+```rust
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq)]
+#[sea_orm(table_name = "complex_product")]
+pub struct Model {
+    #[sea_orm(primary_key, auto_increment = false)]
+    pub product_id: i64, // 链接到 base_product
+    #[sea_orm(column_type = "Decimal(Some((30, 15)))", nullable)]
+    pub price: Option<Decimal>,
+    #[sea_orm(column_type = "Decimal(Some((30, 15)))", nullable)]
+    pub lot_size: Option<Decimal>,
+    pub date_added: DateTime,
+    pub last_modified: DateTime,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::base_product::Entity",
+        from = "Column::ProductId",
+        to = "super::base_product::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    BaseProduct,
+}
+```
+
+#### `ProductType`
+
+基本上是一个“枚举表”。
+
+```rust
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq)]
+#[sea_orm(table_name = "product_type")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    #[sea_orm(unique)]
+    pub name: String,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::base_product::Entity")]
+    BaseProduct,
+}
+```
+
+## 1. 定义结果数据结构
+
+```rust
+#[derive(Clone, Debug, PartialEq, Eq, FromQueryResult, Serialize)]
+pub struct ComplexProduct {
+    pub id: i64,
+    pub name: String,
+    pub r#type: String,
+    pub price: Decimal,
+    pub lot_size: Decimal,
+    pub date_added: DateTime,
+    pub last_modified: DateTime,
+    #[sea_orm(skip)]
+    pub history: Vec<product_history::Model>,
+}
+```
+
+使用 `Serialize`，你可以直接将选择结果转换为 JSON。
+
+## 2. 定义辅助别名
+
+```rust
+#[derive(DeriveIden, Clone, Copy)]
+pub struct Id;
+
+#[derive(DeriveIden, Clone, Copy)]
+pub struct Name;
+
+#[derive(DeriveIden, Clone, Copy)]
+pub struct Base;
+
+use complex_product::Entity as Prod;
+pub type ProdCol = <Prod as EntityTrait>::Column;
+type ProdRel = <Prod as EntityTrait>::Relation;
+```
+
+这将使我们的代码更加简洁和可读。
+
+避免使用字符串字面量，因为它容易出错。
+
+:::tip
+
+如果你需要使用许多别名，可以定义一个枚举：
+
+```rust
+#[derive(DeriveIden, Clone, Copy)]
+pub enum Prod {
+    Base,
+    Frame,
+    Package,
+}
+```
+
+:::
+
+## 3. 自定义选择
+
+```rust
+pub fn query() -> Select<complex_product::Entity> {
+    complex_product::Entity::find()
+        .select_only()
+        .tbl_col_as((Base, Id), "id")
+        .tbl_col_as((Base, Name), "name")
+        .column_as(product_type::Column::Name, "type")
+        .column_as(ProdCol::Price, "price")
+        .column_as(ProdCol::LotSize, "lot_size")
+        .column_as(ProdCol::DateAdded, "date_added")
+        .column_as(ProdCol::LastModified, "last_modified")
+        .join_as(JoinType::InnerJoin, ProdRel::BaseProduct.def(), Base)
+        .join(JoinType::InnerJoin, base_product::Relation::ProductType.def().from_alias(Base))
+        .order_by_asc(Expr::col((Base, Id)))
+}
+```
+
+我们的查询从 `ComplexProduct` 开始。我们连接回 `BaseProduct`，并将其别名为 `Base`。然后我们通过 `Base` 连接到 `ProductType`。
+
+```
+ComplexProduct -> BaseProduct as Base -> ProductType
+```
+
+:::tip
+
+可以以菱形拓扑结构进行连接：
+
+```
+ComplexProduct -> BaseProduct -> Attribute
+               -> Material    -> Attribute
+```
+
+```rust
+.join_as(JoinType::LeftJoin, complex_product::Relation::BaseProduct.def(), Base)
+.join_as(JoinType::LeftJoin, complex_product::Relation::Material.def(), Material)
+.join(JoinType::InnerJoin, base_product::Relation::Attribute.def().from_alias(Base))
+.join(JoinType::InnerJoin, material::Relation::Attribute.def().from_alias(Material))
+```
+
+:::
+
+### 自定义连接条件
+
+你可以使用 `join` 方法在选择查询中构建复杂的连接。它接受任何 `RelationDef`，并且你可以进一步自定义连接条件。下面是一个示例（尽管它来自 Bakery 模式）：
+
+```rust
+use sea_orm::{JoinType, RelationTrait};
+use sea_query::Expr;
+
+assert_eq!(
+    cake::Entity::find()
+        .column_as(filling::Column::Id.count(), "count")
+        .column_as(
+            Expr::col(("fruit_alias", fruit::Column::Name)).into_simple_expr(),
+            "fruit_name"
+        )
+        // 动态构建 `RelationDef`
+        .join_rev(
+            JoinType::InnerJoin,
+            cake_filling::Entity::belongs_to(cake::Entity)
+                .from(cake_filling::Column::CakeId)
+                .to(cake::Column::Id)
+                .into()
+        )
+        // 重用现有实体的 `Relation`
+        .join(JoinType::InnerJoin, cake_filling::Relation::Filling.def())
+        // 使用表别名和自定义条件进行连接
+        .join_as(
+            JoinType::LeftJoin,
+            cake::Relation::Fruit
+                .def()
+                .on_condition(|_left, right| {
+                    Expr::col((right, fruit::Column::Name))
+                        .like("%tropical%")
+                        .into_condition()
+                }),
+            "fruit_alias"
+        )
+        .group_by(cake::Column::Id)
+        .having(filling::Column::Id.count().equals(Expr::value(2)))
+        .build(DbBackend::MySql)
+        .to_string(),
+    [
+        "SELECT `cake`.`id`, `cake`.`name`, COUNT(`filling`.`id`) AS `count`, `fruit_alias`.`name` AS `fruit_name` FROM `cake`",
+        "INNER JOIN `cake_filling` ON `cake_filling`.`cake_id` = `cake`.`id`",
+        "INNER JOIN `filling` ON `cake_filling`.`filling_id` = `filling`.`id`",
+        "LEFT JOIN `fruit` AS `fruit_alias` ON `cake`.`id` = `fruit_alias`.`cake_id` AND `fruit_alias`.`name` LIKE '%tropical%'",
+        "GROUP BY `cake`.`id`",
+        "HAVING COUNT(`filling`.`id`) = 2",
+    ]
+    .join(" ")
+);
+```
+
+## 4. 过滤条件
+
+假设我们在 API 上支持以下查询参数：
+
+```rust
+
+#[derive(Default, Deserialize)]
+pub struct Query {
+    #[serde(default)]
+    pub id: Vec<i64>,
+    pub name: Option<String>,
+}
+```
+
+```rust
+fn condition(query: Query) -> Condition {
+    Condition::all()
+        .add_option(if !query.id.is_empty() {
+            Some(Expr::col((Base, Id)).is_in(query.id))
+        } else { None })
+        .add_option(if let Some(name) = &query.name {
+            Some(Expr::col((Base, Name)).like(name))
+        } else { None })
+}
+```
+
+额外提示：如果你只使用 Postgres，可以将 `is_in` 替换为 `any`：
+
+```rust
+use sea_orm::sea_query::extension::postgres::PgFunc;
+
+Expr::col((Base, Id)).eq(PgFunc::any(query.id)) // WHERE base.id = ANY($N)
+```
+
+```rust
+let products = query()
+    .filter(condition(q))
+    .into_model::<ComplexProduct>()
+    .all(db)
+    .await?;
+```
+
+## 5. 额外：关联模型
+
+现在，假设我们有一个与每个 `BaseProduct` 关联的数据结构，用于记录其历史：
+
+#### `ProductHistory`
+
+```rust
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
+#[sea_orm(table_name = "product_history")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    #[serde(skip)]
+    pub id: i32,
+    pub product_id: i64,
+    pub from: DateTime,
+    pub until: DateTime,
+    pub name: Option<String>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::base_product::Entity",
+        from = "Column::ProductId",
+        to = "super::base_product::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    BaseProduct,
+}
+```
+
+让我们创建一个辅助函数来查询与一组产品关联的历史记录：
+
+```rust
+pub fn history_of(ids: Vec<i64>) -> Select<product_history::Entity> {
+    product_history::Entity::find()
+        .filter(Expr::col(product_history::Column::ProductId).is_in(ids))
+        .order_by_asc(product_history::Column::Id)
+}
+
+let histories = history_of(products.iter().map(|s| s.id).collect::<Vec<_>>())
+    .all(db)
+    .await?;
+```
+
+最后一步是将 `product_history::Model` 与 `ComplexProduct` 关联：
+
+```rust
+pub fn associate(
+    mut parent: Vec<ComplexProduct>,
+    children: Vec<product_history::Model>,
+) -> Vec<ComplexProduct> {
+    let len = parent.len();
+    parent.dedup_by_key(|s| s.id);
+    if len != parent.len() {
+        warn!("parent is not unique.");
+    }
+
+    let parent_id_map: HashMap<i64, usize> = parent
+        .iter()
+        .enumerate()
+        .map(|(i, s)| (s.id, i))
+        .collect();
+
+    // 将子项放入关联的父项中
+    for item in children {
+        if let Some(index) = parent_id_map.get(&item.product_id) {
+            parent[*index].history.push(item);
+        }
+    }
+
+    parent
+}
+
+let products = associate(products, histories);
+```
+
+这有时被称为“数据加载器”模式，并且可以通过泛型进行推广以适用于任何模型。
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/05-subquery.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/05-subquery.md
new file mode 100644
index 00000000000..e0168f64a21
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/05-subquery.md
@@ -0,0 +1,30 @@
+# 子查询
+
+## 带子查询的条件表达式
+
+使用 `in_subquery` 或 `not_in_subquery` 方法来构造带子查询的条件表达式。
+
+```rust
+use sea_orm::Condition;
+use sea_query::Query;
+
+assert_eq!(
+    cake::Entity::find()
+        .filter(
+            Condition::any().add(
+                cake::Column::Id.in_subquery(
+                    Query::select()
+                        .expr(cake::Column::Id.max())
+                        .from(cake::Entity)
+                        .to_owned()
+                )
+            )
+        )
+        .build(DbBackend::MySql)
+        .to_string(),
+    [
+        "SELECT `cake`.`id`, `cake`.`name` FROM `cake`",
+        "WHERE `cake`.`id` IN (SELECT MAX(`cake`.`id`) FROM `cake`)",
+    ]
+    .join(" ")
+);
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/06-transaction.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/06-transaction.md
new file mode 100644
index 00000000000..a4d7e2b206f
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/06-transaction.md
@@ -0,0 +1,146 @@
+# 事务
+
+事务是一组以 ACID 保证执行的 SQL 语句。有两种事务 API。
+
+## 使用闭包
+
+使用闭包执行事务。如果闭包返回 `Ok`，事务将被提交；如果返回 `Err`，事务将被回滚。第二个和第三个类型参数分别是 Ok 和 Err 类型。由于 `async_closure` 尚未稳定，你必须将其 `Pin<Box<_>>`。
+
+```rust
+use sea_orm::TransactionTrait;
+
+// <Fn, A, B> -> Result<A, B>
+db.transaction::<_, (), DbErr>(|txn| {
+    Box::pin(async move {
+        bakery::ActiveModel {
+            name: Set("SeaSide Bakery".to_owned()),
+            profit_margin: Set(10.4),
+            ..Default::default()
+        }
+        .save(txn)
+        .await?;
+
+        bakery::ActiveModel {
+            name: Set("Top Bakery".to_owned()),
+            profit_margin: Set(15.0),
+            ..Default::default()
+        }
+        .save(txn)
+        .await?;
+
+        Ok(())
+    })
+})
+.await;```
+
+这是大多数情况下的首选方式。但是，如果你在异步块中尝试捕获引用时遇到“不可能的生命周期”，那么以下 API 是解决方案。
+
+## `begin` & `commit` / `rollback`
+
+`begin` 事务，然后是 `commit` 或 `rollback`。如果 `txn` 超出作用域，事务将自动回滚。
+
+```rust
+let txn = db.begin().await?;
+
+bakery::ActiveModel {
+    name: Set("SeaSide Bakery".to_owned()),
+    profit_margin: Set(10.4),
+    ..Default::default()
+}
+.save(&txn)
+.await?;
+
+bakery::ActiveModel {
+    name: Set("Top Bakery".to_owned()),
+    profit_margin: Set(15.0),
+    ..Default::default()
+}
+.save(&txn)
+.await?;
+
+txn.commit().await?;
+```
+
+## 嵌套事务
+
+嵌套事务通过数据库的 `SAVEPOINT` 实现。下面的示例说明了使用闭包 API 的行为。
+
+```rust
+assert_eq!(Bakery::find().all(txn).await?.len(), 0);
+
+ctx.db.transaction::<_, _, DbErr>(|txn| {
+    Box::pin(async move {
+        let _ = bakery::ActiveModel {..}.save(txn).await?;
+        let _ = bakery::ActiveModel {..}.save(txn).await?;
+        assert_eq!(Bakery::find().all(txn).await?.len(), 2);
+
+        // 尝试提交嵌套事务
+        txn.transaction::<_, _, DbErr>(|txn| {
+            Box::pin(async move {
+                let _ = bakery::ActiveModel {..}.save(txn).await?;
+                assert_eq!(Bakery::find().all(txn).await?.len(), 3);
+
+                // 尝试回滚嵌套的嵌套事务
+                assert!(txn.transaction::<_, _, DbErr>(|txn| {
+                        Box::pin(async move {
+                            let _ = bakery::ActiveModel {..}.save(txn).await?;
+                            assert_eq!(Bakery::find().all(txn).await?.len(), 4);
+
+                            Err(DbErr::Query(RuntimeErr::Internal(
+                                "Force Rollback!".to_owned(),
+                            )))
+                        })
+                    })
+                    .await
+                    .is_err()
+                );
+
+                assert_eq!(Bakery::find().all(txn).await?.len(), 3);
+
+                // 尝试提交嵌套的嵌套事务
+                txn.transaction::<_, _, DbErr>(|txn| {
+                    Box::pin(async move {
+                        let _ = bakery::ActiveModel {..}.save(txn).await?;
+                        assert_eq!(Bakery::find().all(txn).await?.len(), 4);
+
+                        Ok(())
+                    })
+                })
+                .await;
+
+                assert_eq!(Bakery::find().all(txn).await?.len(), 4);
+
+                Ok(())
+            })
+        })
+        .await;
+
+        Ok(())
+    })
+})
+.await;
+
+assert_eq!(Bakery::find().all(txn).await?.len(), 4);
+```
+
+## 隔离级别和访问模式
+
+在 `0.10.5` 中引入的 [`transaction_with_config`](https://docs.rs/sea-orm/*/sea_orm/trait.TransactionTrait.html#tymethod.transaction_with_config) 和 [`begin_with_config`](https://docs.rs/sea-orm/*/sea_orm/trait.TransactionTrait.html#tymethod.begin_with_config) 允许你指定 [IsolationLevel](https://docs.rs/sea-orm/*/sea_orm/enum.IsolationLevel.html) 和 [AccessMode](https://docs.rs/sea-orm/*/sea_orm/enum.AccessMode.html)。
+
+目前，它们仅针对 MySQL 和 Postgres 实现。为了统一它们的语义差异，MySQL 将在事务开始前执行 `SET TRANSACTION` 命令，而 Postgres 将在事务开始后执行 `SET TRANSACTION` 命令。
+
+### 隔离级别 (IsolationLevel)
+
+`RepeatableRead`：同一事务中的一致性读取会读取由第一次读取建立的快照。
+
+`ReadCommitted`：每次一致性读取，即使在同一事务中，也会设置并读取自己的新快照。
+
+`ReadUncommitted`：SELECT 语句以非锁定方式执行，但可能会使用行的早期版本。
+
+`Serializable`：当前事务的所有语句只能看到在该事务中执行第一个查询或数据修改语句之前提交的行。
+
+### 访问模式 (AccessMode)
+
+`ReadOnly`：此事务中不能修改数据。
+
+`ReadWrite`：此事务中可以修改数据（默认）。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/07-streaming.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/07-streaming.md
new file mode 100644
index 00000000000..61b68d088bf
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/07-streaming.md
@@ -0,0 +1,35 @@
+# 流式处理
+
+在任何 `Select` 上使用来自 [futures](https://crates.io/crates/futures) crate 的异步流，以减少内存分配，提高效率。
+
+```rust
+use futures::TryStreamExt;
+
+// 流式处理所有水果
+let mut stream = Fruit::find().stream(db).await?;
+
+while let Some(item) = stream.try_next().await? {
+    let item: fruit::ActiveModel = item.into();
+    // 对 item 进行操作
+}
+```
+
+```rust
+// 流式处理所有名称包含字符 "a" 的水果
+let mut stream = Fruit::find()
+    .filter(fruit::Column::Name.contains("a"))
+    .order_by_asc(fruit::Column::Name)
+    .stream(db)
+    .await?;
+```
+
+请注意，流对象将独占连接直到被丢弃，从而阻止连接被其他对象借用。
+
+```rust
+{
+    let s1 = Fruit::find().stream(db).await?;
+    let s2 = Fruit::find().stream(db).await?;
+    let s3 = Fruit::find().stream(db).await?;
+    // 3 个连接被持有
+}
+// 所有流都被丢弃，连接返回到连接池
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/08-custom-active-model.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/08-custom-active-model.md
new file mode 100644
index 00000000000..00e95a579b9
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/08-custom-active-model.md
@@ -0,0 +1,90 @@
+# 自定义 Active Model
+
+创建你自己的结构体，其中包含模型的部分字段，并实现 `IntoActiveModel`，可以通过 `into_active_model` 方法将其转换为 `ActiveModel`。例如，它可以用作 REST API 中的表单提交。
+
+`IntoActiveValue` trait 允许使用 `into_active_value` 方法将 `Option<T>` 转换为 `ActiveValue<T>`。
+
+```rust
+// 像往常一样定义常规模型
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "fruit")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub name: String,
+    pub cake_id: Option<i32>,
+}
+```
+
+创建一个省略部分字段的新结构体。
+
+```rust
+use sea_orm::ActiveValue::NotSet;
+
+#[derive(DeriveIntoActiveModel)]
+pub struct NewFruit {
+    // id 被省略
+    pub name: String,
+    // 它是必需的，与 Model 中的可选字段相反
+    pub cake_id: i32,
+}
+
+assert_eq!(
+    NewFruit {
+        name: "Apple".to_owned(),
+        cake_id: 1,
+    }
+    .into_active_model(),
+    fruit::ActiveModel {
+        id: NotSet,
+        name: Set("Apple".to_owned()),
+        cake_id: Set(Some(1)),
+    }
+);
+```
+
+`Option<Option<T>>` 允许 `Some(None)` 将列更新为 NULL。
+
+```rust
+use sea_orm::ActiveValue::NotSet;
+
+#[derive(DeriveIntoActiveModel)]
+pub struct UpdateFruit {
+    pub cake_id: Option<Option<i32>>,
+}
+
+assert_eq!(
+    UpdateFruit {
+        cake_id: Some(Some(1)),
+    }
+    .into_active_model(),
+    fruit::ActiveModel {
+        id: NotSet,
+        name: NotSet,
+        cake_id: Set(Some(1)),
+    }
+);
+
+assert_eq!(
+    UpdateFruit {
+        cake_id: Some(None),
+    }
+    .into_active_model(),
+    fruit::ActiveModel {
+        id: NotSet,
+        name: NotSet,
+        cake_id: Set(None),
+    }
+);
+
+assert_eq!(
+    UpdateFruit {
+        cake_id: None,
+    }
+    .into_active_model(),
+    fruit::ActiveModel {
+        id: NotSet,
+        name: NotSet,
+        cake_id: NotSet,
+    }
+);
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/09-error-handling.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/09-error-handling.md
new file mode 100644
index 00000000000..6ecdfde5d96
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/09-error-handling.md
@@ -0,0 +1,52 @@
+# 错误处理
+
+SeaORM 中的所有运行时错误都由 [`DbErr`](https://docs.rs/sea-orm/*/sea_orm/error/enum.DbErr.html) 表示。
+
+## 处理常见的 SQL 错误
+
+你可以使用 `DbErr::sql_err()` 方法将 SQL 相关错误转换为常见的数据库错误 `SqlErr`，例如唯一约束或外键冲突错误。
+
+```rust
+assert!(matches!(
+    cake.into_active_model().insert(db).await
+        .expect_err("Insert a row with duplicated primary key")
+        .sql_err(),
+    Some(SqlErr::UniqueConstraintViolation(_))
+));
+
+assert!(matches!(
+    fk_cake.insert(db).await
+        .expect_err("Insert a row with invalid foreign key")
+        .sql_err(),
+    Some(SqlErr::ForeignKeyConstraintViolation(_))
+));
+```
+
+## 处理数据库特定错误
+
+你可以从 `RuntimeErr` 中检索数据库特定的错误代码：
+
+```rust
+let my_cake = cake::ActiveModel { id: Set(1), .. };
+
+// 插入一个主键 (`id` 列) 设置为 1 的新蛋糕。
+let cake = my_cake.save(db).await.expect("could not insert cake");
+
+// 再次插入相同的行，但失败了，因为每行的主键应该是唯一的。
+let error: DbErr = cake
+    .into_active_model()
+    .insert(db)
+    .await
+    .expect_err("inserting should fail due to duplicate primary key");
+
+match error {
+    DbErr::Exec(RuntimeErr::SqlxError(error)) => match error {
+        sqlx::Error::Database(e) => {
+            // 我们检查数据库（本例中为 MySQL）抛出的错误代码，
+            // `23000` 表示 `ER_DUP_KEY`：表中存在重复键。
+            assert_eq!(e.code().unwrap(), "23000");
+        }
+        _ => panic!("Unexpected sqlx::Error kind"),
+    },
+    _ => panic!("Unexpected DbErr kind"),
+}
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/_category_.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/_category_.json
new file mode 100644
index 00000000000..d008a2fa961
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/08-advanced-query/_category_.json
@@ -0,0 +1,4 @@
+{
+  "label": "Advanced Queries",
+  "collapsed": false
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/09-schema-statement/01-create-table.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/09-schema-statement/01-create-table.md
new file mode 100644
index 00000000000..de90b1797b9
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/09-schema-statement/01-create-table.md
@@ -0,0 +1,124 @@
+# 创建表
+
+:::tip Rustacean 贴纸包 🦀
+[我们的贴纸](https://www.sea-ql.org/sticker-pack/) 采用优质防水乙烯基材料制成，具有独特的哑光效果。
+将它们贴在你的笔记本电脑、笔记本或任何小工具上，以展示你对 Rust 的热爱！
+:::
+
+要在数据库中创建表，你可以使用 [`Schema::create_table_from_entity`](https://docs.rs/sea-orm/*/sea_orm/schema/struct.Schema.html#method.create_table_from_entity) 从 `Entity` 派生，而不是手动编写 [`TableCreateStatement`](https://docs.rs/sea-query/*/sea_query/table/struct.TableCreateStatement.html)。此方法将帮助你创建一个数据库表，其中包括在 `Entity` 中定义的所有列和外键约束。
+
+下面我们使用 [`CakeFillingPrice`](https://github.com/SeaQL/sea-orm/blob/master/src/tests_cfg/cake_filling_price.rs) 实体来演示其生成的 SQL 语句。你可以使用 [`TableCreateStatement`](https://docs.rs/sea-query/*/sea_query/table/struct.TableCreateStatement.html) 构造相同的语句。
+
+请注意，从 `0.7.0` 版本开始，[`Schema::create_table_from_entity`](https://docs.rs/sea-orm/*/sea_orm/schema/struct.Schema.html#method.create_table_from_entity) 不再创建索引。如果你需要在数据库中创建索引，请查看[此处](09-schema-statement/03-create-index.md)了解详细信息。
+
+```rust
+use sea_orm::{sea_query::*, tests_cfg::*, EntityName, Schema};
+
+let builder = db.get_database_backend();
+let schema = Schema::new(builder);
+
+assert_eq!(
+    builder.build(&schema.create_table_from_entity(CakeFillingPrice)),
+    builder.build(
+        &Table::create()
+            .table(CakeFillingPrice.table_ref())
+            .col(integer(cake_filling_price::Column::CakeId))
+            .col(integer(cake_filling_price::Column::FillingId))
+            .col(decimal(cake_filling_price::Column::Price))
+            .primary_key(
+                Index::create()
+                    .name("pk-cake_filling_price")
+                    .col(cake_filling_price::Column::CakeId)
+                    .col(cake_filling_price::Column::FillingId)
+                    .primary(),
+            )
+            .foreign_key(
+                ForeignKeyCreateStatement::new()
+                    .name("fk-cake_filling_price-cake_id-filling_id")
+                    .from_tbl(CakeFillingPrice)
+                    .from_col(cake_filling_price::Column::CakeId)
+                    .from_col(cake_filling_price::Column::FillingId)
+                    .to_tbl(CakeFilling)
+                    .to_col(cake_filling::Column::CakeId)
+                    .to_col(cake_filling::Column::FillingId),
+            )
+            .to_owned()
+    )
+);
+```
+
+为了进一步说明，我们将在下面以字符串形式显示 SQL 语句。
+
+- PostgreSQL
+    ```rust
+    use sea_orm::{tests_cfg::*, DbBackend, Schema, Statement};
+
+    let db_postgres = DbBackend::Postgres;
+    let schema = Schema::new(db_postgres);
+
+    assert_eq!(
+        db_postgres.build(&schema.create_table_from_entity(CakeFillingPrice)),
+        Statement::from_string(
+            db_postgres,
+            [
+                r#"CREATE TABLE "public"."cake_filling_price" ("#,
+                r#""cake_id" integer NOT NULL,"#,
+                r#""filling_id" integer NOT NULL,"#,
+                r#""price" decimal NOT NULL,"#,
+                r#"CONSTRAINT "pk-cake_filling_price" PRIMARY KEY ("cake_id", "filling_id"),"#,
+                r#"CONSTRAINT "fk-cake_filling_price-cake_id-filling_id" FOREIGN KEY ("cake_id", "filling_id") REFERENCES "cake_filling" ("cake_id", "filling_id")"#,
+                r#")"#,
+            ]
+            .join(" ")
+        )
+    );
+    ```
+
+- MySQL
+    ```rust
+    use sea_orm::{tests_cfg::*, DbBackend, Schema, Statement};
+
+    let db_mysql = DbBackend::MySql;
+    let schema = Schema::new(db_mysql);
+
+    assert_eq!(
+        db_mysql.build(&schema.create_table_from_entity(CakeFillingPrice)),
+        Statement::from_string(
+            db_mysql,
+            [
+                "CREATE TABLE `cake_filling_price` (",
+                "`cake_id` int NOT NULL,",
+                "`filling_id` int NOT NULL,",
+                "`price` decimal NOT NULL,",
+                "PRIMARY KEY `pk-cake_filling_price` (`cake_id`, `filling_id`),",
+                "CONSTRAINT `fk-cake_filling_price-cake_id-filling_id` FOREIGN KEY (`cake_id`, `filling_id`) REFERENCES `cake_filling` (`cake_id`, `filling_id`)",
+                ")",
+            ]
+            .join(" ")
+        )
+    );
+    ```
+
+- SQLite
+    ```rust
+    use sea_orm::{tests_cfg::*, DbBackend, Schema, Statement};
+
+    let db_sqlite = DbBackend::Sqlite;
+    let schema = Schema::new(db_sqlite);
+
+    assert_eq!(
+        db_sqlite.build(&schema.create_table_from_entity(CakeFillingPrice)),
+        Statement::from_string(
+            db_sqlite,
+            [
+                "CREATE TABLE `cake_filling_price` (",
+                "`cake_id` integer NOT NULL,",
+                "`filling_id` integer NOT NULL,",
+                "`price` real NOT NULL,",
+                "CONSTRAINT `pk-cake_filling_price`PRIMARY KEY (`cake_id`, `filling_id`),",
+                "FOREIGN KEY (`cake_id`, `filling_id`) REFERENCES `cake_filling` (`cake_id`, `filling_id`)",
+                ")",
+            ]
+            .join(" ")
+        )
+    );
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/09-schema-statement/02-create-enum.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/09-schema-statement/02-create-enum.md
new file mode 100644
index 00000000000..5855d3c3032
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/09-schema-statement/02-create-enum.md
@@ -0,0 +1,220 @@
+# 创建枚举
+
+你可以通过 [`Schema`](https://docs.rs/sea-orm/*/sea_orm/schema/struct.Schema.html) 辅助结构体生成 SQL 语句来创建带有枚举列的数据库表。
+
+## 字符串和整数枚举
+
+这只是一个普通的字符串/整数列，映射到一个 Rust 枚举。实体定义示例：
+
+```rust title="active_enum.rs"
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(schema_name = "public", table_name = "active_enum")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub category: Option<Category>,
+    pub color: Option<Color>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "String(StringLen::N(1))")]
+pub enum Category {
+    #[sea_orm(string_value = "B")]
+    Big,
+    #[sea_orm(string_value = "S")]
+    Small,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "i32", db_type = "Integer")]
+pub enum Color {
+    #[sea_orm(num_value = 0)]
+    Black,
+    #[sea_orm(num_value = 1)]
+    White,
+}
+```
+
+为了说明，枚举只是普通的数据库列。
+
+```rust
+use sea_orm::{sea_query, Schema};
+
+let builder = db.get_database_backend();
+let schema = Schema::new(builder);
+
+assert_eq!(
+    builder.build(&schema.create_table_from_entity(active_enum::Entity)),
+    builder.build(
+        &sea_query::Table::create()
+            .table(active_enum::Entity.table_ref())
+            .col(pk_auto(active_enum::Column::Id))
+            .col(string_len(active_enum::Column::Category, 1))
+            .col(integer(active_enum::Column::Color))
+            .to_owned()
+    )
+);
+```
+
+<details>
+    <summary>请注意，不符合 UAX#31 标准的字符将如下所示进行转换。</summary>
+
+```rust
+#[derive(Clone, Debug, PartialEq, EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "String(StringLen::None)")]
+pub enum StringValue {
+    #[sea_orm(string_value = "")]
+    Member1,
+    #[sea_orm(string_value = "$")]
+    Member2,
+    #[sea_orm(string_value = "$$")]
+    Member3,
+    #[sea_orm(string_value = "AB")]
+    Member4,
+    #[sea_orm(string_value = "A_B")]
+    Member5,
+    #[sea_orm(string_value = "A$B")]
+    Member6,
+    #[sea_orm(string_value = "0 123")]
+    Member7,
+}
+
+// 将生成以下内容
+pub enum StringValueVariant {
+    __Empty,
+    _0x24,
+    _0x240x24,
+    Ab,
+    A0x5Fb,
+    A0x24B,
+    _0x300x20123,
+}
+```
+</details>
+
+## 原生数据库枚举
+
+不同数据库对枚举的支持是不同的。让我们逐一了解。
+
+考虑以下实体：
+
+```rust title="active_enum.rs"
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(schema_name = "public", table_name = "active_enum")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub tea: Option<Tea>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "tea")]
+pub enum Tea {
+    #[sea_orm(string_value = "EverydayTea")]
+    EverydayTea,
+    #[sea_orm(string_value = "BreakfastTea")]
+    BreakfastTea,
+}
+```
+
+注意 `db_type` 和额外的 `enum_name` 属性。
+
+### PostgreSQL
+
+PostgreSQL 中的枚举由 [`TypeCreateStatement`](https://docs.rs/sea-query/*/sea_query/extension/postgres/struct.TypeCreateStatement.html) 定义，可以使用 [`Schema::create_enum_from_entity`](https://docs.rs/sea-orm/*/sea_orm/schema/struct.Schema.html#method.create_enum_from_entity) 方法从 `Entity` 创建。
+
+你也可以使用 [`Schema::create_enum_from_active_enum`](https://docs.rs/sea-orm/*/sea_orm/schema/struct.Schema.html#method.create_enum_from_active_enum) 方法从 `ActiveEnum` 创建它。
+
+```rust
+use sea_orm::{Schema, Statement};
+
+let db_postgres = DbBackend::Postgres;
+let schema = Schema::new(db_postgres);
+
+assert_eq!(
+    schema
+        .create_enum_from_entity(active_enum::Entity)
+        .iter()
+        .map(|stmt| db_postgres.build(stmt))
+        .collect::<Vec<_>>(),
+    [Statement::from_string(
+        db_postgres,
+        r#"CREATE TYPE "tea" AS ENUM ('EverydayTea', 'BreakfastTea')"#
+    ),]
+);
+
+assert_eq!(
+    db_postgres.build(&schema.create_enum_from_active_enum::<Tea>()),
+    Statement::from_string(
+        db_postgres,
+        r#"CREATE TYPE "tea" AS ENUM ('EverydayTea', 'BreakfastTea')"#
+    )
+);
+
+assert_eq!(
+    db_postgres.build(&schema.create_table_from_entity(active_enum::Entity)),
+    Statement::from_string(
+        db_postgres,
+        [
+            r#"CREATE TABLE "public"."active_enum" ("#,
+            r#""id" serial NOT NULL PRIMARY KEY,"#,
+            r#""tea" tea"#,
+            r#")"#,
+        ]
+        .join(" ")
+    ),
+);
+```
+
+### MySQL
+
+在 MySQL 中，枚举是在表创建时定义的，所以你只需要调用一次 [`Schema::create_table_from_entity`](https://docs.rs/sea-orm/*/sea_orm/schema/struct.Schema.html#method.create_table_from_entity)。
+
+```rust
+use sea_orm::{Schema, Statement};
+
+let db_mysql = DbBackend::MySql;
+let schema = Schema::new(db_mysql);
+
+assert_eq!(
+    db_mysql.build(&schema.create_table_from_entity(active_enum::Entity)),
+    Statement::from_string(
+        db_mysql,
+        [
+            "CREATE TABLE `active_enum` (",
+            "`id` int NOT NULL AUTO_INCREMENT PRIMARY KEY,",
+            "`tea` ENUM('EverydayTea', 'BreakfastTea')",
+            ")",
+        ]
+        .join(" ")
+    ),
+);
+```
+
+### SQLite
+
+SQLite 不支持枚举，所以它将作为 `TEXT` 存储。
+
+```rust
+use sea_orm::{Schema, Statement};
+
+let db_sqlite = DbBackend::Sqlite;
+let schema = Schema::new(db_sqlite);
+
+assert_eq!(
+    db_sqlite.build(&schema.create_enum_from_entity(active_enum::Entity)),
+    Statement::from_string(
+        db_sqlite,
+        [
+            "CREATE TABLE `active_enum` (",
+            "`id` integer NOT NULL PRIMARY KEY AUTOINCREMENT,",
+            "`tea` text",
+            ")",
+        ]
+        .join(" ")
+    ),
+);
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/09-schema-statement/03-create-index.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/09-schema-statement/03-create-index.md
new file mode 100644
index 00000000000..c38f4a3b00b
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/09-schema-statement/03-create-index.md
@@ -0,0 +1,51 @@
+# 创建索引
+
+你可以使用 [`Schema::create_index_from_entity`](https://docs.rs/sea-orm/*/sea_orm/schema/struct.Schema.html#method.create_index_from_entity) 从实体创建索引，或者手动构造 [`IndexCreateStatement`](https://docs.rs/sea-query/*/sea_query/index/struct.IndexCreateStatement.html)。
+
+[`Indexes`](https://github.com/SeaQL/sea-orm/blob/master/src/tests_cfg/indexes.rs) 实体示例：
+
+```rust title="indexes.rs"
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    #[sea_orm(indexed)]
+    pub index1_attr: i32,
+    #[sea_orm(unique, indexed)]
+    pub index2_attr: i32,
+    #[sea_orm(unique_key = "my_unique")]
+    pub unique_key_a: String,
+    #[sea_orm(unique_key = "my_unique")]
+    pub unique_key_b: String,
+}
+```
+
+```rust
+use sea_orm::{sea_query, tests_cfg::*, Schema};
+
+let builder = db.get_database_backend();
+
+let stmts = Schema::new(builder).create_index_from_entity(indexes::Entity);
+
+let idx: IndexCreateStatement = Index::create()
+    .name("idx-indexes-index1_attr")
+    .table(indexes::Entity)
+    .col(indexes::Column::Index1Attr)
+    .to_owned();
+assert_eq!(builder.build(&stmts[0]), builder.build(&idx));
+
+let idx: IndexCreateStatement = Index::create()
+    .name("idx-indexes-index2_attr")
+    .table(indexes::Entity)
+    .col(indexes::Column::Index2Attr)
+    .unique()
+    .take();
+assert_eq!(builder.build(&stmts[1]), builder.build(&idx));
+
+let idx: IndexCreateStatement = Index::create()
+    .name("idx-indexes-my_unique")
+    .table(indexes::Entity)
+    .col(indexes::Column::UniqueKeyA)
+    .col(indexes::Column::UniqueKeyB)
+    .unique()
+    .take();
+assert_eq!(builder.build(&stmts[2]), builder.build(&idx));
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/09-schema-statement/_category_.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/09-schema-statement/_category_.json
new file mode 100644
index 00000000000..9eb671f9565
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/09-schema-statement/_category_.json
@@ -0,0 +1,4 @@
+{
+  "label": "模式语句",
+  "collapsed": false
+}
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/10-graph-ql/01-seaography-intro.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/10-graph-ql/01-seaography-intro.md
new file mode 100644
index 00000000000..53952583ff0
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/10-graph-ql/01-seaography-intro.md
@@ -0,0 +1,9 @@
+# 🧭 Seaography
+
+如果你正在构建一个带有 Web GUI 的全栈应用程序，那么你很可能会使用 GraphQL 作为前端和后端之间的通信接口。然而，对于后端开发人员来说，构建 GraphQL 解析器并非易事。
+
+[Seaography](https://github.com/SeaQL/seaography) 是一个基于 SeaORM 和 [async-graphql](https://github.com/async-graphql/async-graphql) 构建的 GraphQL 框架。给定一组 SeaORM 实体，你可以立即启动一个功能齐全的 GraphQL 服务器/解析器，支持关系查询、过滤器、分页和突变。
+
+SeaORM 在设计上是动态的，并提供一流的 GraphQL 支持。`async-graphql` `v5.0` 引入了[动态 schema](https://docs.rs/async-graphql/latest/async_graphql/dynamic/index.html)，与 SeaORM 完美契合。
+
+Seaography 最初是 [2022 年编程之夏项目](https://github.com/SeaQL/summer-of-code/blob/main/2022/README.md#1-a-graphql-framework-on-top-of-seaorm)的一部分。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/10-graph-ql/02-getting-started.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/10-graph-ql/02-getting-started.md
new file mode 100644
index 00000000000..86e1a738a51
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/10-graph-ql/02-getting-started.md
@@ -0,0 +1,181 @@
+# 入门
+
+此示例可在 [SeaORM + Seaography 示例](https://github.com/SeaQL/sea-orm/tree/master/examples/seaography_example) 中找到。
+
+![](https://raw.githubusercontent.com/SeaQL/sea-orm/master/examples/seaography_example/Seaography%20example.png)
+
+要开始使用，你只需要一个带有模式的实时 SQL 数据库。你可以通过编写 SeaORM 迁移在 Rust 中编写所有代码，或者使用 GUI 工具（例如 [DataGrip](https://www.jetbrains.com/datagrip/)）设计模式。
+
+## 安装 Seaography CLI
+
+```sh
+cargo install seaography-cli@^1.1.0```
+
+## 生成 Seaography 实体
+
+```sh
+sea-orm-cli generate entity --output-dir graphql/src/entities --seaography
+```
+
+像往常一样使用 `sea-orm-cli` 生成实体，但需要添加一个额外的 `--seaography` 标志。这些实体基本上是旧的 SeaORM 实体，但带有一个额外的 `RelatedEntity` 枚举。
+
+```rust title="examples/seaography_example/graphql/src/entities/cake.rs"
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq)]
+#[sea_orm(table_name = "cake")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub name: String,
+    #[sea_orm(column_type = "Decimal(Some((16, 4)))")]
+    pub price: Decimal,
+    pub bakery_id: i32,
+    pub gluten_free: i8,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::bakery::Entity",
+        from = "Column::BakeryId",
+        to = "super::bakery::Column::Id",
+        on_update = "Cascade",
+        on_delete = "Cascade"
+    )]
+    Bakery,
+    #[sea_orm(has_many = "super::cake_baker::Entity")]
+    CakeBaker,
+}
+
+impl Related<super::bakery::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Bakery.def()
+    }
+}
+
+impl Related<super::cake_baker::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::CakeBaker.def()
+    }
+}
+
+impl Related<super::baker::Entity> for Entity {
+    fn to() -> RelationDef {
+        super::cake_baker::Relation::Baker.def()
+    }
+    fn via() -> Option<RelationDef> {
+        Some(super::cake_baker::Relation::Cake.def().rev())
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}
+
+// 暴露给 Seaography 的额外模式元数据
++ #[derive(Copy, Clone, Debug, EnumIter, DeriveRelatedEntity)]
++ pub enum RelatedEntity {
++     #[sea_orm(entity = "super::bakery::Entity")]
++     Bakery,
++     #[sea_orm(entity = "super::cake_baker::Entity")]
++     CakeBaker,
++     #[sea_orm(entity = "super::baker::Entity")]
++     Baker,
++ }
+```
+
+## 生成 GraphQL 项目
+
+生成一个全新的项目是启动 GraphQL 服务器最简单的方法。
+然而，Seaography 可以轻松集成到使用任何 Web 框架构建的现有 Web 服务器中。
+
+Seaography 开箱即用地支持 Poem、Actix 和 Axum。
+
+运行以下命令：
+
+```sh
+seaography-cli graphql graphql/src/entities $DATABASE_URL sea-orm-seaography-example
+```
+
+完整帮助：
+
+```sh
+🧭 SeaORM 的动态 GraphQL 框架
+
+用法：seaography-cli [OPTIONS] <DESTINATION> <ENTITIES> <DATABASE_URL> <CRATE_NAME>
+
+参数：
+  <DESTINATION>   项目目标文件夹
+  <ENTITIES>      SeaORM 实体文件夹
+  <DATABASE_URL>  要写入 .env 的数据库 URL
+  <CRATE_NAME>    生成项目的 crate 名称
+
+选项：
+  -f, --framework <FRAMEWORK>
+          要使用的 Web 框架 [默认值: poem] [可能的值: actix, poem, axum]
+      --depth-limit <DEPTH_LIMIT>
+          GraphQL 深度限制
+      --complexity-limit <COMPLEXITY_LIMIT>
+          GraphQL 复杂度限制
+  -h, --help
+          打印帮助信息
+  -V, --version
+          打印版本信息
+```
+
+## 启动服务器
+
+```sh
+cd graphql
+cargo run
+```
+
+你当然可以自由修改项目以满足你的需求。
+有趣的部分从 `query_root.rs` 中的 `seaography::register_entities!` 宏开始。
+你可以向 GraphQL 模式添加自定义实体、查询和突变。
+
+## 运行一些查询
+
+```sh
+访问 GraphQL Playground：http://localhost:8000
+```
+
+导航到 GraphQL Playground，然后开始运行一些查询！
+
+### 面包店 -> 蛋糕 -> 烘焙师
+
+```graphql
+{
+  bakery(pagination: { page: { limit: 10, page: 0 } }, orderBy: { name: ASC }) {
+    nodes {
+      name
+      cake {
+        nodes {
+          name
+          price
+          baker {
+            nodes {
+              name
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+### 列出无麸质蛋糕并了解在哪里购买
+
+```graphql
+{
+  cake(filters: { glutenFree: { eq: 1 } }) {
+    nodes {
+      name
+      price
+      glutenFree
+      bakery {
+        name
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/10-graph-ql/_category_.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/10-graph-ql/_category_.json
new file mode 100644
index 00000000000..d1434660892
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/10-graph-ql/_category_.json
@@ -0,0 +1,4 @@
+{
+  "label": "GraphQL Support",
+  "collapsed": false
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/11-sea-orm-pro/01-sea-orm-pro-intro.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/11-sea-orm-pro/01-sea-orm-pro-intro.md
new file mode 100644
index 00000000000..1191573455c
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/11-sea-orm-pro/01-sea-orm-pro-intro.md
@@ -0,0 +1,13 @@
+# 🖥️ SeaORM Pro
+
+![](https://www.sea-ql.org/blog/img/sea-orm-pro-light.png)
+
+SeaORM Pro 是一个管理后台解决方案，让你能够快速轻松地为你的应用程序启动一个管理后台——无需（但拥有当然更好）前端开发技能。
+
+管理后台对于运营后端应用程序至关重要。但它通常是事后才想到的，或者没有投入专门的资源（也就是开发人员的时间）来开发它们。
+
+前端工程师通常专注于开发面向消费者的应用程序，这常常导致投入到面向内部的应用程序的 GUI 上的精力不足。
+
+SeaORM Pro 旨在弥合这一差距，提供一种既能快速实施又能在长期使用中保持可靠的解决方案。
+
+在这里了解更多关于 [SeaORM Pro 的信息](https://www.sea-ql.org/sea-orm-pro/docs/introduction/sea-orm-pro/)。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/11-sea-orm-pro/02-getting-started.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/11-sea-orm-pro/02-getting-started.md
new file mode 100644
index 00000000000..77ff4bc9f05
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/11-sea-orm-pro/02-getting-started.md
@@ -0,0 +1,5 @@
+# 入门
+
+[Loco 入门](https://www.sea-ql.org/sea-orm-pro/docs/install-and-config/getting-started-loco/)
+
+[Axum 入门](https://www.sea-ql.org/sea-orm-pro/docs/install-and-config/getting-started-axum/)
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/11-sea-orm-pro/_category_.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/11-sea-orm-pro/_category_.json
new file mode 100644
index 00000000000..f4239916598
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/11-sea-orm-pro/_category_.json
@@ -0,0 +1,4 @@
+{
+  "label": "Admin Panel",
+  "collapsed": false
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/01-trait-and-type.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/01-trait-and-type.md
new file mode 100644
index 00000000000..2025372f489
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/01-trait-and-type.md
@@ -0,0 +1,66 @@
+# Trait 和类型
+
+## Entity
+
+一个实现了 [`EntityTrait`](#) 的单元结构体，代表数据库中的一张表。
+
+该 Trait 包含一个实体的属性，包括：
+- 表名 (实现了 [`EntityName`](#))
+- 列 (实现了 [`ColumnTrait`](#))
+- 关联关系 (实现了 [`RelationTrait`](#))
+- 主键 (实现了 [`PrimaryKeyTrait`](#) 和 [`PrimaryKeyToColumn`](#))
+
+该 Trait 还提供了 CRUD 操作的 API：
+- 查询: `find`, `find_*`
+- 插入: `insert`, `insert_*`
+- 更新: `update`, `update_*`
+- 删除: `delete`, `delete_*`
+
+## Column
+
+一个实现了 [`ColumnTrait`](#) 的枚举，代表表的所有列以及列的类型和属性。
+
+它还实现了：
+- [`IdenStatic`](#) 提供了到具有静态生命周期的列标识符的映射
+- [`Iterable`](#) 允许 SeaORM 内核遍历所有列的变体
+
+## Primary Key
+
+一个实现了 [`PrimaryKeyTrait`](#) 的枚举，代表主键。每个主键变体都必须有一个对应的列变体。
+
+它还实现了：
+- [`IdenStatic`](#) 提供了到具有静态生命周期的主键标识符的映射
+- [`Iterable`](#) 允许 SeaORM 内核遍历所有主键变体
+
+## Model
+
+一个实现了 [`ModelTrait`](#) 的结构体，用于在内存中存储查询结果。它仅用于只读目的，并且是无状态的。
+
+它还实现了：
+- [`FromQueryResult`](#) 将原始查询结果转换为对应的模型
+
+## Active Model
+
+一个实现了 [`ActiveModelTrait`](#) 的结构体，代表插入/更新操作。它可以被编辑并保存到数据库中。
+
+它还实现了：
+- [`ActiveModelBehavior`](#) 为活动模型的不同操作定义了处理程序
+
+## Active Enum
+
+一个实现了 [`ActiveEnum`](#) 的枚举，代表作为 Rust 枚举变体存储在数据库中的值。
+
+## Relation
+
+一个实现了 [`RelationTrait`](#) 的枚举，定义了与其他实体的关联关系。
+
+它还实现了：
+- [`Iterable`](#) 允许 SeaORM 内核遍历所有关联关系变体
+
+## Related
+
+一个泛型 Trait，[`Related`](#)，定义了连接路径，以帮助你一起查询相关的实体，这在多对多关系中特别有用。
+
+## Linked
+
+一个 Trait，[`Linked`](#)，定义了复杂的连接路径，包括链式关联、自引用关联以及两个实体之间的多个关联。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/02-derive-macro.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/02-derive-macro.md
new file mode 100644
index 00000000000..6d25eb75285
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/02-derive-macro.md
@@ -0,0 +1,53 @@
+# 派生宏
+
+## EntityModel
+
+[`EntityModel`](#) 派生宏是“万能”宏，可根据给定的 `Model` 自动生成 `Entity`、`Column` 和 `PrimaryKey`。
+
+## Entity
+
+[`DeriveEntity`](#) 派生宏将为 `Entity` 实现 [`EntityTrait`](#)，并假定 `Model`、`Column`、`PrimaryKey` 和 `Relation` 存在于当前作用域中。它还为 `Entity` 提供了 [`Iden`](#) 和 [`IdenStatic`](#) 的实现。
+
+## Column
+
+[`DeriveColumn`](#) 派生宏将为 `Columns` 实现 [`ColumnTrait`](#)。它通过实现 [`Iden`](#) 和 [`IdenStatic`](#) 来定义每列的标识符。还派生了 [`EnumIter`](#)，从而可以遍历所有枚举变体。
+
+## Primary Key
+
+[`DerivePrimaryKey`](#) 派生宏将为 `PrimaryKey` 实现 [`PrimaryKeyToColumn`](#)，它定义了主键和列之间繁琐的映射。还派生了 [`EnumIter`](#)，从而可以遍历所有枚举变体。
+
+## Model
+
+[`DeriveModel`](#) 派生宏将为 `Model` 实现 [`ModelTrait`](#)，它为模型中的所有属性提供了 setter 和 getter。它还实现了 [`FromQueryResult`](#)，可将查询结果转换为相应的 `Model`。
+
+## Active Model
+
+[`DeriveActiveModel`](#) 派生宏将为 `ActiveModel` 实现 [`ActiveModelTrait`](#)，它为活动模型中的所有活动值提供了 setter 和 getter。
+
+## Partial Model
+
+[`DerivePartialModel`](#) 派生宏将为 `Model` 实现 [`PartialModelTrait`](#)。
+
+## Active Enum
+
+[`DeriveActiveEnum`](#) 派生宏将为任何枚举实现 [`ActiveEnum`](#)。
+
+## Relation
+
+[`DeriveRelation`](#) 派生宏将为 `Relation` 实现 [`RelationTrait`](#)。
+
+## RelatedEntity
+
+当启用 `seaography` 功能时，[`DeriveRelatedEntity`](#) 派生宏将为 `RelatedEntity` 枚举实现 [`seaography::RelationBuilder`](#)。
+
+## Iterable
+
+[`EnumIter`](#) 派生宏将实现 [`Iterable`](#)，以允许遍历所有枚举变体。
+
+## Value Type
+
+[`DeriveValueType`](#) 派生宏将为 `T` 实现 `From<T> for Value`、`sea_orm::TryGetable for T` 和 `sea_query::ValueType for T`。
+
+## Display
+
+[`DeriveDisplay`](#) 派生宏将为枚举实现 `std::fmt::Display`。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/03-diesel.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/03-diesel.md
new file mode 100644
index 00000000000..951740cda49
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/03-diesel.md
@@ -0,0 +1,41 @@
+# 与 Diesel 对比
+
+[SeaORM](https://github.com/SeaQL/sea-orm) 和 [Diesel](https://github.com/diesel-rs/diesel) 有着相同的目标：为你提供与数据库交互的完整解决方案。
+
+SeaORM 和 Diesel 都支持 MySQL、PostgreSQL 和 SQLite，所以你选择任何一个都不会受到限制。Diesel 允许第三方实现自定义后端，而 SeaORM 不支持。
+
+我们还在其他一些方面做出了不同的选择。
+
+## 架构
+
+首先，也许是需求排名第一的功能，即异步 Rust 支持。虽然使用异步在今天可能不会为你带来更好的性能，但在异步中编程是你必须尽早做出的架构决策。通过选择 SeaORM，我们共同期待 Rust 异步生态系统的成熟。
+
+在底层，SeaORM 与 [SQLx](https://crates.io/crates/sqlx) 一起为你提供了一个纯 Rust 技术栈。Diesel 默认使用原生驱动程序，你可能需要花费一些精力才能将其替换为纯 Rust 驱动程序。两者各有优缺点，这取决于你的偏好。
+
+SeaORM 采用模块化设计。如果你不喜欢 ORM 的想法，你肯定仍然会想使用 [SeaQuery](https://crates.io/crates/sea-query)，它是底层的查询构建器。它轻量级，可以轻松集成到任何项目中。使用 SeaORM 时，SeaQuery API 也可供你使用，因此你可以获得高级抽象的好处，同时在需要时仍然拥有灵活查询构建器的强大功能。
+
+## 编程范式
+
+除了同步与异步的基础之外，Diesel 和 SeaORM 之间最大的区别是静态与动态。
+
+Diesel 提供了一个完全在编译时检查类型的 API。你也可以使用 Diesel 进行动态查询，但会失去一些编译时类型检查的好处。
+
+SeaORM 是动态的，其中事物在运行时建立。它提供了更大的灵活性。虽然你失去了一些编译时检查，但 SeaORM 通过测试来帮助你证明正确性。
+
+这两个库都大量使用了 trait 和泛型，但 SeaORM 生成的类型更少：Diesel 中的每一列都是一个结构体（每个结构体都实现了多个 trait），而 SeaORM 中的每一列都是一个枚举变体（一个实体的所有列共同组成一个枚举，该枚举实现了一些 trait）。
+
+SeaORM 中也没有深度嵌套的泛型（例如 `A<B<C<D<E>>>>`）。
+
+## Schema 构建器
+
+虽然在 Diesel 生态系统中有像 [barrel](https://git.irde.st/spacekookie/barrel) 这样很棒的库，但 SeaQL 维护着用于 schema 构建 (SeaQuery) 和管理 ([SeaSchema](https://github.com/SeaQL/sea-schema)) 的工具。这意味着熟悉的 API 和统一的体验。
+
+## 相似之处
+
+Diesel 和 SeaORM 都是 schema 优先的，这意味着一切都从你现有的数据库 schema 开始，而不是从你的 OOP 类开始。
+
+Diesel 和 SeaORM 都是关系型的，这意味着你可以通过定义的关系进行复杂的连接。
+
+## 最后的话
+
+Diesel 是 Rust 生态系统中一个成熟的库。SeaORM 还很新。两者都无法取代对方。我们希望 Rust 社区能够共同成长壮大。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/04-architecture.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/04-architecture.md
new file mode 100644
index 00000000000..cd8510f4fef
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/04-architecture.md
@@ -0,0 +1,43 @@
+# 架构
+
+> 让我们潜入海底 🤿
+
+<img width=&#34;100%&#34; src=&#34;/SeaORM/img/SeaORM Architecture.svg&#34; />
+
+要理解 SeaORM 的架构，我们首先要讨论什么是 ORM。ORM 的存在是为了对数据库的通用操作提供抽象，并隐藏诸如实际 SQL 查询之类的实现细节。
+
+有了一个好的 ORM，你就不应该费心去研究 API 表层之下的东西。直到你需要这样做。我听到你说“抽象泄漏”，是的，它确实会。
+
+SeaORM 采用的方法是“分层抽象”，如果你愿意，可以深入一层。这就是为什么我们把 SeaQuery 做成一个独立的仓库。它本身就很有用，而且有了一个公共的 API 接口和一个独立的命名空间，与单体方法相比，创建令人困惑的内部 API 要困难得多。
+
+SeaORM 的中心思想是几乎所有东西都是运行时可配置的。在编译时，它不知道底层数据库是什么。
+
+数据库无关带来了什么好处？例如，你可以：
+
+1. 让你的应用程序在任何数据库上工作，具体取决于运行时配置
+2. 使用相同的模型并在不同数据库之间迁移
+3. 通过创建一个“数据结构 crate”在不同项目之间共享实体，其中数据库由下游的“行为 crate”选择
+
+SeaORM 的 API 不是一个薄壳，而是由多个层次组成的，每个下层都更不抽象。
+
+API 的使用有不同的阶段。
+
+因此，在 SeaORM 代码库中有两个维度可以导航，“阶段”和“抽象性”。
+
+首先是声明阶段。实体以及它们之间的关系是使用 `EntityTrait`、`ColumnTrait` 和 `RelationTrait` 等定义的。
+
+其次是查询构建阶段。
+
+最顶层是 `Entity` 的 `find*`、`insert`、`update` 和 `delete` 方法，你可以直观地执行基本的 CRUD 操作。
+
+下一层是 `Select`、`Insert`、`Update` 和 `Delete` 结构体，它们各自都有自己的 API 用于更高级的操作。
+
+再下一层是 SeaQuery 的 `SelectStatement`、`InsertStatement`、`UpdateStatement` 和 `DeleteStatement`，它们有丰富的 API 供你摆弄 SQL 语法树。
+
+第三是执行阶段。一组独立的结构体，`Selector`、`Inserter`、`Updater` 和 `Deleter`，负责对数据库连接执行语句。
+
+最后是解析阶段，当查询结果被转换成 Rust 类型并塞进结构体时。随后，如果它是一个关系查询，结构体将根据它们的关系被拼凑在一起。
+
+因为只有执行和解析阶段是数据库特定的，所以我们有可能通过替换它们来使用不同的驱动程序。
+
+我想象有一天，我们将支持许多数据库，它们具有不同的语法、协议和形式。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/05-expanded-entity-format.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/05-expanded-entity-format.md
new file mode 100644
index 00000000000..6cf73c222ab
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/05-expanded-entity-format.md
@@ -0,0 +1,219 @@
+# 展开的实体格式
+
+这是紧凑格式之前的实体格式，现在紧凑格式是默认格式，所有新功能都是在紧凑格式之上添加的。
+
+展开格式被认为是旧格式。但如果你好奇 `DeriveEntityModel` 会扩展成什么，请继续阅读。
+
+可以使用带有 `--expanded-format` 选项的 `sea-orm-cli` 生成展开的实体格式。
+
+让我们来看看展开的 [Cake](https://github.com/SeaQL/sea-orm/blob/master/src/tests_cfg/cake_expanded.rs) 实体的各个部分。
+
+## 实体
+
+通过实现 [`EntityTrait`](https://docs.rs/sea-orm/*/sea_orm/entity/trait.EntityTrait.html)，你可以对给定的表执行 CRUD 操作。
+
+```rust
+#[derive(Copy, Clone, Default, Debug, DeriveEntity)]
+pub struct Entity;
+
+impl EntityName for Entity {
+    fn schema_name(&self) -> Option<&str> {
+        None
+    }
+
+    fn table_name(&self) -> &str {
+        "cake"
+    }
+}
+```
+
+## 列
+
+一个表示此表中所有列的枚举。
+
+```rust
+#[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]
+pub enum Column {
+    Id,
+    Name,
+}
+
+impl ColumnTrait for Column {
+    type EntityName = Entity;
+
+    fn def(&self) -> ColumnDef {
+        match self {
+            Self::Id => ColumnType::Integer.def(),
+            Self::Name => ColumnType::String(StringLen::None).def(),
+        }
+    }
+}
+```
+
+所有列名都假定为蛇形命名法（snake-case）。你可以通过指定 `column_name` 属性来覆盖列名。
+
+```rust
+pub enum Column {
+    Id,      // 映射到 SQL 中的 "id"
+    Name,    // 映射到 SQL 中的 "name"
+    #[sea_orm(column_name = "create_at")]
+    CreateAt // 映射到 SQL 中的 "create_at"
+}
+```
+
+要指定每个列的数据类型，可以使用 [`ColumnType`](https://docs.rs/sea-orm/*/sea_orm/entity/enum.ColumnType.html) 枚举。
+
+### 附加属性
+
+- 默认值
+- 唯一
+- 索引
+- 可为空
+
+```rust
+ColumnType::String(StringLen::None).def().default_value("Sam").unique().indexed().nullable()
+```
+
+### 在选择和保存时转换列类型
+
+如果你需要将列选择为一种类型，但将其作为另一种类型保存到数据库中，你可以覆盖 `select_as` 和 `save_as` 方法来执行转换。一个典型的用例是将 `citext`（不区分大小写的文本）类型的列在 Rust 中选择为 `String`，并将其作为 `citext` 保存到数据库中。应该像下面这样覆盖 `ColumnTrait` 的方法：
+
+```rust
+use sea_orm::sea_query::{Expr, SimpleExpr, Alias}
+
+impl ColumnTrait for Column {
+    // ... 省略 ...
+
+    /// 在 select 语句中使用的列表达式转换。
+    fn select_as(&self, expr: Expr) -> SimpleExpr {
+        match self {
+            Column::CaseInsensitiveText => expr.cast_as("text"),
+            _ => self.select_enum_as(expr),
+        }
+    }
+
+    /// 将列的值转换为正确的类型以进行数据库存储。
+    fn save_as(&self, val: Expr) -> SimpleExpr {
+        match self {
+            Column::CaseInsensitiveText => val.cast_as("citext"),
+            _ => self.save_enum_as(val),
+        }
+    }
+}
+```
+
+## 主键
+
+一个表示此表主键的枚举。复合键由具有多个变体的枚举表示。
+
+`ValueType` 定义了 [`InsertResult`](https://docs.rs/sea-orm/*/sea_orm/struct.InsertResult.html) 中 last_insert_id 的类型。
+
+`auto_increment` 定义了主键是否具有自动生成的值。
+
+```rust
+#[derive(Copy, Clone, Debug, EnumIter, DerivePrimaryKey)]
+pub enum PrimaryKey {
+    #[sea_orm(column_name = "id")] // 覆盖默认列名
+    Id,  // 映射到 SQL 中的 "id"
+}
+
+impl PrimaryKeyTrait for PrimaryKey {
+    type ValueType = i32;
+
+    fn auto_increment() -> bool {
+        true
+    }
+}
+```
+
+复合键示例
+
+```rust
+pub enum PrimaryKey {
+    CakeId,
+    FruitId,
+}
+
+impl PrimaryKeyTrait for PrimaryKey {
+    type ValueType = (i32, i32);
+
+    fn auto_increment() -> bool {
+        false
+    }
+}
+```
+
+## 模型
+
+用于存储查询结果的 Rust 结构体。
+
+```rust
+#[derive(Clone, Debug, PartialEq, Eq, DeriveModel, DeriveActiveModel)]
+pub struct Model {
+    pub id: i32,
+    pub name: String,
+}
+```
+
+### 可为空属性
+
+如果表列可为空，请用 `Option` 包装它。
+
+```rust {3}
+pub struct Model {
+    pub id: i32,
+    pub name: Option<String>,
+}
+```
+
+## 活动模型
+
+`ActiveModel` 具有其相应 `Model` 的所有属性，但所有属性都包装在 [`ActiveValue`](https://docs.rs/sea-orm/*/sea_orm/entity/enum.ActiveValue.html) 中。
+
+```rust
+#[derive(Clone, Debug, PartialEq)]
+pub struct ActiveModel {
+    pub id: ActiveValue<i32>,
+    pub name: ActiveValue<Option<String>>,
+}
+```
+
+## 关系
+
+指定与其他实体的关系。
+
+```rust
+#[derive(Copy, Clone, Debug, EnumIter)]
+pub enum Relation {
+    Fruit,
+}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        match self {
+            Self::Fruit => Entity::has_many(super::fruit::Entity).into(),
+        }
+    }
+}
+```
+
+## 关联
+
+定义 trait 约束以帮助你一起查询相关实体，这在多对多关系中特别有用。
+
+```rust
+impl Related<super::fruit::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Fruit.def()
+    }
+}
+
+impl Related<super::filling::Entity> for Entity {
+    fn to() -> RelationDef {
+        super::cake_filling::Relation::Filling.def()
+    }
+
+    fn via() -> Option<RelationDef> {
+        Some(super::cake_filling::Relation::Cake.def().rev())
+    }
+}
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/_category_.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/_category_.json
new file mode 100644
index 00000000000..4f47c5ac65e
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/12-internal-design/_category_.json
@@ -0,0 +1,4 @@
+{
+  "label": "Internal Design",
+  "collapsed": false
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/13-whats-next/01-whats-next.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/13-whats-next/01-whats-next.md
new file mode 100644
index 00000000000..0d30ae57666
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/13-whats-next/01-whats-next.md
@@ -0,0 +1,7 @@
+# SeaORM 的未来展望
+
+我们仍然记得两年前首次向 Rust 社区[介绍 SeaORM](https://www.sea-ql.org/blog/2021-09-20-introducing-sea-orm/) 的情景。
+
+如今，许多开源项目、初创公司和企业都在使用 SeaORM。如果你的公司正在使用 SeaORM 并希望被推荐，请[提交推荐信](https://forms.office.com/r/YbeqfTAgkJ)。
+
+开源项目是一项永无止境的工作，我们正在积极寻找维持项目的方法。SeaQL.org 是一个由充满热情的开发人员运营的独立开源组织。你可以通过为我们的存储库加星和分享以及通过 [GitHub Sponsor](https://github.com/sponsors/SeaQL) 捐款来支持我们。
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/13-whats-next/_category_.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/13-whats-next/_category_.json
new file mode 100644
index 00000000000..0a52b45f482
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/current/13-whats-next/_category_.json
@@ -0,0 +1,4 @@
+{
+  "label": "What's Next",
+  "collapsed": false
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.10.x.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.10.x.json
new file mode 100644
index 00000000000..46b120a8081
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.10.x.json
@@ -0,0 +1,46 @@
+{
+  "version.label": {
+    "message": "0.10.x",
+    "description": "The label for version 0.10.x"
+  },
+  "sidebar.tutorialSidebar.category.Introduction": {
+    "message": "Introduction",
+    "description": "The label for category Introduction in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Installation & Configuration": {
+    "message": "Installation & Configuration",
+    "description": "The label for category Installation & Configuration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Migration": {
+    "message": "Migration",
+    "description": "The label for category Migration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Entities": {
+    "message": "Generating Entities",
+    "description": "The label for category Generating Entities in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Basic CRUD": {
+    "message": "Basic CRUD",
+    "description": "The label for category Basic CRUD in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Relations": {
+    "message": "Relations",
+    "description": "The label for category Relations in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Writing Tests": {
+    "message": "Writing Tests",
+    "description": "The label for category Writing Tests in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Advanced Queries": {
+    "message": "Advanced Queries",
+    "description": "The label for category Advanced Queries in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating SeaQuery Statement": {
+    "message": "Generating SeaQuery Statement",
+    "description": "The label for category Generating SeaQuery Statement in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Internal Design": {
+    "message": "Internal Design",
+    "description": "The label for category Internal Design in sidebar tutorialSidebar"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.11.x.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.11.x.json
new file mode 100644
index 00000000000..f0ab3555379
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.11.x.json
@@ -0,0 +1,46 @@
+{
+  "version.label": {
+    "message": "0.11.x",
+    "description": "The label for version 0.11.x"
+  },
+  "sidebar.tutorialSidebar.category.Introduction": {
+    "message": "Introduction",
+    "description": "The label for category Introduction in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Installation & Configuration": {
+    "message": "Installation & Configuration",
+    "description": "The label for category Installation & Configuration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Migration": {
+    "message": "Migration",
+    "description": "The label for category Migration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Entities": {
+    "message": "Generating Entities",
+    "description": "The label for category Generating Entities in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Basic CRUD": {
+    "message": "Basic CRUD",
+    "description": "The label for category Basic CRUD in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Relations": {
+    "message": "Relations",
+    "description": "The label for category Relations in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Writing Tests": {
+    "message": "Writing Tests",
+    "description": "The label for category Writing Tests in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Advanced Queries": {
+    "message": "Advanced Queries",
+    "description": "The label for category Advanced Queries in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Schema Statement": {
+    "message": "Schema Statement",
+    "description": "The label for category Schema Statement in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Internal Design": {
+    "message": "Internal Design",
+    "description": "The label for category Internal Design in sidebar tutorialSidebar"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.12.x.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.12.x.json
new file mode 100644
index 00000000000..ea9076a78f5
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.12.x.json
@@ -0,0 +1,54 @@
+{
+  "version.label": {
+    "message": "0.12.x",
+    "description": "The label for version 0.12.x"
+  },
+  "sidebar.tutorialSidebar.category.Introduction": {
+    "message": "Introduction",
+    "description": "The label for category Introduction in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Installation & Configuration": {
+    "message": "Installation & Configuration",
+    "description": "The label for category Installation & Configuration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Migration": {
+    "message": "Migration",
+    "description": "The label for category Migration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Entities": {
+    "message": "Generating Entities",
+    "description": "The label for category Generating Entities in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Basic CRUD": {
+    "message": "Basic CRUD",
+    "description": "The label for category Basic CRUD in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Relations": {
+    "message": "Relations",
+    "description": "The label for category Relations in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Writing Tests": {
+    "message": "Writing Tests",
+    "description": "The label for category Writing Tests in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Advanced Queries": {
+    "message": "Advanced Queries",
+    "description": "The label for category Advanced Queries in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Schema Statement": {
+    "message": "Schema Statement",
+    "description": "The label for category Schema Statement in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Seaography": {
+    "message": "Seaography",
+    "description": "The label for category Seaography in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Internal Design": {
+    "message": "Internal Design",
+    "description": "The label for category Internal Design in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.What's Next": {
+    "message": "What's Next",
+    "description": "The label for category What's Next in sidebar tutorialSidebar"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.4.x.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.4.x.json
new file mode 100644
index 00000000000..dacd3134aaf
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.4.x.json
@@ -0,0 +1,42 @@
+{
+  "version.label": {
+    "message": "0.4.x",
+    "description": "The label for version 0.4.x"
+  },
+  "sidebar.tutorialSidebar.category.Introduction": {
+    "message": "Introduction",
+    "description": "The label for category Introduction in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Installation & Configuration": {
+    "message": "Installation & Configuration",
+    "description": "The label for category Installation & Configuration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Entities": {
+    "message": "Generating Entities",
+    "description": "The label for category Generating Entities in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Database Schema": {
+    "message": "Generating Database Schema",
+    "description": "The label for category Generating Database Schema in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Basic CRUD": {
+    "message": "Basic CRUD",
+    "description": "The label for category Basic CRUD in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Relations": {
+    "message": "Relations",
+    "description": "The label for category Relations in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Writing Tests": {
+    "message": "Writing Tests",
+    "description": "The label for category Writing Tests in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Advanced Queries": {
+    "message": "Advanced Queries",
+    "description": "The label for category Advanced Queries in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Internal Design": {
+    "message": "Internal Design",
+    "description": "The label for category Internal Design in sidebar tutorialSidebar"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.5.x.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.5.x.json
new file mode 100644
index 00000000000..a848c512dda
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.5.x.json
@@ -0,0 +1,42 @@
+{
+  "version.label": {
+    "message": "0.5.x",
+    "description": "The label for version 0.5.x"
+  },
+  "sidebar.tutorialSidebar.category.Introduction": {
+    "message": "Introduction",
+    "description": "The label for category Introduction in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Installation & Configuration": {
+    "message": "Installation & Configuration",
+    "description": "The label for category Installation & Configuration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Entities": {
+    "message": "Generating Entities",
+    "description": "The label for category Generating Entities in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Database Schema": {
+    "message": "Generating Database Schema",
+    "description": "The label for category Generating Database Schema in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Basic CRUD": {
+    "message": "Basic CRUD",
+    "description": "The label for category Basic CRUD in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Relations": {
+    "message": "Relations",
+    "description": "The label for category Relations in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Writing Tests": {
+    "message": "Writing Tests",
+    "description": "The label for category Writing Tests in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Advanced Queries": {
+    "message": "Advanced Queries",
+    "description": "The label for category Advanced Queries in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Internal Design": {
+    "message": "Internal Design",
+    "description": "The label for category Internal Design in sidebar tutorialSidebar"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.6.x.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.6.x.json
new file mode 100644
index 00000000000..21e620dfeab
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.6.x.json
@@ -0,0 +1,46 @@
+{
+  "version.label": {
+    "message": "0.6.x",
+    "description": "The label for version 0.6.x"
+  },
+  "sidebar.tutorialSidebar.category.Introduction": {
+    "message": "Introduction",
+    "description": "The label for category Introduction in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Installation & Configuration": {
+    "message": "Installation & Configuration",
+    "description": "The label for category Installation & Configuration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Entities": {
+    "message": "Generating Entities",
+    "description": "The label for category Generating Entities in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Database Schema": {
+    "message": "Generating Database Schema",
+    "description": "The label for category Generating Database Schema in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Migration": {
+    "message": "Migration",
+    "description": "The label for category Migration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Basic CRUD": {
+    "message": "Basic CRUD",
+    "description": "The label for category Basic CRUD in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Relations": {
+    "message": "Relations",
+    "description": "The label for category Relations in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Writing Tests": {
+    "message": "Writing Tests",
+    "description": "The label for category Writing Tests in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Advanced Queries": {
+    "message": "Advanced Queries",
+    "description": "The label for category Advanced Queries in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Internal Design": {
+    "message": "Internal Design",
+    "description": "The label for category Internal Design in sidebar tutorialSidebar"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.7.x.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.7.x.json
new file mode 100644
index 00000000000..e7f1f9d9105
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.7.x.json
@@ -0,0 +1,46 @@
+{
+  "version.label": {
+    "message": "0.7.x",
+    "description": "The label for version 0.7.x"
+  },
+  "sidebar.tutorialSidebar.category.Introduction": {
+    "message": "Introduction",
+    "description": "The label for category Introduction in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Installation & Configuration": {
+    "message": "Installation & Configuration",
+    "description": "The label for category Installation & Configuration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Entities": {
+    "message": "Generating Entities",
+    "description": "The label for category Generating Entities in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Database Schema": {
+    "message": "Generating Database Schema",
+    "description": "The label for category Generating Database Schema in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Migration": {
+    "message": "Migration",
+    "description": "The label for category Migration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Basic CRUD": {
+    "message": "Basic CRUD",
+    "description": "The label for category Basic CRUD in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Relations": {
+    "message": "Relations",
+    "description": "The label for category Relations in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Writing Tests": {
+    "message": "Writing Tests",
+    "description": "The label for category Writing Tests in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Advanced Queries": {
+    "message": "Advanced Queries",
+    "description": "The label for category Advanced Queries in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Internal Design": {
+    "message": "Internal Design",
+    "description": "The label for category Internal Design in sidebar tutorialSidebar"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.8.x.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.8.x.json
new file mode 100644
index 00000000000..86808b2b749
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.8.x.json
@@ -0,0 +1,46 @@
+{
+  "version.label": {
+    "message": "0.8.x",
+    "description": "The label for version 0.8.x"
+  },
+  "sidebar.tutorialSidebar.category.Introduction": {
+    "message": "Introduction",
+    "description": "The label for category Introduction in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Installation & Configuration": {
+    "message": "Installation & Configuration",
+    "description": "The label for category Installation & Configuration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Entities": {
+    "message": "Generating Entities",
+    "description": "The label for category Generating Entities in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Database Schema": {
+    "message": "Generating Database Schema",
+    "description": "The label for category Generating Database Schema in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Basic CRUD": {
+    "message": "Basic CRUD",
+    "description": "The label for category Basic CRUD in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Migration": {
+    "message": "Migration",
+    "description": "The label for category Migration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Relations": {
+    "message": "Relations",
+    "description": "The label for category Relations in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Writing Tests": {
+    "message": "Writing Tests",
+    "description": "The label for category Writing Tests in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Advanced Queries": {
+    "message": "Advanced Queries",
+    "description": "The label for category Advanced Queries in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Internal Design": {
+    "message": "Internal Design",
+    "description": "The label for category Internal Design in sidebar tutorialSidebar"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.9.x.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.9.x.json
new file mode 100644
index 00000000000..983cdd1b56d
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-0.9.x.json
@@ -0,0 +1,46 @@
+{
+  "version.label": {
+    "message": "0.9.x",
+    "description": "The label for version 0.9.x"
+  },
+  "sidebar.tutorialSidebar.category.Introduction": {
+    "message": "Introduction",
+    "description": "The label for category Introduction in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Installation & Configuration": {
+    "message": "Installation & Configuration",
+    "description": "The label for category Installation & Configuration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Migration": {
+    "message": "Migration",
+    "description": "The label for category Migration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Entities": {
+    "message": "Generating Entities",
+    "description": "The label for category Generating Entities in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Basic CRUD": {
+    "message": "Basic CRUD",
+    "description": "The label for category Basic CRUD in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Relations": {
+    "message": "Relations",
+    "description": "The label for category Relations in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Writing Tests": {
+    "message": "Writing Tests",
+    "description": "The label for category Writing Tests in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Advanced Queries": {
+    "message": "Advanced Queries",
+    "description": "The label for category Advanced Queries in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating SeaQuery Statement": {
+    "message": "Generating SeaQuery Statement",
+    "description": "The label for category Generating SeaQuery Statement in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Internal Design": {
+    "message": "Internal Design",
+    "description": "The label for category Internal Design in sidebar tutorialSidebar"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-1.0.x.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-1.0.x.json
new file mode 100644
index 00000000000..09f7e60fe26
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-1.0.x.json
@@ -0,0 +1,54 @@
+{
+  "version.label": {
+    "message": "1.0.x",
+    "description": "The label for version 1.0.x"
+  },
+  "sidebar.tutorialSidebar.category.Introduction": {
+    "message": "Introduction",
+    "description": "The label for category Introduction in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Installation & Configuration": {
+    "message": "Installation & Configuration",
+    "description": "The label for category Installation & Configuration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Migration": {
+    "message": "Migration",
+    "description": "The label for category Migration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Entities": {
+    "message": "Generating Entities",
+    "description": "The label for category Generating Entities in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Basic CRUD": {
+    "message": "Basic CRUD",
+    "description": "The label for category Basic CRUD in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Relations": {
+    "message": "Relations",
+    "description": "The label for category Relations in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Writing Tests": {
+    "message": "Writing Tests",
+    "description": "The label for category Writing Tests in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Advanced Queries": {
+    "message": "Advanced Queries",
+    "description": "The label for category Advanced Queries in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Schema Statement": {
+    "message": "Schema Statement",
+    "description": "The label for category Schema Statement in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Seaography": {
+    "message": "Seaography",
+    "description": "The label for category Seaography in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Internal Design": {
+    "message": "Internal Design",
+    "description": "The label for category Internal Design in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.What's Next": {
+    "message": "What's Next",
+    "description": "The label for category What's Next in sidebar tutorialSidebar"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-1.1.x.json b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-1.1.x.json
new file mode 100644
index 00000000000..77cd6313cfa
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-docs/version-1.1.x.json
@@ -0,0 +1,58 @@
+{
+  "version.label": {
+    "message": "1.1.x",
+    "description": "The label for version 1.1.x"
+  },
+  "sidebar.tutorialSidebar.category.Introduction": {
+    "message": "Introduction",
+    "description": "The label for category Introduction in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Installation & Configuration": {
+    "message": "Installation & Configuration",
+    "description": "The label for category Installation & Configuration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Migration": {
+    "message": "Migration",
+    "description": "The label for category Migration in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Generating Entities": {
+    "message": "Generating Entities",
+    "description": "The label for category Generating Entities in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Basic CRUD": {
+    "message": "Basic CRUD",
+    "description": "The label for category Basic CRUD in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Relations": {
+    "message": "Relations",
+    "description": "The label for category Relations in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Writing Tests": {
+    "message": "Writing Tests",
+    "description": "The label for category Writing Tests in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Advanced Queries": {
+    "message": "Advanced Queries",
+    "description": "The label for category Advanced Queries in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Schema Statement": {
+    "message": "Schema Statement",
+    "description": "The label for category Schema Statement in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.GraphQL Support": {
+    "message": "GraphQL Support",
+    "description": "The label for category GraphQL Support in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Admin Panel": {
+    "message": "Admin Panel",
+    "description": "The label for category Admin Panel in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.Internal Design": {
+    "message": "Internal Design",
+    "description": "The label for category Internal Design in sidebar tutorialSidebar"
+  },
+  "sidebar.tutorialSidebar.category.What's Next": {
+    "message": "What's Next",
+    "description": "The label for category What's Next in sidebar tutorialSidebar"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-pages/about-us.md b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-pages/about-us.md
new file mode 100644
index 00000000000..46e6b9e4181
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-plugin-content-pages/about-us.md
@@ -0,0 +1,11 @@
+# About Us
+
+We are a small team of passionate Rust engineers. Seeing the potential of Rust to become one of the most important languages of our era, we sought to improve the data engineering toolings to make it a reality.
+
+Rust is not just a programming language. It's a set of open-source values, an approach to software engineering, an ecosystem for libraries, but most importantly, a community for programmers like us to collaborate and thrive.
+
+If you decided to develop software in Rust, that piece of software must be important to you, and other people. So much so you are willing to design it delicately and maintain it long term.
+
+If you decided to contribute to Rust, then you truely believe in that sharing knowledge and experience will benefit others in the community and in turn ourselves.
+
+Welcome to the community! You are also one of us.
\ No newline at end of file
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-theme-classic/footer.json b/SeaORM/i18n/zh-Hans/docusaurus-theme-classic/footer.json
new file mode 100644
index 00000000000..17fb1e49e36
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-theme-classic/footer.json
@@ -0,0 +1,58 @@
+{
+  "link.title.Docs": {
+    "message": "Docs",
+    "description": "The title of the footer links column with title=Docs in the footer"
+  },
+  "link.title.Community": {
+    "message": "Community",
+    "description": "The title of the footer links column with title=Community in the footer"
+  },
+  "link.title.More": {
+    "message": "More",
+    "description": "The title of the footer links column with title=More in the footer"
+  },
+  "link.item.label.Getting Started": {
+    "message": "Getting Started",
+    "description": "The label of footer link with label=Getting Started linking to /docs/index"
+  },
+  "link.item.label.SeaORM Tutorial": {
+    "message": "SeaORM Tutorial",
+    "description": "The label of footer link with label=SeaORM Tutorial linking to https://www.sea-ql.org/sea-orm-tutorial/"
+  },
+  "link.item.label.SeaORM Cookbook": {
+    "message": "SeaORM Cookbook",
+    "description": "The label of footer link with label=SeaORM Cookbook linking to https://www.sea-ql.org/sea-orm-cookbook/"
+  },
+  "link.item.label.API Reference": {
+    "message": "API Reference",
+    "description": "The label of footer link with label=API Reference linking to https://docs.rs/sea-orm/latest/sea_orm/"
+  },
+  "link.item.label.GitHub": {
+    "message": "GitHub",
+    "description": "The label of footer link with label=GitHub linking to https://github.com/SeaQL/sea-orm/discussions"
+  },
+  "link.item.label.Discord": {
+    "message": "Discord",
+    "description": "The label of footer link with label=Discord linking to https://discord.com/invite/uCPdDXzbdv"
+  },
+  "link.item.label.Twitter": {
+    "message": "Twitter",
+    "description": "The label of footer link with label=Twitter linking to https://twitter.com/sea_ql"
+  },
+  "link.item.label.Blog": {
+    "message": "Blog",
+    "description": "The label of footer link with label=Blog linking to https://www.sea-ql.org/blog/"
+  },
+  "link.item.label.About Us": {
+    "message": "About Us",
+    "description": "The label of footer link with label=About Us linking to /about-us"
+  },
+  "link.item.label.Seaography": {
+    "message": "Seaography",
+    "description": "The label of footer link with label=Seaography linking to https://www.sea-ql.org/Seaography/"
+  },
+  "copyright": {
+    "message": "<br/><a href=\"https://github.com/SeaQL/sea-orm/stargazers/\" target=\"_blank\"><img src=\"https://img.shields.io/github/stars/SeaQL/sea-orm.svg?style=social&label=Star\"/></a><br/>Every ⭐ counts!<br/>SeaQL.org © 2025 🇬🇧",
+    "description": "The footer copyright"
+  }
+}
diff --git a/SeaORM/i18n/zh-Hans/docusaurus-theme-classic/navbar.json b/SeaORM/i18n/zh-Hans/docusaurus-theme-classic/navbar.json
new file mode 100644
index 00000000000..745f55dcd85
--- /dev/null
+++ b/SeaORM/i18n/zh-Hans/docusaurus-theme-classic/navbar.json
@@ -0,0 +1,34 @@
+{
+  "title": {
+    "message": "SeaORM",
+    "description": "The title in the navbar"
+  },
+  "logo.alt": {
+    "message": "SeaORM Logo",
+    "description": "The alt text of navbar logo"
+  },
+  "item.label.Docs": {
+    "message": "Docs",
+    "description": "Navbar item with label Docs"
+  },
+  "item.label.Blog": {
+    "message": "Blog",
+    "description": "Navbar item with label Blog"
+  },
+  "item.label.Tutorial": {
+    "message": "Tutorial",
+    "description": "Navbar item with label Tutorial"
+  },
+  "item.label.Cookbook": {
+    "message": "Cookbook",
+    "description": "Navbar item with label Cookbook"
+  },
+  "item.label.Crate": {
+    "message": "Crate",
+    "description": "Navbar item with label Crate"
+  },
+  "item.label.GitHub": {
+    "message": "GitHub",
+    "description": "Navbar item with label GitHub"
+  }
+}