This is an automated email from the ASF dual-hosted git repository.
yihua pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/hudi.git
The following commit(s) were added to refs/heads/asf-site by this push:
new da5f87667a [DOCS] Fix typos in query types (#6008)
da5f87667a is described below
commit da5f87667a5b3181b9134635bf06ebedb97c3b13
Author: 董可伦 <[email protected]>
AuthorDate: Fri Jul 1 02:33:57 2022 +0800
[DOCS] Fix typos in query types (#6008)
---
content/assets/js/43d31177.43d23fab.js | 2 +-
content/cn/docs/0.5.0/concepts/index.html | 2 +-
content/cn/docs/0.5.1/concepts/index.html | 2 +-
content/cn/docs/0.5.2/concepts/index.html | 2 +-
content/cn/docs/0.5.3/concepts/index.html | 2 +-
content/cn/docs/0.6.0/concepts/index.html | 2 +-
content/cn/docs/0.7.0/overview/index.html | 2 +-
content/cn/docs/0.8.0/overview/index.html | 2 +-
content/cn/docs/0.9.0/concepts/index.html | 2 +-
content/cn/docs/0.9.0/overview/index.html | 2 +-
content/cn/docs/next/concepts/index.html | 2 +-
content/cn/docs/next/overview/index.html | 2 +-
content/docs/0.5.0/concepts/index.html | 2 +-
.../i18n/cn/docusaurus-plugin-content-docs/current/concepts.md | 8 ++++----
.../i18n/cn/docusaurus-plugin-content-docs/current/overview.md | 4 ++--
.../cn/docusaurus-plugin-content-docs/version-0.5.0/concepts.md | 4 ++--
.../cn/docusaurus-plugin-content-docs/version-0.5.1/concepts.md | 4 ++--
.../cn/docusaurus-plugin-content-docs/version-0.5.2/concepts.md | 4 ++--
.../cn/docusaurus-plugin-content-docs/version-0.5.3/concepts.md | 4 ++--
.../cn/docusaurus-plugin-content-docs/version-0.6.0/concepts.md | 4 ++--
.../cn/docusaurus-plugin-content-docs/version-0.7.0/overview.md | 4 ++--
.../cn/docusaurus-plugin-content-docs/version-0.8.0/overview.md | 4 ++--
.../cn/docusaurus-plugin-content-docs/version-0.9.0/concepts.md | 4 ++--
.../cn/docusaurus-plugin-content-docs/version-0.9.0/overview.md | 4 ++--
website/versioned_docs/version-0.5.0/concepts.md | 4 ++--
25 files changed, 39 insertions(+), 39 deletions(-)
diff --git a/content/assets/js/43d31177.43d23fab.js
b/content/assets/js/43d31177.43d23fab.js
index 9837c9d929..c64748d5b0 100644
--- a/content/assets/js/43d31177.43d23fab.js
+++ b/content/assets/js/43d31177.43d23fab.js
@@ -1 +1 @@
-"use
strict";(self.webpackChunkhudi=self.webpackChunkhudi||[]).push([[83660],{3905:(e,t,a)=>{a.d(t,{Zo:()=>p,kt:()=>u});var
n=a(67294);function i(e,t,a){return t in
e?Object.defineProperty(e,t,{value:a,enumerable:!0,configurable:!0,writable:!0}):e[t]=a,e}function
r(e,t){var a=Object.keys(e);if(Object.getOwnPropertySymbols){var
n=Object.getOwnPropertySymbols(e);t&&(n=n.filter((function(t){return
Object.getOwnPropertyDescriptor(e,t).enumerable}))),a.push.apply(a,n)}return
a}function o(e){f [...]
\ No newline at end of file
+"use
strict";(self.webpackChunkhudi=self.webpackChunkhudi||[]).push([[83660],{3905:(e,t,a)=>{a.d(t,{Zo:()=>p,kt:()=>u});var
n=a(67294);function i(e,t,a){return t in
e?Object.defineProperty(e,t,{value:a,enumerable:!0,configurable:!0,writable:!0}):e[t]=a,e}function
r(e,t){var a=Object.keys(e);if(Object.getOwnPropertySymbols){var
n=Object.getOwnPropertySymbols(e);t&&(n=n.filter((function(t){return
Object.getOwnPropertyDescriptor(e,t).enumerable}))),a.push.apply(a,n)}return
a}function o(e){f [...]
\ No newline at end of file
diff --git a/content/cn/docs/0.5.0/concepts/index.html
b/content/cn/docs/0.5.0/concepts/index.html
index e0d0af6772..bd3b129ade 100644
--- a/content/cn/docs/0.5.0/concepts/index.html
+++ b/content/cn/docs/0.5.0/concepts/index.html
@@ -22,7 +22,7 @@
每个文件组包含多个<code>文件切片</code>，其中每个切片包含在某个提交/压缩即时时间生成的基本列文件（<code>*.parquet</code>）以及一组日志文件（<code>*.log*</code>），该文件包含自生成基本文件以来对基本文件的插入/更新。
Hudi采用MVCC设计，其中压缩操作将日志和基本文件合并以产生新的文件片，而清理操作则将未使用的/较旧的文件片删除以回收DFS上的空间。</p><p>Hudi通过索引机制将给定的hoodie键（记录键+分区路径）映射到文件组，从而提供了高效的Upsert。
一旦将记录的第一个版本写入文件，记录键和文件组/文件id之间的映射就永远不会改变。 简而言之，映射的文件组包含一组记录的所有版本。</p><h2
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型和视图">存储类型和视图<a
class="hash-link" href="#存储类型和视图" title="Direct link to
heading"></a></h2><p>Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如何在这种组织之上实现上述原语和时间轴活动（即如何写入数据）。
-反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>读优化
+ 增量</td></tr><tr><td>读时合并</td><td>读优化 + 增量 + 近实时</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
+反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>近实时
+ 增量</td></tr><tr><td>读时合并</td><td>近实时 + 增量 + 读优化</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
该视图仅将最新文件切片中的基本/列文件暴露给查询，并保证与非Hudi列式数据集相比，具有相同的列式查询性能。</li><li><strong>增量视图</strong>
:
对该视图的查询只能看到从某个提交/压缩后写入数据集的新数据。该视图有效地提供了更改流，来支持增量数据管道。</li><li><strong>实时视图</strong>
:
在此视图上的查询将查看某个增量提交操作中数据集的最新快照。该视图通过动态合并最新的基本文件(例如parquet)和增量文件(例如avro)来提供近实时数据集（几分钟的延迟）。</li></ul><p>下表总结了不同视图之间的权衡。</p><table><thead><tr><th>权衡</th><th>读优化</th><th>实时</th></tr></thead><tbody><tr><td>数据延迟</td><td>更高</td><td>更低</td></tr><tr><td>查询延迟</td><td>更低（原始列式性能）</td><td>更高（合并列式
+ 基于行的增量）</td></tr></tbody></table>< [...]
换句话说，我们压缩每个提交，从而所有的数据都是以列数据的形式储存。在这种情况下，写入数据非常昂贵（我们需要重写整个列数据文件，即使只有一个字节的新数据被提交），而读取数据的成本则没有增加。
这种视图有利于读取繁重的分析工作。</p><p>以下内容说明了将数据写入写时复制存储并在其上运行两个查询时，它是如何工作的。</p><figure><img
class="docimage" src="/assets/images/hudi_cow.png"
alt="hudi_cow.png"></figure><p>随着数据的写入，对现有文件组的更新将为该文件组生成一个带有提交即时时间标记的新切片，而插入分配一个新文件组并写入该文件组的第一个切片。
diff --git a/content/cn/docs/0.5.1/concepts/index.html
b/content/cn/docs/0.5.1/concepts/index.html
index 42c4e822e1..74dc3975cb 100644
--- a/content/cn/docs/0.5.1/concepts/index.html
+++ b/content/cn/docs/0.5.1/concepts/index.html
@@ -22,7 +22,7 @@
每个文件组包含多个<code>文件切片</code>，其中每个切片包含在某个提交/压缩即时时间生成的基本列文件（<code>*.parquet</code>）以及一组日志文件（<code>*.log*</code>），该文件包含自生成基本文件以来对基本文件的插入/更新。
Hudi采用MVCC设计，其中压缩操作将日志和基本文件合并以产生新的文件片，而清理操作则将未使用的/较旧的文件片删除以回收DFS上的空间。</p><p>Hudi通过索引机制将给定的hoodie键（记录键+分区路径）映射到文件组，从而提供了高效的Upsert。
一旦将记录的第一个版本写入文件，记录键和文件组/文件id之间的映射就永远不会改变。 简而言之，映射的文件组包含一组记录的所有版本。</p><h2
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型和视图">存储类型和视图<a
class="hash-link" href="#存储类型和视图" title="Direct link to
heading"></a></h2><p>Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如何在这种组织之上实现上述原语和时间轴活动（即如何写入数据）。
-反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>读优化
+ 增量</td></tr><tr><td>读时合并</td><td>读优化 + 增量 + 近实时</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
+反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>近实时
+ 增量</td></tr><tr><td>读时合并</td><td>近实时 + 增量 + 读优化</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
该视图仅将最新文件切片中的基本/列文件暴露给查询，并保证与非Hudi列式数据集相比，具有相同的列式查询性能。</li><li><strong>增量视图</strong>
:
对该视图的查询只能看到从某个提交/压缩后写入数据集的新数据。该视图有效地提供了更改流，来支持增量数据管道。</li><li><strong>实时视图</strong>
:
在此视图上的查询将查看某个增量提交操作中数据集的最新快照。该视图通过动态合并最新的基本文件(例如parquet)和增量文件(例如avro)来提供近实时数据集（几分钟的延迟）。</li></ul><p>下表总结了不同视图之间的权衡。</p><table><thead><tr><th>权衡</th><th>读优化</th><th>实时</th></tr></thead><tbody><tr><td>数据延迟</td><td>更高</td><td>更低</td></tr><tr><td>查询延迟</td><td>更低（原始列式性能）</td><td>更高（合并列式
+ 基于行的增量）</td></tr></tbody></table>< [...]
换句话说，我们压缩每个提交，从而所有的数据都是以列数据的形式储存。在这种情况下，写入数据非常昂贵（我们需要重写整个列数据文件，即使只有一个字节的新数据被提交），而读取数据的成本则没有增加。
这种视图有利于读取繁重的分析工作。</p><p>以下内容说明了将数据写入写时复制存储并在其上运行两个查询时，它是如何工作的。</p><figure><img
class="docimage" src="/assets/images/hudi_cow.png"
alt="hudi_cow.png"></figure><p>随着数据的写入，对现有文件组的更新将为该文件组生成一个带有提交即时时间标记的新切片，而插入分配一个新文件组并写入该文件组的第一个切片。
diff --git a/content/cn/docs/0.5.2/concepts/index.html
b/content/cn/docs/0.5.2/concepts/index.html
index b730be6f32..2a8093ced2 100644
--- a/content/cn/docs/0.5.2/concepts/index.html
+++ b/content/cn/docs/0.5.2/concepts/index.html
@@ -22,7 +22,7 @@
每个文件组包含多个<code>文件切片</code>，其中每个切片包含在某个提交/压缩即时时间生成的基本列文件（<code>*.parquet</code>）以及一组日志文件（<code>*.log*</code>），该文件包含自生成基本文件以来对基本文件的插入/更新。
Hudi采用MVCC设计，其中压缩操作将日志和基本文件合并以产生新的文件片，而清理操作则将未使用的/较旧的文件片删除以回收DFS上的空间。</p><p>Hudi通过索引机制将给定的hoodie键（记录键+分区路径）映射到文件组，从而提供了高效的Upsert。
一旦将记录的第一个版本写入文件，记录键和文件组/文件id之间的映射就永远不会改变。 简而言之，映射的文件组包含一组记录的所有版本。</p><h2
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型和视图">存储类型和视图<a
class="hash-link" href="#存储类型和视图" title="Direct link to
heading"></a></h2><p>Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如何在这种组织之上实现上述原语和时间轴活动（即如何写入数据）。
-反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>读优化
+ 增量</td></tr><tr><td>读时合并</td><td>读优化 + 增量 + 近实时</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
+反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>近实时
+ 增量</td></tr><tr><td>读时合并</td><td>近实时 + 增量 + 读优化</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
该视图仅将最新文件切片中的基本/列文件暴露给查询，并保证与非Hudi列式数据集相比，具有相同的列式查询性能。</li><li><strong>增量视图</strong>
:
对该视图的查询只能看到从某个提交/压缩后写入数据集的新数据。该视图有效地提供了更改流，来支持增量数据管道。</li><li><strong>实时视图</strong>
:
在此视图上的查询将查看某个增量提交操作中数据集的最新快照。该视图通过动态合并最新的基本文件(例如parquet)和增量文件(例如avro)来提供近实时数据集（几分钟的延迟）。</li></ul><p>下表总结了不同视图之间的权衡。</p><table><thead><tr><th>权衡</th><th>读优化</th><th>实时</th></tr></thead><tbody><tr><td>数据延迟</td><td>更高</td><td>更低</td></tr><tr><td>查询延迟</td><td>更低（原始列式性能）</td><td>更高（合并列式
+ 基于行的增量）</td></tr></tbody></table>< [...]
换句话说，我们压缩每个提交，从而所有的数据都是以列数据的形式储存。在这种情况下，写入数据非常昂贵（我们需要重写整个列数据文件，即使只有一个字节的新数据被提交），而读取数据的成本则没有增加。
这种视图有利于读取繁重的分析工作。</p><p>以下内容说明了将数据写入写时复制存储并在其上运行两个查询时，它是如何工作的。</p><figure><img
class="docimage" src="/assets/images/hudi_cow.png"
alt="hudi_cow.png"></figure><p>随着数据的写入，对现有文件组的更新将为该文件组生成一个带有提交即时时间标记的新切片，而插入分配一个新文件组并写入该文件组的第一个切片。
diff --git a/content/cn/docs/0.5.3/concepts/index.html
b/content/cn/docs/0.5.3/concepts/index.html
index e5bdd9250e..ec045658f9 100644
--- a/content/cn/docs/0.5.3/concepts/index.html
+++ b/content/cn/docs/0.5.3/concepts/index.html
@@ -22,7 +22,7 @@
每个文件组包含多个<code>文件切片</code>，其中每个切片包含在某个提交/压缩即时时间生成的基本列文件（<code>*.parquet</code>）以及一组日志文件（<code>*.log*</code>），该文件包含自生成基本文件以来对基本文件的插入/更新。
Hudi采用MVCC设计，其中压缩操作将日志和基本文件合并以产生新的文件片，而清理操作则将未使用的/较旧的文件片删除以回收DFS上的空间。</p><p>Hudi通过索引机制将给定的hoodie键（记录键+分区路径）映射到文件组，从而提供了高效的Upsert。
一旦将记录的第一个版本写入文件，记录键和文件组/文件id之间的映射就永远不会改变。 简而言之，映射的文件组包含一组记录的所有版本。</p><h2
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型和视图">存储类型和视图<a
class="hash-link" href="#存储类型和视图" title="Direct link to
heading"></a></h2><p>Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如何在这种组织之上实现上述原语和时间轴活动（即如何写入数据）。
-反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>读优化
+ 增量</td></tr><tr><td>读时合并</td><td>读优化 + 增量 + 近实时</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
+反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>近实时
+ 增量</td></tr><tr><td>读时合并</td><td>近实时 + 增量 + 读优化</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
该视图仅将最新文件切片中的基本/列文件暴露给查询，并保证与非Hudi列式数据集相比，具有相同的列式查询性能。</li><li><strong>增量视图</strong>
:
对该视图的查询只能看到从某个提交/压缩后写入数据集的新数据。该视图有效地提供了更改流，来支持增量数据管道。</li><li><strong>实时视图</strong>
:
在此视图上的查询将查看某个增量提交操作中数据集的最新快照。该视图通过动态合并最新的基本文件(例如parquet)和增量文件(例如avro)来提供近实时数据集（几分钟的延迟）。</li></ul><p>下表总结了不同视图之间的权衡。</p><table><thead><tr><th>权衡</th><th>读优化</th><th>实时</th></tr></thead><tbody><tr><td>数据延迟</td><td>更高</td><td>更低</td></tr><tr><td>查询延迟</td><td>更低（原始列式性能）</td><td>更高（合并列式
+ 基于行的增量）</td></tr></tbody></table>< [...]
换句话说，我们压缩每个提交，从而所有的数据都是以列数据的形式储存。在这种情况下，写入数据非常昂贵（我们需要重写整个列数据文件，即使只有一个字节的新数据被提交），而读取数据的成本则没有增加。
这种视图有利于读取繁重的分析工作。</p><p>以下内容说明了将数据写入写时复制存储并在其上运行两个查询时，它是如何工作的。</p><figure><img
class="docimage" src="/assets/images/hudi_cow.png"
alt="hudi_cow.png"></figure><p>随着数据的写入，对现有文件组的更新将为该文件组生成一个带有提交即时时间标记的新切片，而插入分配一个新文件组并写入该文件组的第一个切片。
diff --git a/content/cn/docs/0.6.0/concepts/index.html
b/content/cn/docs/0.6.0/concepts/index.html
index 6e28354aa1..48251de1fa 100644
--- a/content/cn/docs/0.6.0/concepts/index.html
+++ b/content/cn/docs/0.6.0/concepts/index.html
@@ -22,7 +22,7 @@
每个文件组包含多个<code>文件切片</code>，其中每个切片包含在某个提交/压缩即时时间生成的基本列文件（<code>*.parquet</code>）以及一组日志文件（<code>*.log*</code>），该文件包含自生成基本文件以来对基本文件的插入/更新。
Hudi采用MVCC设计，其中压缩操作将日志和基本文件合并以产生新的文件片，而清理操作则将未使用的/较旧的文件片删除以回收DFS上的空间。</p><p>Hudi通过索引机制将给定的hoodie键（记录键+分区路径）映射到文件组，从而提供了高效的Upsert。
一旦将记录的第一个版本写入文件，记录键和文件组/文件id之间的映射就永远不会改变。 简而言之，映射的文件组包含一组记录的所有版本。</p><h2
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型和视图">存储类型和视图<a
class="hash-link" href="#存储类型和视图" title="Direct link to
heading"></a></h2><p>Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如何在这种组织之上实现上述原语和时间轴活动（即如何写入数据）。
-反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>读优化
+ 增量</td></tr><tr><td>读时合并</td><td>读优化 + 增量 + 近实时</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
+反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>近实时
+ 增量</td></tr><tr><td>读时合并</td><td>近实时 + 增量 + 读优化</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
该视图仅将最新文件切片中的基本/列文件暴露给查询，并保证与非Hudi列式数据集相比，具有相同的列式查询性能。</li><li><strong>增量视图</strong>
:
对该视图的查询只能看到从某个提交/压缩后写入数据集的新数据。该视图有效地提供了更改流，来支持增量数据管道。</li><li><strong>实时视图</strong>
:
在此视图上的查询将查看某个增量提交操作中数据集的最新快照。该视图通过动态合并最新的基本文件(例如parquet)和增量文件(例如avro)来提供近实时数据集（几分钟的延迟）。</li></ul><p>下表总结了不同视图之间的权衡。</p><table><thead><tr><th>权衡</th><th>读优化</th><th>实时</th></tr></thead><tbody><tr><td>数据延迟</td><td>更高</td><td>更低</td></tr><tr><td>查询延迟</td><td>更低（原始列式性能）</td><td>更高（合并列式
+ 基于行的增量）</td></tr></tbody></table>< [...]
换句话说，我们压缩每个提交，从而所有的数据都是以列数据的形式储存。在这种情况下，写入数据非常昂贵（我们需要重写整个列数据文件，即使只有一个字节的新数据被提交），而读取数据的成本则没有增加。
这种视图有利于读取繁重的分析工作。</p><p>以下内容说明了将数据写入写时复制存储并在其上运行两个查询时，它是如何工作的。</p><figure><img
class="docimage" src="/assets/images/hudi_cow.png"
alt="hudi_cow.png"></figure><p>随着数据的写入，对现有文件组的更新将为该文件组生成一个带有提交即时时间标记的新切片，而插入分配一个新文件组并写入该文件组的第一个切片。
diff --git a/content/cn/docs/0.7.0/overview/index.html
b/content/cn/docs/0.7.0/overview/index.html
index 5169222416..19a5a9a876 100644
--- a/content/cn/docs/0.7.0/overview/index.html
+++ b/content/cn/docs/0.7.0/overview/index.html
@@ -22,7 +22,7 @@
每个文件组包含多个<code>文件切片</code>，其中每个切片包含在某个提交/压缩即时时间生成的基本列文件（<code>*.parquet</code>）以及一组日志文件（<code>*.log*</code>），该文件包含自生成基本文件以来对基本文件的插入/更新。
Hudi采用MVCC设计，其中压缩操作将日志和基本文件合并以产生新的文件片，而清理操作则将未使用的/较旧的文件片删除以回收DFS上的空间。</p><p>Hudi通过索引机制将给定的hoodie键（记录键+分区路径）映射到文件组，从而提供了高效的Upsert。
一旦将记录的第一个版本写入文件，记录键和文件组/文件id之间的映射就永远不会改变。 简而言之，映射的文件组包含一组记录的所有版本。</p><h2
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型和视图">存储类型和视图<a
class="hash-link" href="#存储类型和视图" title="Direct link to
heading"></a></h2><p>Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如何在这种组织之上实现上述原语和时间轴活动（即如何写入数据）。
-反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>读优化
+ 增量</td></tr><tr><td>读时合并</td><td>读优化 + 增量 + 近实时</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
+反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>近实时
+ 增量</td></tr><tr><td>读时合并</td><td>近实时 + 增量 + 读优化</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
该视图仅将最新文件切片中的基本/列文件暴露给查询，并保证与非Hudi列式数据集相比，具有相同的列式查询性能。</li><li><strong>增量视图</strong>
:
对该视图的查询只能看到从某个提交/压缩后写入数据集的新数据。该视图有效地提供了更改流，来支持增量数据管道。</li><li><strong>实时视图</strong>
:
在此视图上的查询将查看某个增量提交操作中数据集的最新快照。该视图通过动态合并最新的基本文件(例如parquet)和增量文件(例如avro)来提供近实时数据集（几分钟的延迟）。</li></ul><p>下表总结了不同视图之间的权衡。</p><table><thead><tr><th>权衡</th><th>读优化</th><th>实时</th></tr></thead><tbody><tr><td>数据延迟</td><td>更高</td><td>更低</td></tr><tr><td>查询延迟</td><td>更低（原始列式性能）</td><td>更高（合并列式
+ 基于行的增量）</td></tr></tbody></table>< [...]
换句话说，我们压缩每个提交，从而所有的数据都是以列数据的形式储存。在这种情况下，写入数据非常昂贵（我们需要重写整个列数据文件，即使只有一个字节的新数据被提交），而读取数据的成本则没有增加。
这种视图有利于读取繁重的分析工作。</p><p>以下内容说明了将数据写入写时复制存储并在其上运行两个查询时，它是如何工作的。</p><figure><img
class="docimage" src="/assets/images/hudi_cow.png"
alt="hudi_cow.png"></figure><p>随着数据的写入，对现有文件组的更新将为该文件组生成一个带有提交即时时间标记的新切片，而插入分配一个新文件组并写入该文件组的第一个切片。
diff --git a/content/cn/docs/0.8.0/overview/index.html
b/content/cn/docs/0.8.0/overview/index.html
index de47b6457c..abaab2868a 100644
--- a/content/cn/docs/0.8.0/overview/index.html
+++ b/content/cn/docs/0.8.0/overview/index.html
@@ -22,7 +22,7 @@
每个文件组包含多个<code>文件切片</code>，其中每个切片包含在某个提交/压缩即时时间生成的基本列文件（<code>*.parquet</code>）以及一组日志文件（<code>*.log*</code>），该文件包含自生成基本文件以来对基本文件的插入/更新。
Hudi采用MVCC设计，其中压缩操作将日志和基本文件合并以产生新的文件片，而清理操作则将未使用的/较旧的文件片删除以回收DFS上的空间。</p><p>Hudi通过索引机制将给定的hoodie键（记录键+分区路径）映射到文件组，从而提供了高效的Upsert。
一旦将记录的第一个版本写入文件，记录键和文件组/文件id之间的映射就永远不会改变。 简而言之，映射的文件组包含一组记录的所有版本。</p><h2
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型和视图">存储类型和视图<a
class="hash-link" href="#存储类型和视图" title="Direct link to
heading"></a></h2><p>Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如何在这种组织之上实现上述原语和时间轴活动（即如何写入数据）。
-反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>读优化
+ 增量</td></tr><tr><td>读时合并</td><td>读优化 + 增量 + 近实时</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
+反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>近实时
+ 增量</td></tr><tr><td>读时合并</td><td>近实时 + 增量 + 读优化</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
该视图仅将最新文件切片中的基本/列文件暴露给查询，并保证与非Hudi列式数据集相比，具有相同的列式查询性能。</li><li><strong>增量视图</strong>
:
对该视图的查询只能看到从某个提交/压缩后写入数据集的新数据。该视图有效地提供了更改流，来支持增量数据管道。</li><li><strong>实时视图</strong>
:
在此视图上的查询将查看某个增量提交操作中数据集的最新快照。该视图通过动态合并最新的基本文件(例如parquet)和增量文件(例如avro)来提供近实时数据集（几分钟的延迟）。</li></ul><p>下表总结了不同视图之间的权衡。</p><table><thead><tr><th>权衡</th><th>读优化</th><th>实时</th></tr></thead><tbody><tr><td>数据延迟</td><td>更高</td><td>更低</td></tr><tr><td>查询延迟</td><td>更低（原始列式性能）</td><td>更高（合并列式
+ 基于行的增量）</td></tr></tbody></table>< [...]
换句话说，我们压缩每个提交，从而所有的数据都是以列数据的形式储存。在这种情况下，写入数据非常昂贵（我们需要重写整个列数据文件，即使只有一个字节的新数据被提交），而读取数据的成本则没有增加。
这种视图有利于读取繁重的分析工作。</p><p>以下内容说明了将数据写入写时复制存储并在其上运行两个查询时，它是如何工作的。</p><figure><img
class="docimage" src="/assets/images/hudi_cow.png"
alt="hudi_cow.png"></figure><p>随着数据的写入，对现有文件组的更新将为该文件组生成一个带有提交即时时间标记的新切片，而插入分配一个新文件组并写入该文件组的第一个切片。
diff --git a/content/cn/docs/0.9.0/concepts/index.html
b/content/cn/docs/0.9.0/concepts/index.html
index cba95376da..7c93f12ab1 100644
--- a/content/cn/docs/0.9.0/concepts/index.html
+++ b/content/cn/docs/0.9.0/concepts/index.html
@@ -22,7 +22,7 @@
每个文件组包含多个<code>文件切片</code>，其中每个切片包含在某个提交/压缩即时时间生成的基本列文件（<code>*.parquet</code>）以及一组日志文件（<code>*.log*</code>），该文件包含自生成基本文件以来对基本文件的插入/更新。
Hudi采用MVCC设计，其中压缩操作将日志和基本文件合并以产生新的文件片，而清理操作则将未使用的/较旧的文件片删除以回收DFS上的空间。</p><p>Hudi通过索引机制将给定的hoodie键（记录键+分区路径）映射到文件组，从而提供了高效的Upsert。
一旦将记录的第一个版本写入文件，记录键和文件组/文件id之间的映射就永远不会改变。 简而言之，映射的文件组包含一组记录的所有版本。</p><h2
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型和视图">存储类型和视图<a
class="hash-link" href="#存储类型和视图" title="Direct link to
heading"></a></h2><p>Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如何在这种组织之上实现上述原语和时间轴活动（即如何写入数据）。
-反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>读优化
+ 增量</td></tr><tr><td>读时合并</td><td>读优化 + 增量 + 近实时</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
+反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>近实时
+ 增量</td></tr><tr><td>读时合并</td><td>近实时 + 增量 + 读优化</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
该视图仅将最新文件切片中的基本/列文件暴露给查询，并保证与非Hudi列式数据集相比，具有相同的列式查询性能。</li><li><strong>增量视图</strong>
:
对该视图的查询只能看到从某个提交/压缩后写入数据集的新数据。该视图有效地提供了更改流，来支持增量数据管道。</li><li><strong>实时视图</strong>
:
在此视图上的查询将查看某个增量提交操作中数据集的最新快照。该视图通过动态合并最新的基本文件(例如parquet)和增量文件(例如avro)来提供近实时数据集（几分钟的延迟）。</li></ul><p>下表总结了不同视图之间的权衡。</p><table><thead><tr><th>权衡</th><th>读优化</th><th>实时</th></tr></thead><tbody><tr><td>数据延迟</td><td>更高</td><td>更低</td></tr><tr><td>查询延迟</td><td>更低（原始列式性能）</td><td>更高（合并列式
+ 基于行的增量）</td></tr></tbody></table>< [...]
换句话说，我们压缩每个提交，从而所有的数据都是以列数据的形式储存。在这种情况下，写入数据非常昂贵（我们需要重写整个列数据文件，即使只有一个字节的新数据被提交），而读取数据的成本则没有增加。
这种视图有利于读取繁重的分析工作。</p><p>以下内容说明了将数据写入写时复制存储并在其上运行两个查询时，它是如何工作的。</p><figure><img
class="docimage"
src="/cn/assets/images/hudi_cow-9750b5f006646e2d1874ad18b355d200.png"
alt="hudi_cow.png"></figure><p>随着数据的写入，对现有文件组的更新将为该文件组生成一个带有提交即时时间标记的新切片，而插入分配一个新文件组并写入该文件组的第一个切片。
diff --git a/content/cn/docs/0.9.0/overview/index.html
b/content/cn/docs/0.9.0/overview/index.html
index 551a7b78ae..301768879e 100644
--- a/content/cn/docs/0.9.0/overview/index.html
+++ b/content/cn/docs/0.9.0/overview/index.html
@@ -22,7 +22,7 @@
每个文件组包含多个<code>文件切片</code>，其中每个切片包含在某个提交/压缩即时时间生成的基本列文件（<code>*.parquet</code>）以及一组日志文件（<code>*.log*</code>），该文件包含自生成基本文件以来对基本文件的插入/更新。
Hudi采用MVCC设计，其中压缩操作将日志和基本文件合并以产生新的文件片，而清理操作则将未使用的/较旧的文件片删除以回收DFS上的空间。</p><p>Hudi通过索引机制将给定的hoodie键（记录键+分区路径）映射到文件组，从而提供了高效的Upsert。
一旦将记录的第一个版本写入文件，记录键和文件组/文件id之间的映射就永远不会改变。 简而言之，映射的文件组包含一组记录的所有版本。</p><h2
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型和视图">存储类型和视图<a
class="hash-link" href="#存储类型和视图" title="Direct link to
heading"></a></h2><p>Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如何在这种组织之上实现上述原语和时间轴活动（即如何写入数据）。
-反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>读优化
+ 增量</td></tr><tr><td>读时合并</td><td>读优化 + 增量 + 近实时</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
+反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>近实时
+ 增量</td></tr><tr><td>读时合并</td><td>近实时 + 增量 + 读优化</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
该视图仅将最新文件切片中的基本/列文件暴露给查询，并保证与非Hudi列式数据集相比，具有相同的列式查询性能。</li><li><strong>增量视图</strong>
:
对该视图的查询只能看到从某个提交/压缩后写入数据集的新数据。该视图有效地提供了更改流，来支持增量数据管道。</li><li><strong>实时视图</strong>
:
在此视图上的查询将查看某个增量提交操作中数据集的最新快照。该视图通过动态合并最新的基本文件(例如parquet)和增量文件(例如avro)来提供近实时数据集（几分钟的延迟）。</li></ul><p>下表总结了不同视图之间的权衡。</p><table><thead><tr><th>权衡</th><th>读优化</th><th>实时</th></tr></thead><tbody><tr><td>数据延迟</td><td>更高</td><td>更低</td></tr><tr><td>查询延迟</td><td>更低（原始列式性能）</td><td>更高（合并列式
+ 基于行的增量）</td></tr></tbody></table>< [...]
换句话说，我们压缩每个提交，从而所有的数据都是以列数据的形式储存。在这种情况下，写入数据非常昂贵（我们需要重写整个列数据文件，即使只有一个字节的新数据被提交），而读取数据的成本则没有增加。
这种视图有利于读取繁重的分析工作。</p><p>以下内容说明了将数据写入写时复制存储并在其上运行两个查询时，它是如何工作的。</p><figure><img
class="docimage" src="/assets/images/hudi_cow.png"
alt="hudi_cow.png"></figure><p>随着数据的写入，对现有文件组的更新将为该文件组生成一个带有提交即时时间标记的新切片，而插入分配一个新文件组并写入该文件组的第一个切片。
diff --git a/content/cn/docs/next/concepts/index.html
b/content/cn/docs/next/concepts/index.html
index c37082bf8a..066a997b87 100644
--- a/content/cn/docs/next/concepts/index.html
+++ b/content/cn/docs/next/concepts/index.html
@@ -22,7 +22,7 @@
每个文件组包含多个<code>文件切片</code>，其中每个切片包含在某个提交/压缩即时时间生成的基本列文件（<code>*.parquet</code>）以及一组日志文件（<code>*.log*</code>），该文件包含自生成基本文件以来对基本文件的插入/更新。
Hudi采用MVCC设计，其中压缩操作将日志和基本文件合并以产生新的文件片，而清理操作则将未使用的/较旧的文件片删除以回收DFS上的空间。</p><p>Hudi通过索引机制将给定的hoodie键（记录键+分区路径）映射到文件组，从而提供了高效的Upsert。
一旦将记录的第一个版本写入文件，记录键和文件组/文件id之间的映射就永远不会改变。 简而言之，映射的文件组包含一组记录的所有版本。</p><h2
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型和视图">存储类型和视图<a
class="hash-link" href="#存储类型和视图" title="Direct link to
heading"></a></h2><p>Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如何在这种组织之上实现上述原语和时间轴活动（即如何写入数据）。
-反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>读优化
+ 增量</td></tr><tr><td>读时合并</td><td>读优化 + 增量 + 近实时</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
+反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>近实时
+ 增量</td></tr><tr><td>读时合并</td><td>近实时 + 增量 + 读优化</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
该视图仅将最新文件切片中的基本/列文件暴露给查询，并保证与非Hudi列式数据集相比，具有相同的列式查询性能。</li><li><strong>增量视图</strong>
:
对该视图的查询只能看到从某个提交/压缩后写入数据集的新数据。该视图有效地提供了更改流，来支持增量数据管道。</li><li><strong>实时视图</strong>
:
在此视图上的查询将查看某个增量提交操作中数据集的最新快照。该视图通过动态合并最新的基本文件(例如parquet)和增量文件(例如avro)来提供近实时数据集（几分钟的延迟）。</li></ul><p>下表总结了不同视图之间的权衡。</p><table><thead><tr><th>权衡</th><th>读优化</th><th>实时</th></tr></thead><tbody><tr><td>数据延迟</td><td>更高</td><td>更低</td></tr><tr><td>查询延迟</td><td>更低（原始列式性能）</td><td>更高（合并列式
+ 基于行的增量）</td></tr></tbody></table>< [...]
换句话说，我们压缩每个提交，从而所有的数据都是以列数据的形式储存。在这种情况下，写入数据非常昂贵（我们需要重写整个列数据文件，即使只有一个字节的新数据被提交），而读取数据的成本则没有增加。
这种视图有利于读取繁重的分析工作。</p><p>以下内容说明了将数据写入写时复制存储并在其上运行两个查询时，它是如何工作的。</p><figure><img
class="docimage"
src="/cn/assets/images/hudi_cow-9750b5f006646e2d1874ad18b355d200.png"
alt="hudi_cow.png"></figure><p>随着数据的写入，对现有文件组的更新将为该文件组生成一个带有提交即时时间标记的新切片，而插入分配一个新文件组并写入该文件组的第一个切片。
diff --git a/content/cn/docs/next/overview/index.html
b/content/cn/docs/next/overview/index.html
index f3ff095da2..6c375be2c3 100644
--- a/content/cn/docs/next/overview/index.html
+++ b/content/cn/docs/next/overview/index.html
@@ -22,7 +22,7 @@
每个文件组包含多个<code>文件切片</code>，其中每个切片包含在某个提交/压缩即时时间生成的基本列文件（<code>*.parquet</code>）以及一组日志文件（<code>*.log*</code>），该文件包含自生成基本文件以来对基本文件的插入/更新。
Hudi采用MVCC设计，其中压缩操作将日志和基本文件合并以产生新的文件片，而清理操作则将未使用的/较旧的文件片删除以回收DFS上的空间。</p><p>Hudi通过索引机制将给定的hoodie键（记录键+分区路径）映射到文件组，从而提供了高效的Upsert。
一旦将记录的第一个版本写入文件，记录键和文件组/文件id之间的映射就永远不会改变。 简而言之，映射的文件组包含一组记录的所有版本。</p><h2
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型和视图">存储类型和视图<a
class="hash-link" href="#存储类型和视图" title="Direct link to
heading"></a></h2><p>Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如何在这种组织之上实现上述原语和时间轴活动（即如何写入数据）。
-反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>读优化
+ 增量</td></tr><tr><td>读时合并</td><td>读优化 + 增量 + 近实时</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
+反过来，<code>视图</code>定义了基础数据如何暴露给查询（即如何读取数据）。</p><table><thead><tr><th>存储类型</th><th>支持的视图</th></tr></thead><tbody><tr><td>写时复制</td><td>近实时
+ 增量</td></tr><tr><td>读时合并</td><td>近实时 + 增量 + 读优化</td></tr></tbody></table><h3
class="anchor anchorWithStickyNavbar_y2LR" id="存储类型">存储类型<a class="hash-link"
href="#存储类型" title="Direct link to
heading"></a></h3><p>Hudi支持以下存储类型。</p><ul><li><p><a
href="#copy-on-write-storage">写时复制</a> :
仅使用列文件格式（例如parquet）存储数据。通过在写入过程中执行同步合并以更新版本并重写文件。</p></li><li><p><a h [...]
该视图仅将最新文件切片中的基本/列文件暴露给查询，并保证与非Hudi列式数据集相比，具有相同的列式查询性能。</li><li><strong>增量视图</strong>
:
对该视图的查询只能看到从某个提交/压缩后写入数据集的新数据。该视图有效地提供了更改流，来支持增量数据管道。</li><li><strong>实时视图</strong>
:
在此视图上的查询将查看某个增量提交操作中数据集的最新快照。该视图通过动态合并最新的基本文件(例如parquet)和增量文件(例如avro)来提供近实时数据集（几分钟的延迟）。</li></ul><p>下表总结了不同视图之间的权衡。</p><table><thead><tr><th>权衡</th><th>读优化</th><th>实时</th></tr></thead><tbody><tr><td>数据延迟</td><td>更高</td><td>更低</td></tr><tr><td>查询延迟</td><td>更低（原始列式性能）</td><td>更高（合并列式
+ 基于行的增量）</td></tr></tbody></table>< [...]
换句话说，我们压缩每个提交，从而所有的数据都是以列数据的形式储存。在这种情况下，写入数据非常昂贵（我们需要重写整个列数据文件，即使只有一个字节的新数据被提交），而读取数据的成本则没有增加。
这种视图有利于读取繁重的分析工作。</p><p>以下内容说明了将数据写入写时复制存储并在其上运行两个查询时，它是如何工作的。</p><figure><img
class="docimage" src="/assets/images/hudi_cow.png"
alt="hudi_cow.png"></figure><p>随着数据的写入，对现有文件组的更新将为该文件组生成一个带有提交即时时间标记的新切片，而插入分配一个新文件组并写入该文件组的第一个切片。
diff --git a/content/docs/0.5.0/concepts/index.html
b/content/docs/0.5.0/concepts/index.html
index f49ca0a4ea..4876360ab7 100644
--- a/content/docs/0.5.0/concepts/index.html
+++ b/content/docs/0.5.0/concepts/index.html
@@ -29,7 +29,7 @@ Hudi adopts a MVCC design, where compaction action merges
logs and base files to
unused/older file slices to reclaim space on DFS. </p><p>Hudi provides
efficient upserts, by mapping a given hoodie key (record key + partition path)
consistently to a file group, via an indexing mechanism.
This mapping between record key and file group/file id, never changes once the
first version of a record has been written to a file. In short, the
mapped file group contains all versions of a group of records.</p><h2
class="anchor anchorWithStickyNavbar_y2LR" id="storage-types--views">Storage
Types & Views<a class="hash-link" href="#storage-types--views"
title="Direct link to heading"></a></h2><p>Hudi storage types define how data
is indexed & laid out on the DFS and how the above primitives and timeline
activities are implemented on top of such organization (i.e how data is
written).
-In turn, <code>views</code> define how the underlying data is exposed to the
queries (i.e how data is read). </p><table><thead><tr><th>Storage
Type</th><th>Supported Views</th></tr></thead><tbody><tr><td>Copy On
Write</td><td>Read Optimized + Incremental</td></tr><tr><td>Merge On
Read</td><td>Read Optimized + Incremental + Near
Real-time</td></tr></tbody></table><h3 class="anchor
anchorWithStickyNavbar_y2LR" id="storage-types">Storage Types<a
class="hash-link" href="#storage-types" title [...]
+In turn, <code>views</code> define how the underlying data is exposed to the
queries (i.e how data is read). </p><table><thead><tr><th>Storage
Type</th><th>Supported Views</th></tr></thead><tbody><tr><td>Copy On
Write</td><td>Snapshot Queries + Incremental Queries</td></tr><tr><td>Merge On
Read</td><td>Snapshot Queries + Incremental Queries + Read Optimized
Queries</td></tr></tbody></table><h3 class="anchor anchorWithStickyNavbar_y2LR"
id="storage-types">Storage Types<a class="hash-link" [...]
This view exposes only the base/columnar files in latest file slices to the
queries and guarantees the same columnar query performance compared to a
non-hudi columnar dataset. </li><li><strong>Incremental View</strong> : Queries
on this view only see new data written to the dataset, since a given
commit/compaction. This view effectively provides change streams to enable
incremental data pipelines. </li><li><strong>Realtime View</strong> : Queries
on this view see the latest snapshot of d [...]
by merging the base and delta files of the latest file slice
on-the-fly.</li></ul><p>Following table summarizes the trade-offs between the
different
views.</p><table><thead><tr><th>Trade-off</th><th>ReadOptimized</th><th>RealTime</th></tr></thead><tbody><tr><td>Data
Latency</td><td>Higher</td><td>Lower</td></tr><tr><td>Query
Latency</td><td>Lower (raw columnar performance)</td><td>Higher (merge columnar
+ row based delta)</td></tr></tbody></table><h2 class="anchor
anchorWithStickyNavbar_ [...]
In other words, we implicitly compact on every commit, such that only columnar
data exists. As a result, the write amplification
diff --git a/website/i18n/cn/docusaurus-plugin-content-docs/current/concepts.md
b/website/i18n/cn/docusaurus-plugin-content-docs/current/concepts.md
index a91d50bf0c..822b1ccb36 100644
--- a/website/i18n/cn/docusaurus-plugin-content-docs/current/concepts.md
+++ b/website/i18n/cn/docusaurus-plugin-content-docs/current/concepts.md
@@ -63,10 +63,10 @@ Hudi通过索引机制将给定的hoodie键（记录键+分区路径）映射到
Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如何在这种组织之上实现上述原语和时间轴活动（即如何写入数据）。
反过来，`视图`定义了基础数据如何暴露给查询（即如何读取数据）。
-| 存储类型 | 支持的视图 |
-|-------------- |------------------|
-| 写时复制 | 读优化 + 增量 |
-| 读时合并 | 读优化 + 增量 + 近实时 |
+| 存储类型 | 支持的视图 |
+|-------------- |----------------|
+| 写时复制 | 近实时 + 增量 |
+| 读时合并 | 近实时 + 增量 + 读优化 |
### 存储类型
Hudi支持以下存储类型。
diff --git a/website/i18n/cn/docusaurus-plugin-content-docs/current/overview.md
b/website/i18n/cn/docusaurus-plugin-content-docs/current/overview.md
index c78283f52a..2ae90fe37b 100644
--- a/website/i18n/cn/docusaurus-plugin-content-docs/current/overview.md
+++ b/website/i18n/cn/docusaurus-plugin-content-docs/current/overview.md
@@ -66,8 +66,8 @@ Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如
| 存储类型 | 支持的视图 |
|-------------- |------------------|
-| 写时复制 | 读优化 + 增量 |
-| 读时合并 | 读优化 + 增量 + 近实时 |
+| 写时复制 | 近实时 + 增量 |
+| 读时合并 | 近实时 + 增量 + 读优化 |
### 存储类型
Hudi支持以下存储类型。
diff --git
a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.0/concepts.md
b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.0/concepts.md
index e2e089a977..943ed9177b 100644
--- a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.0/concepts.md
+++ b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.0/concepts.md
@@ -66,8 +66,8 @@ Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如
| 存储类型 | 支持的视图 |
|-------------- |------------------|
-| 写时复制 | 读优化 + 增量 |
-| 读时合并 | 读优化 + 增量 + 近实时 |
+| 写时复制 | 近实时 + 增量 |
+| 读时合并 | 近实时 + 增量 + 读优化 |
### 存储类型
Hudi支持以下存储类型。
diff --git
a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.1/concepts.md
b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.1/concepts.md
index 4badaf6434..7de8f9d5c5 100644
--- a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.1/concepts.md
+++ b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.1/concepts.md
@@ -66,8 +66,8 @@ Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如
| 存储类型 | 支持的视图 |
|-------------- |------------------|
-| 写时复制 | 读优化 + 增量 |
-| 读时合并 | 读优化 + 增量 + 近实时 |
+| 写时复制 | 近实时 + 增量 |
+| 读时合并 | 近实时 + 增量 + 读优化 |
### 存储类型
Hudi支持以下存储类型。
diff --git
a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.2/concepts.md
b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.2/concepts.md
index 9b19460dad..511fb8cabd 100644
--- a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.2/concepts.md
+++ b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.2/concepts.md
@@ -66,8 +66,8 @@ Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如
| 存储类型 | 支持的视图 |
|-------------- |------------------|
-| 写时复制 | 读优化 + 增量 |
-| 读时合并 | 读优化 + 增量 + 近实时 |
+| 写时复制 | 近实时 + 增量 |
+| 读时合并 | 近实时 + 增量 + 读优化 |
### 存储类型
Hudi支持以下存储类型。
diff --git
a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.3/concepts.md
b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.3/concepts.md
index d8cdfe828e..075fc175c4 100644
--- a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.3/concepts.md
+++ b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.5.3/concepts.md
@@ -66,8 +66,8 @@ Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如
| 存储类型 | 支持的视图 |
|-------------- |------------------|
-| 写时复制 | 读优化 + 增量 |
-| 读时合并 | 读优化 + 增量 + 近实时 |
+| 写时复制 | 近实时 + 增量 |
+| 读时合并 | 近实时 + 增量 + 读优化 |
### 存储类型
Hudi支持以下存储类型。
diff --git
a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.6.0/concepts.md
b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.6.0/concepts.md
index 305a8cf2c6..49152260dd 100644
--- a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.6.0/concepts.md
+++ b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.6.0/concepts.md
@@ -66,8 +66,8 @@ Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如
| 存储类型 | 支持的视图 |
|-------------- |------------------|
-| 写时复制 | 读优化 + 增量 |
-| 读时合并 | 读优化 + 增量 + 近实时 |
+| 写时复制 | 近实时 + 增量 |
+| 读时合并 | 近实时 + 增量 + 读优化 |
### 存储类型
Hudi支持以下存储类型。
diff --git
a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.7.0/overview.md
b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.7.0/overview.md
index 181e9048d0..4d4b1c8e04 100644
--- a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.7.0/overview.md
+++ b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.7.0/overview.md
@@ -66,8 +66,8 @@ Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如
| 存储类型 | 支持的视图 |
|-------------- |------------------|
-| 写时复制 | 读优化 + 增量 |
-| 读时合并 | 读优化 + 增量 + 近实时 |
+| 写时复制 | 近实时 + 增量 |
+| 读时合并 | 近实时 + 增量 + 读优化 |
### 存储类型
Hudi支持以下存储类型。
diff --git
a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.8.0/overview.md
b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.8.0/overview.md
index c78283f52a..2ae90fe37b 100644
--- a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.8.0/overview.md
+++ b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.8.0/overview.md
@@ -66,8 +66,8 @@ Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如
| 存储类型 | 支持的视图 |
|-------------- |------------------|
-| 写时复制 | 读优化 + 增量 |
-| 读时合并 | 读优化 + 增量 + 近实时 |
+| 写时复制 | 近实时 + 增量 |
+| 读时合并 | 近实时 + 增量 + 读优化 |
### 存储类型
Hudi支持以下存储类型。
diff --git
a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.9.0/concepts.md
b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.9.0/concepts.md
index a91d50bf0c..1c53982e81 100644
--- a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.9.0/concepts.md
+++ b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.9.0/concepts.md
@@ -65,8 +65,8 @@ Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如
| 存储类型 | 支持的视图 |
|-------------- |------------------|
-| 写时复制 | 读优化 + 增量 |
-| 读时合并 | 读优化 + 增量 + 近实时 |
+| 写时复制 | 近实时 + 增量 |
+| 读时合并 | 近实时 + 增量 + 读优化 |
### 存储类型
Hudi支持以下存储类型。
diff --git
a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.9.0/overview.md
b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.9.0/overview.md
index c78283f52a..2ae90fe37b 100644
--- a/website/i18n/cn/docusaurus-plugin-content-docs/version-0.9.0/overview.md
+++ b/website/i18n/cn/docusaurus-plugin-content-docs/version-0.9.0/overview.md
@@ -66,8 +66,8 @@ Hudi存储类型定义了如何在DFS上对数据进行索引和布局以及如
| 存储类型 | 支持的视图 |
|-------------- |------------------|
-| 写时复制 | 读优化 + 增量 |
-| 读时合并 | 读优化 + 增量 + 近实时 |
+| 写时复制 | 近实时 + 增量 |
+| 读时合并 | 近实时 + 增量 + 读优化 |
### 存储类型
Hudi支持以下存储类型。
diff --git a/website/versioned_docs/version-0.5.0/concepts.md
b/website/versioned_docs/version-0.5.0/concepts.md
index a28ca32cdc..53bbfe3ba1 100644
--- a/website/versioned_docs/version-0.5.0/concepts.md
+++ b/website/versioned_docs/version-0.5.0/concepts.md
@@ -72,8 +72,8 @@ In turn, `views` define how the underlying data is exposed to
the queries (i.e h
| Storage Type | Supported Views |
|-------------- |------------------|
-| Copy On Write | Read Optimized + Incremental |
-| Merge On Read | Read Optimized + Incremental + Near Real-time |
+| Copy On Write | Snapshot Queries + Incremental Queries |
+| Merge On Read | Snapshot Queries + Incremental Queries + Read Optimized
Queries |
### Storage Types
Hudi supports the following storage types.
