Copilot commented on code in PR #3523:
URL: https://github.com/apache/doris-website/pull/3523#discussion_r3042647989
##########
i18n/zh-CN/docusaurus-plugin-content-docs/version-2.0/table-design/row-store.md:
##########
@@ -15,17 +15,19 @@ Doris 默认采用列式存储,每个列连续存储,在分析场景(如
## 使用语法
-建表时在表的 PROPERTIES 中指定是否开启行存。
-```
-"store_row_column" = "true"
-```
+建表时在表的 `PROPERTIES` 中指定是否开启行存以及其存储单位大小。
+
+| 参数 | 默认值 | 说明 |
+|---|---|---|
+| `"store_row_column"` | `false` | 对所有列开启行存。 |
+| `"row_store_page_size"` | `16384`(16 KB) | 行存 page
大小(字节)。较小的值适合极致点查性能,但占用更多存储。 |
Review Comment:
内联代码里出现了转义引号(例如 `\"store_row_column\"`),渲染后会把反斜杠也显示出来。Markdown
的反引号代码中不需要对双引号做转义,建议去掉反斜杠,使其显示为 `"store_row_column"` / `"row_store_page_size"`。
##########
versioned_docs/version-2.0/table-design/row-store.md:
##########
@@ -15,16 +15,18 @@ The principle of row storage is that an additional column
is added during storag
## Syntax
-When creating a table, specify whether to enable row storage in the table's
PROPERTIES.
-```
-"store_row_column" = "true"
-```
+When creating a table, specify whether to enable row storage and its page size
in the table's `PROPERTIES`.
+
+| Property | Default | Description |
+|---|---|---|
+| `"store_row_column"` | `false` | Enable row storage for all columns. |
+| `"row_store_page_size"` | `16384` (16 KB) | Size of the row-store page in
bytes. A smaller value increases storage overhead but yields better point-query
performance. |
Review Comment:
Inline code is using escaped quotes (e.g., `\"store_row_column\"`), which
will render the backslashes in the published docs. Quotes don’t need escaping
inside backticks in Markdown—remove the backslashes so it displays as
`"store_row_column"` / `"row_store_page_size"`.
##########
versioned_docs/version-2.1/table-design/row-store.md:
##########
@@ -16,26 +16,24 @@ The principle of row storage is that an additional column
is added during storag
## Syntax
-When creating a table, specify whether to enable row storage, and the storage
compression unit size page_size in the table's PROPERTIES.
+When creating a table, specify whether to enable row storage, and the storage
compression unit size `page_size` in the table's `PROPERTIES`.
-1. Whether to enable row storage: defaults to false (not enabled).
-```
-"store_row_column" = "true"
-```
-
-1. Row storage page_size: defaults to 16KB.
-```
-"row_store_page_size" = "16384"
-```
+| Property | Default | Description |
+|---|---|---|
+| `"store_row_column"` | `false` | Enable row storage for all columns. |
+| `"row_store_page_size"` | `16384` (16 KB) | Size of the row-store page in
bytes. |
Review Comment:
Inline code is using escaped quotes (e.g., `\"store_row_column\"`), which
will render the backslashes in the published docs. Quotes don’t need escaping
inside backticks in Markdown—remove the backslashes so it displays as
`"store_row_column"` / `"row_store_page_size"`.
##########
i18n/zh-CN/docusaurus-plugin-content-docs/version-3.x/table-design/row-store.md:
##########
@@ -2,52 +2,88 @@
{
"title": "行列混存",
"language": "zh-CN",
- "description": "Doris
默认采用列式存储,每个列连续存储,在分析场景(如聚合,过滤,排序等)有很好的性能,因为只需要读取所需要的列减少不必要的 IO。但是在点查场景(比如
SELECT ),需要读取所有列,每个列都需要一次 IO 导致 IOPS 成为瓶颈,特别对列多的宽表(比如上百列)尤为明显。"
+ "description": "Doris 行列混存功能在列存基础上增加行存,降低宽表点查场景的 IOPS 开销。"
}
---
-## 行列混存介绍
+## 概述
-Doris 默认采用列式存储,每个列连续存储,在分析场景(如聚合,过滤,排序等)有很好的性能,因为只需要读取所需要的列减少不必要的
IO。但是在点查场景(比如 `SELECT *`),需要读取所有列,每个列都需要一次 IO 导致 IOPS 成为瓶颈,特别对列多的宽表(比如上百列)尤为明显。
+Doris 默认采用列式存储,每个列连续存储。列存在分析场景(聚合、过滤、排序等)表现优异,因为只需读取所需的列。但在点查场景(如 `SELECT
*`)中需要读取所有列,每列一次 IO,在列数较多的宽表(如上百列)上 IOPS 会成为瓶颈。
-为了解决点查场景 IOPS 的瓶颈问题,Doris 2.0.0 版本开始支持行列混存,用户建表时指定开启行存后,点查(比如 `SELECT
*`)每一行只需要一次 IO,在宽表列很多的情况下性能有数量级提升。
+为此,Doris 从 2.0.0
版本开始支持**行列混存**。在建表时开启行存后,系统会在存储时增加一个额外的列,将该行所有列拼接为紧凑二进制格式存储。点查时只需一次 IO
即可读取完整行数据,大幅降低 IOPS、提升查询延迟。
-行存的原理是在存储时增加了一个额外的列,这个列将对应行的所有列拼接起来采用特殊的二进制格式存储。
+## 适用场景
-## 使用语法
+以下场景推荐开启行存:
-建表时在表的 PROPERTIES 中指定是否开启行存,哪些列开启行存,行存的存储压缩单元大小 page_size。
+- **主键高并发点查**:在 Unique Key Merge-On-Write(MOW)表上,根据完整主键查找特定行。
+- **宽表 SELECT \* 查询**:在 Duplicate 表或 MOW 表上,仅返回少量行的 TOPN 查询。
-1. 是否开启行存:默认为 false 不开启
-```
-"store_row_column" = "true"
-```
+如果业务以分析查询为主(聚合、对少数列的复杂过滤等),通常仅列存即可满足需求。
-2. 哪些列开启行存:如果 `"store_row_column" = "true"`,默认所有列开启行存,若需要指定部分列开启行存,设置
row_store_columns 参数(3.0 之后的版本),格式为逗号分割的列名
-```
-"row_store_columns" = "column1,column2,column3"
-```
+## 建表配置
-3. 行存 page_size:默认为 16KB。
-```
-"row_store_page_size" = "16384"
-```
+通过 `CREATE TABLE` 的 `PROPERTIES` 设置行存相关参数:
+
+| 参数 | 默认值 | 支持版本 | 说明 |
+|------|--------|---------|------|
+| `"store_row_column" = "true"` | `false` | 2.0+ | 对**所有列**开启行存。 |
+| `"row_store_columns" = "col1,col2,..."` | 全部列 | 3.0+ | 仅对**指定列**开启行存。设置此参数时
`store_row_column` 隐式启用。相比全量行存可显著降低存储开销。 |
+| `"row_store_page_size" = "16384"` | `16384`(16 KB) | 2.0+ | 行存 page
大小(字节)。page 是最小 IO 单元——即使只读一行也需产生一个 page 的 IO。 |
Review Comment:
内联代码里出现了转义引号(例如 `\"store_row_column\" = \"true\"`),渲染后会把反斜杠也显示出来。Markdown
的反引号代码中不需要对双引号做转义,建议去掉反斜杠(写成 `"store_row_column" = "true"`)。
##########
versioned_docs/version-3.x/table-design/row-store.md:
##########
@@ -2,53 +2,88 @@
{
"title": "Hybrid Row-Columnar Storage",
"language": "en",
- "description": "Doris uses columnar storage by default, with each column
stored contiguously."
+ "description": "Doris hybrid row-columnar storage enables row-oriented
storage alongside columnar storage, reducing IOPS for point queries on wide
tables."
}
---
-## Hybrid Row-Columnar Storage
+## Overview
-Doris uses columnar storage by default, with each column stored contiguously.
Columnar storage offers excellent performance for analytical scenarios (such as
aggregation, filtering, sorting, etc.), as it only reads the necessary columns,
reducing unnecessary IO. However, in point query scenarios (such as `SELECT
*`), all columns need to be read, requiring an IO operation for each column,
which can lead to IOPS becoming a bottleneck, especially for wide tables with
many columns (e.g., hundreds of columns).
+Doris uses columnar storage by default, where each column is stored
contiguously. Columnar storage performs well in analytical scenarios
(aggregation, filtering, sorting, etc.) because it reads only the required
columns. However, when a query needs all columns — such as `SELECT *` in point
query scenarios — each column requires a separate IO operation, making IOPS a
bottleneck. This is especially noticeable on wide tables with hundreds of
columns.
-To address the IOPS bottleneck in point query scenarios, starting from version
2.0.0, Doris supports Hybrid Row-Columnar Storage. When users create tables,
they can specify whether to enable row storage. With row storage enabled, each
row only requires one IO operation for point queries (such as `SELECT *`),
significantly improving performance.
+To solve this, Doris supports **Hybrid Row-Columnar Storage** since version
2.0.0. When row storage is enabled at table creation, all columns of a row are
concatenated into a single additional column using a compact binary format. A
point query then reads a complete row in one IO operation instead of one IO per
column, significantly reducing IOPS and improving latency.
-The principle of row storage is that an additional column is added during
storage. This column concatenates all the columns of the corresponding row and
stores them using a special binary format.
+## Use Cases
-## Syntax
+Row storage is recommended in the following scenarios:
-When creating a table, specify whether to enable row storage, which columns to
enable row storage for, and the storage compression unit size page_size in the
table's PROPERTIES.
+- **High-concurrency primary key point queries** on Unique Key merge-on-write
(MOW) tables, where each query looks up a specific row by the full primary key.
+- **Wide-table SELECT \* queries** on Duplicate or MOW tables where only a
small number of rows are returned (TOPN pattern).
-1. Whether to enable row storage: defaults to false (not enabled).
-```
-"store_row_column" = "true"
-```
+If your workload is primarily analytical (aggregation, complex filtering on a
few columns), columnar storage alone is usually sufficient.
-2. Which columns to enable row storage for:if `"store_row_column" = "true"`,
all columns are enabled by default. If you need to specify that only some
columns are enabled for row storage, set the row_store_columns parameter (afer
version 3.0), formatted as a comma-separated list of column names.
-```
-"row_store_columns" = "column1,column2,column3"
-```
+## Table Properties
-3. Row storage page_size: defaults to 16KB.
-```
-"row_store_page_size" = "16384"
-```
+Enable and configure row storage through the following `PROPERTIES` when
creating a table.
+
+| Property | Default | Since | Description |
+|----------|---------|-------|-------------|
+| `"store_row_column" = "true"` | `false` | 2.0 | Enable row storage for
**all** columns. |
+| `"row_store_columns" = "col1,col2,..."` | All columns | 3.0 | Enable row
storage for **specified columns only**. When this property is set,
`store_row_column` is implicitly enabled. Using selective columns reduces
storage overhead compared to storing all columns. |
+| `"row_store_page_size" = "16384"` | `16384` (16 KB) | 2.0 | Size of the
row-store page in bytes. A page is the minimum IO unit — reading even a single
row requires one page IO. |
Review Comment:
Inline code spans are using escaped quotes (e.g., `\"store_row_column\" =
\"true\"`), which will display backslashes in the rendered docs. In Markdown,
quotes don’t need escaping inside backticks, so remove the backslashes (use
`"store_row_column" = "true"`).
##########
docs/table-design/row-store.md:
##########
@@ -2,54 +2,88 @@
{
"title": "Hybrid Row-Columnar Storage",
"language": "en",
- "description": "Doris uses columnar storage by default, with each column
stored contiguously."
+ "description": "Doris hybrid row-columnar storage enables row-oriented
storage alongside columnar storage, reducing IOPS for point queries on wide
tables."
}
---
-## Hybrid Row-Columnar Storage
+## Overview
-Doris uses columnar storage by default, with each column stored contiguously.
Columnar storage offers excellent performance for analytical scenarios (such as
aggregation, filtering, sorting, etc.), as it only reads the necessary columns,
reducing unnecessary IO. However, in point query scenarios (such as `SELECT
*`), all columns need to be read, requiring an IO operation for each column,
which can lead to IOPS becoming a bottleneck, especially for wide tables with
many columns (e.g., hundreds of columns).
+Doris uses columnar storage by default, where each column is stored
contiguously. Columnar storage performs well in analytical scenarios
(aggregation, filtering, sorting, etc.) because it reads only the required
columns. However, when a query needs all columns — such as `SELECT *` in point
query scenarios — each column requires a separate IO operation, making IOPS a
bottleneck. This is especially noticeable on wide tables with hundreds of
columns.
-To address the IOPS bottleneck in point query scenarios, starting from version
2.0.0, Doris supports Hybrid Row-Columnar Storage. When users create tables,
they can specify whether to enable row storage. With row storage enabled, each
row only requires one IO operation for point queries (such as `SELECT *`),
significantly improving performance.
+To solve this, Doris supports **Hybrid Row-Columnar Storage** since version
2.0.0. When row storage is enabled at table creation, all columns of a row are
concatenated into a single additional column using a compact binary format. A
point query then reads a complete row in one IO operation instead of one IO per
column, significantly reducing IOPS and improving latency.
-The principle of row storage is that an additional column is added during
storage. This column concatenates all the columns of the corresponding row and
stores them using a special binary format.
+## Use Cases
-## Syntax
+Row storage is recommended in the following scenarios:
-When creating a table, specify whether to enable row storage, which columns to
enable row storage for, and the storage compression unit size page_size in the
table's PROPERTIES.
+- **High-concurrency primary key point queries** on Unique Key merge-on-write
(MOW) tables, where each query looks up a specific row by the full primary key.
+- **Wide-table SELECT \* queries** on Duplicate or MOW tables where only a
small number of rows are returned (TOPN pattern).
Review Comment:
The text renders as `SELECT \*` because the asterisk is double-escaped.
Consider writing this as inline code (`SELECT *`) or use a single escape (`\*`)
so the published docs show `SELECT *` without a stray backslash.
```suggestion
- **Wide-table `SELECT *` queries** on Duplicate or MOW tables where only a
small number of rows are returned (TOPN pattern).
```
##########
versioned_docs/version-3.x/table-design/row-store.md:
##########
@@ -2,53 +2,88 @@
{
"title": "Hybrid Row-Columnar Storage",
"language": "en",
- "description": "Doris uses columnar storage by default, with each column
stored contiguously."
+ "description": "Doris hybrid row-columnar storage enables row-oriented
storage alongside columnar storage, reducing IOPS for point queries on wide
tables."
}
---
-## Hybrid Row-Columnar Storage
+## Overview
-Doris uses columnar storage by default, with each column stored contiguously.
Columnar storage offers excellent performance for analytical scenarios (such as
aggregation, filtering, sorting, etc.), as it only reads the necessary columns,
reducing unnecessary IO. However, in point query scenarios (such as `SELECT
*`), all columns need to be read, requiring an IO operation for each column,
which can lead to IOPS becoming a bottleneck, especially for wide tables with
many columns (e.g., hundreds of columns).
+Doris uses columnar storage by default, where each column is stored
contiguously. Columnar storage performs well in analytical scenarios
(aggregation, filtering, sorting, etc.) because it reads only the required
columns. However, when a query needs all columns — such as `SELECT *` in point
query scenarios — each column requires a separate IO operation, making IOPS a
bottleneck. This is especially noticeable on wide tables with hundreds of
columns.
-To address the IOPS bottleneck in point query scenarios, starting from version
2.0.0, Doris supports Hybrid Row-Columnar Storage. When users create tables,
they can specify whether to enable row storage. With row storage enabled, each
row only requires one IO operation for point queries (such as `SELECT *`),
significantly improving performance.
+To solve this, Doris supports **Hybrid Row-Columnar Storage** since version
2.0.0. When row storage is enabled at table creation, all columns of a row are
concatenated into a single additional column using a compact binary format. A
point query then reads a complete row in one IO operation instead of one IO per
column, significantly reducing IOPS and improving latency.
-The principle of row storage is that an additional column is added during
storage. This column concatenates all the columns of the corresponding row and
stores them using a special binary format.
+## Use Cases
-## Syntax
+Row storage is recommended in the following scenarios:
-When creating a table, specify whether to enable row storage, which columns to
enable row storage for, and the storage compression unit size page_size in the
table's PROPERTIES.
+- **High-concurrency primary key point queries** on Unique Key merge-on-write
(MOW) tables, where each query looks up a specific row by the full primary key.
+- **Wide-table SELECT \* queries** on Duplicate or MOW tables where only a
small number of rows are returned (TOPN pattern).
Review Comment:
The text renders as `SELECT \*` because the asterisk is double-escaped.
Consider writing this as inline code (`SELECT *`) or use a single escape (`\*`)
so the published docs show `SELECT *` without a stray backslash.
```suggestion
- **Wide-table `SELECT *` queries** on Duplicate or MOW tables where only a
small number of rows are returned (TOPN pattern).
```
##########
versioned_docs/version-4.x/table-design/row-store.md:
##########
@@ -2,54 +2,88 @@
{
"title": "Hybrid Row-Columnar Storage",
"language": "en",
- "description": "Doris uses columnar storage by default, with each column
stored contiguously."
+ "description": "Doris hybrid row-columnar storage enables row-oriented
storage alongside columnar storage, reducing IOPS for point queries on wide
tables."
}
---
-## Hybrid Row-Columnar Storage
+## Overview
-Doris uses columnar storage by default, with each column stored contiguously.
Columnar storage offers excellent performance for analytical scenarios (such as
aggregation, filtering, sorting, etc.), as it only reads the necessary columns,
reducing unnecessary IO. However, in point query scenarios (such as `SELECT
*`), all columns need to be read, requiring an IO operation for each column,
which can lead to IOPS becoming a bottleneck, especially for wide tables with
many columns (e.g., hundreds of columns).
+Doris uses columnar storage by default, where each column is stored
contiguously. Columnar storage performs well in analytical scenarios
(aggregation, filtering, sorting, etc.) because it reads only the required
columns. However, when a query needs all columns — such as `SELECT *` in point
query scenarios — each column requires a separate IO operation, making IOPS a
bottleneck. This is especially noticeable on wide tables with hundreds of
columns.
-To address the IOPS bottleneck in point query scenarios, starting from version
2.0.0, Doris supports Hybrid Row-Columnar Storage. When users create tables,
they can specify whether to enable row storage. With row storage enabled, each
row only requires one IO operation for point queries (such as `SELECT *`),
significantly improving performance.
+To solve this, Doris supports **Hybrid Row-Columnar Storage** since version
2.0.0. When row storage is enabled at table creation, all columns of a row are
concatenated into a single additional column using a compact binary format. A
point query then reads a complete row in one IO operation instead of one IO per
column, significantly reducing IOPS and improving latency.
-The principle of row storage is that an additional column is added during
storage. This column concatenates all the columns of the corresponding row and
stores them using a special binary format.
+## Use Cases
-## Syntax
+Row storage is recommended in the following scenarios:
-When creating a table, specify whether to enable row storage, which columns to
enable row storage for, and the storage compression unit size page_size in the
table's PROPERTIES.
+- **High-concurrency primary key point queries** on Unique Key merge-on-write
(MOW) tables, where each query looks up a specific row by the full primary key.
+- **Wide-table SELECT \* queries** on Duplicate or MOW tables where only a
small number of rows are returned (TOPN pattern).
-1. Whether to enable row storage: defaults to false (not enabled).
-```
-"store_row_column" = "true"
-```
+If your workload is primarily analytical (aggregation, complex filtering on a
few columns), columnar storage alone is usually sufficient.
-2. Which columns to enable row storage for:if `"store_row_column" = "true"`,
all columns are enabled by default. If you need to specify that only some
columns are enabled for row storage, set the row_store_columns parameter (afer
version 3.0), formatted as a comma-separated list of column names.
-```
-"row_store_columns" = "column1,column2,column3"
-```
+## Table Properties
-3. Row storage page_size: defaults to 16KB.
-```
-"row_store_page_size" = "16384"
-```
+Enable and configure row storage through the following `PROPERTIES` when
creating a table.
-A page is the smallest unit for storage read and write operations, and
`page_size` refers to the size of a row-store page. This means that reading a
single row requires generating a page IO. The larger this value is, the better
the compression effect and the lower the storage space usage. However, the IO
overhead during point queries increases, resulting in lower performance
(because each IO operation reads at least one page). Conversely, the smaller
the value, the higher the storage space usage and the better the performance
for point queries. The default value of 16KB is a balanced choice in most
cases. If you prioritize query performance, you can configure a smaller value,
such as 4KB or even lower. If you prioritize storage space, you can configure a
larger value, such as 64KB or even higher.
+| Property | Default | Since | Description |
+|----------|---------|-------|-------------|
+| `"store_row_column" = "true"` | `false` | 2.0 | Enable row storage for
**all** columns. |
+| `"row_store_columns" = "col1,col2,..."` | All columns | 3.0 | Enable row
storage for **specified columns only**. When this property is set,
`store_row_column` is implicitly enabled. Using selective columns reduces
storage overhead compared to storing all columns. |
+| `"row_store_page_size" = "16384"` | `16384` (16 KB) | 2.0 | Size of the
row-store page in bytes. A page is the minimum IO unit — reading even a single
row requires one page IO. |
Review Comment:
Inline code spans are using escaped quotes (e.g., `\"store_row_column\" =
\"true\"`), which will display backslashes in the rendered docs. In Markdown,
quotes don’t need escaping inside backticks, so remove the backslashes (use
`"store_row_column" = "true"`).
##########
versioned_docs/version-4.x/table-design/row-store.md:
##########
@@ -2,54 +2,88 @@
{
"title": "Hybrid Row-Columnar Storage",
"language": "en",
- "description": "Doris uses columnar storage by default, with each column
stored contiguously."
+ "description": "Doris hybrid row-columnar storage enables row-oriented
storage alongside columnar storage, reducing IOPS for point queries on wide
tables."
}
---
-## Hybrid Row-Columnar Storage
+## Overview
-Doris uses columnar storage by default, with each column stored contiguously.
Columnar storage offers excellent performance for analytical scenarios (such as
aggregation, filtering, sorting, etc.), as it only reads the necessary columns,
reducing unnecessary IO. However, in point query scenarios (such as `SELECT
*`), all columns need to be read, requiring an IO operation for each column,
which can lead to IOPS becoming a bottleneck, especially for wide tables with
many columns (e.g., hundreds of columns).
+Doris uses columnar storage by default, where each column is stored
contiguously. Columnar storage performs well in analytical scenarios
(aggregation, filtering, sorting, etc.) because it reads only the required
columns. However, when a query needs all columns — such as `SELECT *` in point
query scenarios — each column requires a separate IO operation, making IOPS a
bottleneck. This is especially noticeable on wide tables with hundreds of
columns.
-To address the IOPS bottleneck in point query scenarios, starting from version
2.0.0, Doris supports Hybrid Row-Columnar Storage. When users create tables,
they can specify whether to enable row storage. With row storage enabled, each
row only requires one IO operation for point queries (such as `SELECT *`),
significantly improving performance.
+To solve this, Doris supports **Hybrid Row-Columnar Storage** since version
2.0.0. When row storage is enabled at table creation, all columns of a row are
concatenated into a single additional column using a compact binary format. A
point query then reads a complete row in one IO operation instead of one IO per
column, significantly reducing IOPS and improving latency.
-The principle of row storage is that an additional column is added during
storage. This column concatenates all the columns of the corresponding row and
stores them using a special binary format.
+## Use Cases
-## Syntax
+Row storage is recommended in the following scenarios:
-When creating a table, specify whether to enable row storage, which columns to
enable row storage for, and the storage compression unit size page_size in the
table's PROPERTIES.
+- **High-concurrency primary key point queries** on Unique Key merge-on-write
(MOW) tables, where each query looks up a specific row by the full primary key.
+- **Wide-table SELECT \* queries** on Duplicate or MOW tables where only a
small number of rows are returned (TOPN pattern).
Review Comment:
The text renders as `SELECT \*` because the asterisk is double-escaped.
Consider writing this as inline code (`SELECT *`) or use a single escape (`\*`)
so the published docs show `SELECT *` without a stray backslash.
```suggestion
- **Wide-table `SELECT *` queries** on Duplicate or MOW tables where only a
small number of rows are returned (TOPN pattern).
```
##########
i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/table-design/row-store.md:
##########
@@ -16,26 +16,24 @@ Doris 默认采用列式存储,每个列连续存储,在分析场景(如
## 使用语法
-建表时在表的 PROPERTIES 中指定是否开启行存,哪些列开启行存,行存的存储压缩单元大小 page_size。
+建表时在表的 `PROPERTIES` 中指定是否开启行存,以及行存的存储压缩单元大小 `page_size`。
-1. 是否开启行存:默认为 false 不开启
-```
-"store_row_column" = "true"
-```
-
-2. 行存 page_size:默认为 16KB。
-```
-"row_store_page_size" = "16384"
-```
+| 参数 | 默认值 | 说明 |
+|---|---|---|
+| `"store_row_column"` | `false` | 对所有列开启行存。 |
+| `"row_store_page_size"` | `16384`(16 KB) | 行存 page 大小(字节)。 |
Review Comment:
内联代码里出现了转义引号(例如 `\"store_row_column\"`),渲染后会把反斜杠也显示出来。Markdown
的反引号代码中不需要对双引号做转义,建议去掉反斜杠,使其显示为 `"store_row_column"` / `"row_store_page_size"`。
##########
i18n/zh-CN/docusaurus-plugin-content-docs/version-4.x/table-design/row-store.md:
##########
@@ -2,52 +2,88 @@
{
"title": "行列混存",
"language": "zh-CN",
- "description": "Doris
默认采用列式存储,每个列连续存储,在分析场景(如聚合,过滤,排序等)有很好的性能,因为只需要读取所需要的列减少不必要的 IO。但是在点查场景(比如
SELECT ),需要读取所有列,每个列都需要一次 IO 导致 IOPS 成为瓶颈,特别对列多的宽表(比如上百列)尤为明显。"
+ "description": "Doris 行列混存功能在列存基础上增加行存,降低宽表点查场景的 IOPS 开销。"
}
---
-## 行列混存介绍
+## 概述
-Doris 默认采用列式存储,每个列连续存储,在分析场景(如聚合,过滤,排序等)有很好的性能,因为只需要读取所需要的列减少不必要的
IO。但是在点查场景(比如 `SELECT *`),需要读取所有列,每个列都需要一次 IO 导致 IOPS 成为瓶颈,特别对列多的宽表(比如上百列)尤为明显。
+Doris 默认采用列式存储,每个列连续存储。列存在分析场景(聚合、过滤、排序等)表现优异,因为只需读取所需的列。但在点查场景(如 `SELECT
*`)中需要读取所有列,每列一次 IO,在列数较多的宽表(如上百列)上 IOPS 会成为瓶颈。
-为了解决点查场景 IOPS 的瓶颈问题,Doris 2.0.0 版本开始支持行列混存,用户建表时指定开启行存后,点查(比如 `SELECT
*`)每一行只需要一次 IO,在宽表列很多的情况下性能有数量级提升。
+为此,Doris 从 2.0.0
版本开始支持**行列混存**。在建表时开启行存后,系统会在存储时增加一个额外的列,将该行所有列拼接为紧凑二进制格式存储。点查时只需一次 IO
即可读取完整行数据,大幅降低 IOPS、提升查询延迟。
-行存的原理是在存储时增加了一个额外的列,这个列将对应行的所有列拼接起来采用特殊的二进制格式存储。
+## 适用场景
-## 使用语法
+以下场景推荐开启行存:
-建表时在表的 PROPERTIES 中指定是否开启行存,哪些列开启行存,行存的存储压缩单元大小 page_size。
+- **主键高并发点查**:在 Unique Key Merge-On-Write(MOW)表上,根据完整主键查找特定行。
+- **宽表 SELECT \* 查询**:在 Duplicate 表或 MOW 表上,仅返回少量行的 TOPN 查询。
Review Comment:
这里会渲染成 `SELECT \*`(多了反斜杠),因为 `*` 被双重转义了。建议改成内联代码形式(`SELECT
*`),或只保留一次转义(`\*`),以确保页面显示为 `SELECT *`。
```suggestion
- **宽表 `SELECT *` 查询**:在 Duplicate 表或 MOW 表上,仅返回少量行的 TOPN 查询。
```
##########
i18n/zh-CN/docusaurus-plugin-content-docs/current/table-design/row-store.md:
##########
@@ -2,52 +2,88 @@
{
"title": "行列混存",
"language": "zh-CN",
- "description": "Doris
默认采用列式存储,每个列连续存储,在分析场景(如聚合,过滤,排序等)有很好的性能,因为只需要读取所需要的列减少不必要的 IO。但是在点查场景(比如
SELECT ),需要读取所有列,每个列都需要一次 IO 导致 IOPS 成为瓶颈,特别对列多的宽表(比如上百列)尤为明显。"
+ "description": "Doris 行列混存功能在列存基础上增加行存,降低宽表点查场景的 IOPS 开销。"
}
---
-## 行列混存介绍
+## 概述
-Doris 默认采用列式存储,每个列连续存储,在分析场景(如聚合,过滤,排序等)有很好的性能,因为只需要读取所需要的列减少不必要的
IO。但是在点查场景(比如 `SELECT *`),需要读取所有列,每个列都需要一次 IO 导致 IOPS 成为瓶颈,特别对列多的宽表(比如上百列)尤为明显。
+Doris 默认采用列式存储,每个列连续存储。列存在分析场景(聚合、过滤、排序等)表现优异,因为只需读取所需的列。但在点查场景(如 `SELECT
*`)中需要读取所有列,每列一次 IO,在列数较多的宽表(如上百列)上 IOPS 会成为瓶颈。
-为了解决点查场景 IOPS 的瓶颈问题,Doris 2.0.0 版本开始支持行列混存,用户建表时指定开启行存后,点查(比如 `SELECT
*`)每一行只需要一次 IO,在宽表列很多的情况下性能有数量级提升。
+为此,Doris 从 2.0.0
版本开始支持**行列混存**。在建表时开启行存后,系统会在存储时增加一个额外的列,将该行所有列拼接为紧凑二进制格式存储。点查时只需一次 IO
即可读取完整行数据,大幅降低 IOPS、提升查询延迟。
-行存的原理是在存储时增加了一个额外的列,这个列将对应行的所有列拼接起来采用特殊的二进制格式存储。
+## 适用场景
-## 使用语法
+以下场景推荐开启行存:
-建表时在表的 PROPERTIES 中指定是否开启行存,哪些列开启行存,行存的存储压缩单元大小 page_size。
+- **主键高并发点查**:在 Unique Key Merge-On-Write(MOW)表上,根据完整主键查找特定行。
+- **宽表 SELECT \* 查询**:在 Duplicate 表或 MOW 表上,仅返回少量行的 TOPN 查询。
-1. 是否开启行存:默认为 false 不开启
-```
-"store_row_column" = "true"
-```
+如果业务以分析查询为主(聚合、对少数列的复杂过滤等),通常仅列存即可满足需求。
-2. 哪些列开启行存:如果 `"store_row_column" = "true"`,默认所有列开启行存,若需要指定部分列开启行存,设置
row_store_columns 参数(3.0 之后的版本),格式为逗号分割的列名
-```
-"row_store_columns" = "column1,column2,column3"
-```
+## 建表配置
-3. 行存 page_size:默认为 16KB。
-```
-"row_store_page_size" = "16384"
-```
+通过 `CREATE TABLE` 的 `PROPERTIES` 设置行存相关参数:
+
+| 参数 | 默认值 | 支持版本 | 说明 |
+|------|--------|---------|------|
+| `"store_row_column" = "true"` | `false` | 2.0+ | 对**所有列**开启行存。 |
+| `"row_store_columns" = "col1,col2,..."` | 全部列 | 3.0+ | 仅对**指定列**开启行存。设置此参数时
`store_row_column` 隐式启用。相比全量行存可显著降低存储开销。 |
+| `"row_store_page_size" = "16384"` | `16384`(16 KB) | 2.0+ | 行存 page
大小(字节)。page 是最小 IO 单元——即使只读一行也需产生一个 page 的 IO。 |
Review Comment:
内联代码里出现了转义引号(例如 `\"store_row_column\" = \"true\"`),渲染后会把反斜杠也显示出来。Markdown
的反引号代码中不需要对双引号做转义,建议去掉反斜杠(写成 `"store_row_column" = "true"`)。
##########
docs/table-design/row-store.md:
##########
@@ -2,54 +2,88 @@
{
"title": "Hybrid Row-Columnar Storage",
"language": "en",
- "description": "Doris uses columnar storage by default, with each column
stored contiguously."
+ "description": "Doris hybrid row-columnar storage enables row-oriented
storage alongside columnar storage, reducing IOPS for point queries on wide
tables."
}
---
-## Hybrid Row-Columnar Storage
+## Overview
-Doris uses columnar storage by default, with each column stored contiguously.
Columnar storage offers excellent performance for analytical scenarios (such as
aggregation, filtering, sorting, etc.), as it only reads the necessary columns,
reducing unnecessary IO. However, in point query scenarios (such as `SELECT
*`), all columns need to be read, requiring an IO operation for each column,
which can lead to IOPS becoming a bottleneck, especially for wide tables with
many columns (e.g., hundreds of columns).
+Doris uses columnar storage by default, where each column is stored
contiguously. Columnar storage performs well in analytical scenarios
(aggregation, filtering, sorting, etc.) because it reads only the required
columns. However, when a query needs all columns — such as `SELECT *` in point
query scenarios — each column requires a separate IO operation, making IOPS a
bottleneck. This is especially noticeable on wide tables with hundreds of
columns.
-To address the IOPS bottleneck in point query scenarios, starting from version
2.0.0, Doris supports Hybrid Row-Columnar Storage. When users create tables,
they can specify whether to enable row storage. With row storage enabled, each
row only requires one IO operation for point queries (such as `SELECT *`),
significantly improving performance.
+To solve this, Doris supports **Hybrid Row-Columnar Storage** since version
2.0.0. When row storage is enabled at table creation, all columns of a row are
concatenated into a single additional column using a compact binary format. A
point query then reads a complete row in one IO operation instead of one IO per
column, significantly reducing IOPS and improving latency.
-The principle of row storage is that an additional column is added during
storage. This column concatenates all the columns of the corresponding row and
stores them using a special binary format.
+## Use Cases
-## Syntax
+Row storage is recommended in the following scenarios:
-When creating a table, specify whether to enable row storage, which columns to
enable row storage for, and the storage compression unit size page_size in the
table's PROPERTIES.
+- **High-concurrency primary key point queries** on Unique Key merge-on-write
(MOW) tables, where each query looks up a specific row by the full primary key.
+- **Wide-table SELECT \* queries** on Duplicate or MOW tables where only a
small number of rows are returned (TOPN pattern).
-1. Whether to enable row storage: defaults to false (not enabled).
-```
-"store_row_column" = "true"
-```
+If your workload is primarily analytical (aggregation, complex filtering on a
few columns), columnar storage alone is usually sufficient.
-2. Which columns to enable row storage for:if `"store_row_column" = "true"`,
all columns are enabled by default. If you need to specify that only some
columns are enabled for row storage, set the row_store_columns parameter (afer
version 3.0), formatted as a comma-separated list of column names.
-```
-"row_store_columns" = "column1,column2,column3"
-```
+## Table Properties
-3. Row storage page_size: defaults to 16KB.
-```
-"row_store_page_size" = "16384"
-```
+Enable and configure row storage through the following `PROPERTIES` when
creating a table.
-A page is the smallest unit for storage read and write operations, and
`page_size` refers to the size of a row-store page. This means that reading a
single row requires generating a page IO. The larger this value is, the better
the compression effect and the lower the storage space usage. However, the IO
overhead during point queries increases, resulting in lower performance
(because each IO operation reads at least one page). Conversely, the smaller
the value, the higher the storage space usage and the better the performance
for point queries. The default value of 16KB is a balanced choice in most
cases. If you prioritize query performance, you can configure a smaller value,
such as 4KB or even lower. If you prioritize storage space, you can configure a
larger value, such as 64KB or even higher.
+| Property | Default | Since | Description |
+|----------|---------|-------|-------------|
+| `"store_row_column" = "true"` | `false` | 2.0 | Enable row storage for
**all** columns. |
+| `"row_store_columns" = "col1,col2,..."` | All columns | 3.0 | Enable row
storage for **specified columns only**. When this property is set,
`store_row_column` is implicitly enabled. Using selective columns reduces
storage overhead compared to storing all columns. |
+| `"row_store_page_size" = "16384"` | `16384` (16 KB) | 2.0 | Size of the
row-store page in bytes. A page is the minimum IO unit — reading even a single
row requires one page IO. |
Review Comment:
Inline code spans are using escaped quotes (e.g., `\"store_row_column\" =
\"true\"`), which will display backslashes in the rendered docs. In Markdown,
quotes don’t need escaping inside backticks, so remove the backslashes (use
`"store_row_column" = "true"`).
##########
i18n/zh-CN/docusaurus-plugin-content-docs/version-3.x/table-design/row-store.md:
##########
@@ -2,52 +2,88 @@
{
"title": "行列混存",
"language": "zh-CN",
- "description": "Doris
默认采用列式存储,每个列连续存储,在分析场景(如聚合,过滤,排序等)有很好的性能,因为只需要读取所需要的列减少不必要的 IO。但是在点查场景(比如
SELECT ),需要读取所有列,每个列都需要一次 IO 导致 IOPS 成为瓶颈,特别对列多的宽表(比如上百列)尤为明显。"
+ "description": "Doris 行列混存功能在列存基础上增加行存,降低宽表点查场景的 IOPS 开销。"
}
---
-## 行列混存介绍
+## 概述
-Doris 默认采用列式存储,每个列连续存储,在分析场景(如聚合,过滤,排序等)有很好的性能,因为只需要读取所需要的列减少不必要的
IO。但是在点查场景(比如 `SELECT *`),需要读取所有列,每个列都需要一次 IO 导致 IOPS 成为瓶颈,特别对列多的宽表(比如上百列)尤为明显。
+Doris 默认采用列式存储,每个列连续存储。列存在分析场景(聚合、过滤、排序等)表现优异,因为只需读取所需的列。但在点查场景(如 `SELECT
*`)中需要读取所有列,每列一次 IO,在列数较多的宽表(如上百列)上 IOPS 会成为瓶颈。
-为了解决点查场景 IOPS 的瓶颈问题,Doris 2.0.0 版本开始支持行列混存,用户建表时指定开启行存后,点查(比如 `SELECT
*`)每一行只需要一次 IO,在宽表列很多的情况下性能有数量级提升。
+为此,Doris 从 2.0.0
版本开始支持**行列混存**。在建表时开启行存后,系统会在存储时增加一个额外的列,将该行所有列拼接为紧凑二进制格式存储。点查时只需一次 IO
即可读取完整行数据,大幅降低 IOPS、提升查询延迟。
-行存的原理是在存储时增加了一个额外的列,这个列将对应行的所有列拼接起来采用特殊的二进制格式存储。
+## 适用场景
-## 使用语法
+以下场景推荐开启行存:
-建表时在表的 PROPERTIES 中指定是否开启行存,哪些列开启行存,行存的存储压缩单元大小 page_size。
+- **主键高并发点查**:在 Unique Key Merge-On-Write(MOW)表上,根据完整主键查找特定行。
+- **宽表 SELECT \* 查询**:在 Duplicate 表或 MOW 表上,仅返回少量行的 TOPN 查询。
Review Comment:
这里会渲染成 `SELECT \*`(多了反斜杠),因为 `*` 被双重转义了。建议改成内联代码形式(`SELECT
*`),或只保留一次转义(`\*`),以确保页面显示为 `SELECT *`。
```suggestion
- **宽表 `SELECT *` 查询**:在 Duplicate 表或 MOW 表上,仅返回少量行的 TOPN 查询。
```
##########
i18n/zh-CN/docusaurus-plugin-content-docs/current/table-design/row-store.md:
##########
@@ -2,52 +2,88 @@
{
"title": "行列混存",
"language": "zh-CN",
- "description": "Doris
默认采用列式存储,每个列连续存储,在分析场景(如聚合,过滤,排序等)有很好的性能,因为只需要读取所需要的列减少不必要的 IO。但是在点查场景(比如
SELECT ),需要读取所有列,每个列都需要一次 IO 导致 IOPS 成为瓶颈,特别对列多的宽表(比如上百列)尤为明显。"
+ "description": "Doris 行列混存功能在列存基础上增加行存,降低宽表点查场景的 IOPS 开销。"
}
---
-## 行列混存介绍
+## 概述
-Doris 默认采用列式存储,每个列连续存储,在分析场景(如聚合,过滤,排序等)有很好的性能,因为只需要读取所需要的列减少不必要的
IO。但是在点查场景(比如 `SELECT *`),需要读取所有列,每个列都需要一次 IO 导致 IOPS 成为瓶颈,特别对列多的宽表(比如上百列)尤为明显。
+Doris 默认采用列式存储,每个列连续存储。列存在分析场景(聚合、过滤、排序等)表现优异,因为只需读取所需的列。但在点查场景(如 `SELECT
*`)中需要读取所有列,每列一次 IO,在列数较多的宽表(如上百列)上 IOPS 会成为瓶颈。
-为了解决点查场景 IOPS 的瓶颈问题,Doris 2.0.0 版本开始支持行列混存,用户建表时指定开启行存后,点查(比如 `SELECT
*`)每一行只需要一次 IO,在宽表列很多的情况下性能有数量级提升。
+为此,Doris 从 2.0.0
版本开始支持**行列混存**。在建表时开启行存后,系统会在存储时增加一个额外的列,将该行所有列拼接为紧凑二进制格式存储。点查时只需一次 IO
即可读取完整行数据,大幅降低 IOPS、提升查询延迟。
-行存的原理是在存储时增加了一个额外的列,这个列将对应行的所有列拼接起来采用特殊的二进制格式存储。
+## 适用场景
-## 使用语法
+以下场景推荐开启行存:
-建表时在表的 PROPERTIES 中指定是否开启行存,哪些列开启行存,行存的存储压缩单元大小 page_size。
+- **主键高并发点查**:在 Unique Key Merge-On-Write(MOW)表上,根据完整主键查找特定行。
+- **宽表 SELECT \* 查询**:在 Duplicate 表或 MOW 表上,仅返回少量行的 TOPN 查询。
Review Comment:
这里会渲染成 `SELECT \*`(多了反斜杠),因为 `*` 被双重转义了。建议改成内联代码形式(`SELECT
*`),或只保留一次转义(`\*`),以确保页面显示为 `SELECT *`。
```suggestion
- **宽表 `SELECT *` 查询**:在 Duplicate 表或 MOW 表上,仅返回少量行的 TOPN 查询。
```
##########
i18n/zh-CN/docusaurus-plugin-content-docs/version-4.x/table-design/row-store.md:
##########
@@ -2,52 +2,88 @@
{
"title": "行列混存",
"language": "zh-CN",
- "description": "Doris
默认采用列式存储,每个列连续存储,在分析场景(如聚合,过滤,排序等)有很好的性能,因为只需要读取所需要的列减少不必要的 IO。但是在点查场景(比如
SELECT ),需要读取所有列,每个列都需要一次 IO 导致 IOPS 成为瓶颈,特别对列多的宽表(比如上百列)尤为明显。"
+ "description": "Doris 行列混存功能在列存基础上增加行存,降低宽表点查场景的 IOPS 开销。"
}
---
-## 行列混存介绍
+## 概述
-Doris 默认采用列式存储,每个列连续存储,在分析场景(如聚合,过滤,排序等)有很好的性能,因为只需要读取所需要的列减少不必要的
IO。但是在点查场景(比如 `SELECT *`),需要读取所有列,每个列都需要一次 IO 导致 IOPS 成为瓶颈,特别对列多的宽表(比如上百列)尤为明显。
+Doris 默认采用列式存储,每个列连续存储。列存在分析场景(聚合、过滤、排序等)表现优异,因为只需读取所需的列。但在点查场景(如 `SELECT
*`)中需要读取所有列,每列一次 IO,在列数较多的宽表(如上百列)上 IOPS 会成为瓶颈。
-为了解决点查场景 IOPS 的瓶颈问题,Doris 2.0.0 版本开始支持行列混存,用户建表时指定开启行存后,点查(比如 `SELECT
*`)每一行只需要一次 IO,在宽表列很多的情况下性能有数量级提升。
+为此,Doris 从 2.0.0
版本开始支持**行列混存**。在建表时开启行存后,系统会在存储时增加一个额外的列,将该行所有列拼接为紧凑二进制格式存储。点查时只需一次 IO
即可读取完整行数据,大幅降低 IOPS、提升查询延迟。
-行存的原理是在存储时增加了一个额外的列,这个列将对应行的所有列拼接起来采用特殊的二进制格式存储。
+## 适用场景
-## 使用语法
+以下场景推荐开启行存:
-建表时在表的 PROPERTIES 中指定是否开启行存,哪些列开启行存,行存的存储压缩单元大小 page_size。
+- **主键高并发点查**:在 Unique Key Merge-On-Write(MOW)表上,根据完整主键查找特定行。
+- **宽表 SELECT \* 查询**:在 Duplicate 表或 MOW 表上,仅返回少量行的 TOPN 查询。
-1. 是否开启行存:默认为 false 不开启
-```
-"store_row_column" = "true"
-```
+如果业务以分析查询为主(聚合、对少数列的复杂过滤等),通常仅列存即可满足需求。
-2. 哪些列开启行存:如果 `"store_row_column" = "true"`,默认所有列开启行存,若需要指定部分列开启行存,设置
row_store_columns 参数(3.0 之后的版本),格式为逗号分割的列名
-```
-"row_store_columns" = "column1,column2,column3"
-```
+## 建表配置
-3. 行存 page_size:默认为 16KB。
-```
-"row_store_page_size" = "16384"
-```
+通过 `CREATE TABLE` 的 `PROPERTIES` 设置行存相关参数:
+
+| 参数 | 默认值 | 支持版本 | 说明 |
+|------|--------|---------|------|
+| `"store_row_column" = "true"` | `false` | 2.0+ | 对**所有列**开启行存。 |
+| `"row_store_columns" = "col1,col2,..."` | 全部列 | 3.0+ | 仅对**指定列**开启行存。设置此参数时
`store_row_column` 隐式启用。相比全量行存可显著降低存储开销。 |
+| `"row_store_page_size" = "16384"` | `16384`(16 KB) | 2.0+ | 行存 page
大小(字节)。page 是最小 IO 单元——即使只读一行也需产生一个 page 的 IO。 |
Review Comment:
内联代码里出现了转义引号(例如 `\"store_row_column\" = \"true\"`),渲染后会把反斜杠也显示出来。Markdown
的反引号代码中不需要对双引号做转义,建议去掉反斜杠(写成 `"store_row_column" = "true"`)。
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]