This is an automated email from the ASF dual-hosted git repository.
eldenmoon pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris-website.git
The following commit(s) were added to refs/heads/master by this push:
new e86ca9bf114 [doc](query) Remove row cache descriptions (#4607)
e86ca9bf114 is described below
commit e86ca9bf114ced02e9b5f884e70e307aa90236c0
Author: lihangyu <[email protected]>
AuthorDate: Sun Nov 15 18:52:11 2026 -0800
[doc](query) Remove row cache descriptions (#4607)
Remove row-cache descriptions from the published point-query guides,
feature pages, cache diagnostics, blogs, and release notes. This
includes the two BE settings, examples, and links to the removed
sections. Keep row-store and prepared-statement guidance and retain the
2.0 and 2.1 archived snapshots.
---
...eased-Database-Query-Concurrency-by-20-Times.md | 23 ++--------------------
...expect-from-apache-doris-as-a-data-warehouse.md | 2 +-
...wn-data-silos-with-an-apache-doris-based-cdp.md | 5 ++---
blog/release-note-2.0.0.md | 2 +-
.../memory-analysis/doris-cache-memory-analysis.md | 1 -
docs/key-features/columnar-storage.mdx | 2 +-
docs/key-features/high-concurrency-point-query.mdx | 7 +++----
docs/key-features/prepared-statement.mdx | 2 +-
.../high-concurrent-point-query.md | 19 +-----------------
.../memory-analysis/doris-cache-memory-analysis.md | 1 -
.../key-features/high-concurrency-point-query.mdx | 7 +++----
.../current/key-features/prepared-statement.mdx | 2 +-
.../high-concurrent-point-query.md | 19 +-----------------
.../memory-analysis/doris-cache-memory-analysis.md | 1 -
.../key-features/high-concurrency-point-query.mdx | 7 +++----
.../key-features/prepared-statement.mdx | 2 +-
.../high-concurrent-point-query.md | 19 +-----------------
.../memory-analysis/doris-cache-memory-analysis.md | 1 -
.../current/key-features/columnar-storage.mdx | 2 +-
.../key-features/high-concurrency-point-query.mdx | 7 +++----
.../current/key-features/prepared-statement.mdx | 2 +-
.../high-concurrent-point-query.md | 19 +-----------------
.../memory-analysis/doris-cache-memory-analysis.md | 1 -
.../version-4.x/key-features/columnar-storage.mdx | 2 +-
.../key-features/high-concurrency-point-query.mdx | 7 +++----
.../key-features/prepared-statement.mdx | 2 +-
.../high-concurrent-point-query.md | 19 +-----------------
.../memory-analysis/doris-cache-memory-analysis.md | 1 -
.../current/key-features/columnar-storage.mdx | 2 +-
.../key-features/high-concurrency-point-query.mdx | 7 +++----
.../current/key-features/prepared-statement.mdx | 2 +-
.../high-concurrent-point-query.md | 19 +-----------------
.../memory-analysis/doris-cache-memory-analysis.md | 1 -
.../version-4.x/key-features/columnar-storage.mdx | 2 +-
.../key-features/high-concurrency-point-query.mdx | 7 +++----
.../key-features/prepared-statement.mdx | 2 +-
.../high-concurrent-point-query.md | 19 +-----------------
.../memory-analysis/doris-cache-memory-analysis.md | 1 -
.../high-concurrent-point-query.md | 19 +-----------------
.../memory-analysis/doris-cache-memory-analysis.md | 1 -
.../high-concurrent-point-query.md | 8 --------
.../memory-analysis/doris-cache-memory-analysis.md | 1 -
.../high-concurrent-point-query.md | 19 +-----------------
releasenotes/v2.0/release-2.0.0.md | 4 ++--
.../memory-analysis/doris-cache-memory-analysis.md | 1 -
.../high-concurrent-point-query.md | 7 -------
.../memory-analysis/doris-cache-memory-analysis.md | 1 -
.../version-4.x/key-features/columnar-storage.mdx | 2 +-
.../key-features/high-concurrency-point-query.mdx | 7 +++----
.../key-features/prepared-statement.mdx | 2 +-
.../high-concurrent-point-query.md | 19 +-----------------
51 files changed, 56 insertions(+), 281 deletions(-)
diff --git a/blog/How-We-Increased-Database-Query-Concurrency-by-20-Times.md
b/blog/How-We-Increased-Database-Query-Concurrency-by-20-Times.md
index 098b1d61362..56805ec6323 100644
--- a/blog/How-We-Increased-Database-Query-Concurrency-by-20-Times.md
+++ b/blog/How-We-Increased-Database-Query-Concurrency-by-20-Times.md
@@ -217,25 +217,6 @@ resultSet = readStatement.executeQuery();
...
```
-### Row Storage Cache
-
-Apache Doris has a Page Cache feature, where each page caches the data of one
column.
-
-
-
-As mentioned above, we have introduced row storage in Doris. The problem with
this is, one row of data consists of multiple columns, so in the case of big
queries, the cached data might be erased. Thus, we also introduced row cache to
increase row cache hit rate.
-
-Row cache reuses the LRU Cache mechanism in Apache Doris. When the caching
starts, the system will initialize a threshold value. If that threshold is hit,
the old cached rows will be phased out. For a primary key query statement, the
performance gap between cache hit and cache miss can be huge (we are talking
about dozens of times less disk I/O and memory access here). So the
introduction of row cache can remarkably enhance point query performance.
-
-
-
-To enable row cache, you can specify the following configuration in BE:
-
-```JSON
-disable_storage_row_cache=false // This specifies whether to enable row cache;
it is set to false by default.
-row_cache_mem_limit=20% // This specifies the percentage of row cache in the
memory; it is set to 20% by default.
-```
-
## Benchmark Performance
We tested Apache Doris with YCSB (Yahoo! Cloud Serving Benchmark) to see how
all these optimizations work.
@@ -323,8 +304,8 @@ For a primary key-based point query like the one below,
after table creation, yo
select * from usertable where USER_KEY = xxx;
```
-To further unleash performance, you can apply prepared statement. If you have
enough memory space, you can also enable row cache in the BE configuration.
+To further unleash performance, you can apply prepared statement.
## Conclusion
-In high-concurrency scenarios, Apache Doris realizes over 30,000 QPS per node
after optimizations including row storage, short-circuit, prepared statement,
and row cache. Also, Apache Doris is easily scaled out since it is built on MPP
architecture, on top of which you can scale it up by upgrading the hardware and
machine configuration. This is how Apache Doris manages to achieve both high
throughput and high concurrency. It allows you to deal with various data
analytic workloads on one [...]
+In high-concurrency scenarios, Apache Doris realizes over 30,000 QPS per node
after optimizations including row storage, short-circuit, and prepared
statements. Also, Apache Doris is easily scaled out since it is built on MPP
architecture, on top of which you can scale it up by upgrading the hardware and
machine configuration. This is how Apache Doris manages to achieve both high
throughput and high concurrency. It allows you to deal with various data
analytic workloads on one single pla [...]
diff --git
a/blog/apache-doris-summit-asia-2023-what-can-you-expect-from-apache-doris-as-a-data-warehouse.md
b/blog/apache-doris-summit-asia-2023-what-can-you-expect-from-apache-doris-as-a-data-warehouse.md
index 99184fec15b..49f14f8694e 100644
---
a/blog/apache-doris-summit-asia-2023-what-can-you-expect-from-apache-doris-as-a-data-warehouse.md
+++
b/blog/apache-doris-summit-asia-2023-what-can-you-expect-from-apache-doris-as-a-data-warehouse.md
@@ -78,7 +78,7 @@ In traditional data reporting, data is often arranged in flat
tables. The idea o
Similarly, the new version of Doris has automated another
engineering-intensive process: adjusting the compute instance execution
concurrency in the backend. What bothered our users was that when queries of
different sizes happened concurrently, these queries tended to fight for
resources and thus required human intervention. To solve that, we have
introduced a pipeline execution model. It automatically decides the execution
concurrency for the current situation to make sure queries of a [...]
-For **[high concurrency point
queries](https://doris.apache.org/blog/How-We-Increased-Database-Query-Concurrency-by-20-Times)**,
Apache Doris 2.0 reached a throughput of 30,000 QPS. It is a 20-fold
improvement driven by optimizations in data storage, reading, and query
execution. As a column-oriented DBMS, Apache Doris has relatively low row
reading efficiency, so we have introduced ow/column hybrid storage and [row
cache](https://doris.apache.org/docs/query-acceleration/hight-concurrent [...]
+For **[high concurrency point
queries](https://doris.apache.org/blog/How-We-Increased-Database-Query-Concurrency-by-20-Times)**,
Apache Doris 2.0 reached a throughput of 30,000 QPS. It is a 20-fold
improvement driven by optimizations in data storage, reading, and query
execution. As a column-oriented DBMS, Apache Doris has relatively low row
reading efficiency, so we have introduced row/column hybrid storage to make up
for that. We have also enabled the short circuit plan and prepared st [...]

diff --git a/blog/breaking-down-data-silos-with-an-apache-doris-based-cdp.md
b/blog/breaking-down-data-silos-with-an-apache-doris-based-cdp.md
index 9f8deabb2c3..66ec5401d06 100644
--- a/blog/breaking-down-data-silos-with-an-apache-doris-based-cdp.md
+++ b/blog/breaking-down-data-silos-with-an-apache-doris-based-cdp.md
@@ -93,12 +93,11 @@ curl --location-trusted -u root: -H "partial_columns:true"
-H "column_separator:
**3. High-concurrency point queries:**
-With its current business size, the company is receiving query requests for
tags at a concurrency level of over 5000 QPS. They use a combination of
strategies to guarantee high performance. Firstly, they adopt [Prepared
Statement](https://doris.apache.org/docs/query-acceleration/hight-concurrent-point-query#using-preparedstatement)
for pre-compilation and pre-execution of SQL. Secondly, they fine-tune the
parameters for Doris Backend and the tables to optimize storage and execution.
Last [...]
+With its current business size, the company is receiving query requests for
tags at a concurrency level of over 5000 QPS. They use a combination of
strategies to guarantee high performance. Firstly, they adopt [Prepared
Statement](https://doris.apache.org/docs/query-acceleration/hight-concurrent-point-query#using-preparedstatement)
for pre-compilation and pre-execution of SQL. Secondly, they fine-tune the
parameters for Doris Backend and the tables to optimize storage and execution.
-- Fine-tune Doris Backend parameters in `be.conf`:
+- Fine-tune the Doris Backend page cache in `be.conf`:
```SQL
-disable_storage_row_cache = false
storage_page_cache_limit=40%
```
diff --git a/blog/release-note-2.0.0.md b/blog/release-note-2.0.0.md
index 10e7dc8e3ee..234916768d0 100644
--- a/blog/release-note-2.0.0.md
+++ b/blog/release-note-2.0.0.md
@@ -76,7 +76,7 @@ A smartphone manufacturer tested Apache Doris 2.0.0 in their
user behavior analy
In scenarios like e-commerce order queries and express tracking, a huge number
of end data users search for a certain data record simultaneously. These are
what we call high-concurrency point queries, which can bring huge pressure on
the system. A traditional solution is to introduce Key-Value stores like Apache
HBase for such queries, and Redis as a cache layer to ease the burden, but that
means redundant storage and higher maintenance costs.
-For a column-oriented DBMS like Apache Doris, the I/O usage of point queries
will be multiplied. We need neater execution. Thus, on the basis of columnar
storage, we added row storage format and row cache to increase row reading
efficiency, short-circuit plans to speed up data retrieval, and prepared
statements to reduce frontend overheads.
+For a column-oriented DBMS like Apache Doris, the I/O usage of point queries
will be multiplied. We need neater execution. Thus, on the basis of columnar
storage, we added a row storage format to increase row reading efficiency,
short-circuit plans to speed up data retrieval, and prepared statements to
reduce frontend overheads.
After these optimizations, Apache Doris 2.0 reached a concurrency level of
**30,000 QPS per node** on YCSB on a 16 Core 64G cloud server with 4×1T hard
drives, representing an improvement of **20 times** compared to its older
version. This makes Apache Doris a good alternative to HBase in
high-concurrency scenarios, so that users don't need to endure extra
maintenance costs and redundant storage brought by complicated tech stacks.
diff --git
a/docs/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
b/docs/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
index 280f4522c7a..934b33ec50e 100644
---
a/docs/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
+++
b/docs/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
@@ -56,7 +56,6 @@ Speed up inverted index.
Speed up point query execution, mainly used for log analysis.
```
-- PointQueryRowCache
- PointQueryLookupConnectionCache
```
diff --git a/docs/key-features/columnar-storage.mdx
b/docs/key-features/columnar-storage.mdx
index 5055969e917..80b53bb96af 100644
--- a/docs/key-features/columnar-storage.mdx
+++ b/docs/key-features/columnar-storage.mdx
@@ -108,7 +108,7 @@ Apache Doris columnar storage is the default and only OLAP
format, so every anal
**Not a good fit**
-- `SELECT *` lookups by primary key at thousands of QPS. Each column is a
separate read, so a wide-row point query pays N times the I/O. Reach for the
[High-Concurrency Point Query](./high-concurrency-point-query) path, which adds
a row-cached column with `"store_row_column" = "true"` on top of a Unique-Key
Merge-on-Write table.
+- `SELECT *` lookups by primary key at thousands of QPS. Each column is a
separate read, so a wide-row point query pays N times the I/O. Reach for the
[High-Concurrency Point Query](./high-concurrency-point-query) path, which adds
a row-format column with `"store_row_column" = "true"` on top of a Unique-Key
Merge-on-Write table.
- Tweaking `compression` or `storage_page_size` without a profile. The
defaults (LZ4F, 64 KB) fit most workloads. Move to ZSTD only when storage cost
matters more than CPU; shrink the page size only when small columns are wasting
decompression work.
- Disabling encodings to "see the raw column." There is no raw mode. The codec
is part of the file format, not a layer you peel off.
- Treating columnar storage as a fix for narrow point lookups on a
row-oriented schema. If every query is `WHERE id = ?` and returns one row, you
want a different system or the row-store extension, not a different compression
codec.
diff --git a/docs/key-features/high-concurrency-point-query.mdx
b/docs/key-features/high-concurrency-point-query.mdx
index 24a45a253dc..457d1cdc93f 100644
--- a/docs/key-features/high-concurrency-point-query.mdx
+++ b/docs/key-features/high-concurrency-point-query.mdx
@@ -45,17 +45,16 @@ The Apache Doris high-concurrency point query is a
four-layer optimization that
- **`store_row_column`**: a table property that adds a hidden column holding
each row in a row-encoded blob, so the BE reads one column instead of N to
return a whole row.
- **`SHORT-CIRCUIT`**: a marker in `EXPLAIN` output that appears once the
planner has skipped the normal distributed plan and routed the query through a
single-tablet, single-RPC path.
- **`PreparedStatement`**: server-side statement caching over the MySQL
protocol. Apache Doris caches the parsed statement, output expressions, and
descriptor table per session, then reuses them across `EXECUTE` calls.
-- **`Row Cache`**: a separate LRU cache that holds whole rows. It survives the
eviction pressure that the columnar Page Cache suffers under mixed analytical
and point-query workloads.
## How does the Apache Doris high-concurrency point query work? {#how}
-The Apache Doris high-concurrency point query path threads five layers
together: storage layout, FE plan rewrite, short-circuit dispatch, server-side
`PreparedStatement` reuse, and a BE row lookup with optional Row Cache.
+The Apache Doris high-concurrency point query path threads five layers
together: storage layout, FE plan rewrite, short-circuit dispatch, server-side
`PreparedStatement` reuse, and a BE row lookup.
1. **Storage layout.** When you set `store_row_column=true` at table creation,
the BE writes each row both into the columnar segments and into a row-encoded
hidden column. From Apache Doris 3.0 onward you can scope this to a subset with
`row_store_columns="k1,v1,v2"` to limit the storage overhead.
2. **Plan rewrite (FE).** The Nereids rule
`LogicalResultSinkToShortCircuitPointQuery` checks the query shape: single
Unique table, equality conjuncts on every key column, no joins or subqueries,
no aggregations. If everything matches, it flips the `isShortCircuitQuery` flag
in the `StatementContext`.
3. **Short-circuit dispatch.** Instead of building fragments and shipping
them, the FE resolves the bucket through `PartitionPruneV2ForShortCircuitPlan`,
picks the one tablet that can hold the key, and sends a single RPC to the BE
that owns it.
4. **Server-side `PreparedStatement` reuse.** With `useServerPrepStmts=true`,
the FE caches the `ShortCircuitQueryContext` per session UUID. Subsequent
`EXECUTE` calls skip parsing and planning entirely; only the parameter values
change.
-5. **BE row lookup.** The `point_query_executor` locates the row by key, reads
the row-format column, and returns the bytes. The optional Row Cache
short-circuits even the segment read on a hit.
+5. **BE row lookup.** The `point_query_executor` locates the row by key, reads
the row-format column, and returns the bytes.
## Quick start {#quick-start}
@@ -109,7 +108,7 @@ The Apache Doris high-concurrency point query fits any
online service that reads
## Performance and verification {#performance}
-Apache Doris reports that enabling server-side `PreparedStatement` on top of
the short-circuit path delivers more than a 4x throughput improvement when FE
CPU is the bottleneck. This is the same 4x cited from the prepared-statement
angle in the [Prepared Statement card](./prepared-statement) — one combined
gain, not two stackable ones. Numbers depend on row width, row cache hit rate,
and how many FE Observers absorb traffic, so treat that as a planning floor,
not a benchmark.
+Apache Doris reports that enabling server-side `PreparedStatement` on top of
the short-circuit path delivers more than a 4x throughput improvement when FE
CPU is the bottleneck. This is the same 4x cited from the prepared-statement
angle in the [Prepared Statement card](./prepared-statement) — one combined
gain, not two stackable ones. Numbers depend on row width and how many FE
Observers absorb traffic, so treat that as a planning floor, not a benchmark.
Two checks tell you the path is live:
diff --git a/docs/key-features/prepared-statement.mdx
b/docs/key-features/prepared-statement.mdx
index d7476837106..b40eeedfae9 100644
--- a/docs/key-features/prepared-statement.mdx
+++ b/docs/key-features/prepared-statement.mdx
@@ -114,7 +114,7 @@ Apache Doris prepared statements fit high-QPS point queries
on Unique Key tables
## Performance and verification {#performance}
-Doris reports a [4x or better throughput
improvement](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/)
from PreparedStatement on point-query workloads where FE CPU is the
bottleneck. This is the same 4x cited from the short-circuit angle in the
[High-Concurrency Point Query card](./high-concurrency-point-query) — one
combined gain, not two stackable ones. The full high-concurrency stack (Unique
Key + Merge-on-Write + row store + row cache + short-circuit [...]
+Doris reports a [4x or better throughput
improvement](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/)
from PreparedStatement on point-query workloads where FE CPU is the
bottleneck. This is the same 4x cited from the short-circuit angle in the
[High-Concurrency Point Query card](./high-concurrency-point-query) — one
combined gain, not two stackable ones. The full high-concurrency stack reaches
[30,000+ QPS per node](https://doris.apache.org/blog/How-We- [...]
Two checks tell you the path is live:
diff --git a/docs/query-acceleration/high-concurrent-point-query.md
b/docs/query-acceleration/high-concurrent-point-query.md
index e3fa54da517..e3acb064654 100644
--- a/docs/query-acceleration/high-concurrent-point-query.md
+++ b/docs/query-acceleration/high-concurrent-point-query.md
@@ -2,7 +2,7 @@
{
"title": "High-Concurrency Point Query",
"language": "en",
- "description": "How to enable high-concurrency point queries in Doris?
Significantly improve primary-key point-query QPS and response latency through
row store, short-circuit path, PreparedStatement, and row cache.",
+ "description": "How to enable high-concurrency point queries in Doris?
Significantly improve primary-key point-query QPS and response latency through
row store, short-circuit path, and PreparedStatement.",
"keywords": [
"Doris high-concurrency point query",
"primary-key point-query optimization",
@@ -10,7 +10,6 @@
"row store store_row_column",
"Merge-On-Write point query",
"SHORT-CIRCUIT short path",
- "row cache",
"FE high CPU point-query bottleneck"
]
}
@@ -30,7 +29,6 @@ To address this, Doris applies optimizations at the following
layers:
| Row Store | Columnar storage amplifies random IO when reading whole rows of
wide tables; row store reduces IO overhead |
| Short-Circuit query path (SHORT-CIRCUIT) | FE query planning and parsing is
too heavy for simple queries; the short-circuit path bypasses the regular
planning flow |
| PreparedStatement | SQL parsing and expression evaluation consume FE CPU;
caching the plan and expressions reduces overhead |
-| Row Cache | The Page Cache is easily evicted by large queries; a dedicated
row cache improves hit rate |
## Quick Enablement Checklist
@@ -41,7 +39,6 @@ Before using high-concurrency point queries, confirm that all
of the following c
- `light_schema_change = true` is enabled at table creation
- The query contains only **equality conditions on Key columns**, with no
joins or nested subqueries
- The JDBC URL has `useServerPrepStmts=true` enabled to use PreparedStatement
-- (Optional) BE configuration `disable_storage_row_cache = false` is set to
enable row cache
- Use `EXPLAIN` to verify that the execution plan contains the `SHORT-CIRCUIT`
marker
## Row Store
@@ -143,20 +140,6 @@ resultSet = readStatement.executeQuery();
...
```
-## Enabling Row Cache
-
-<!-- Knowledge type: Configuration parameter -->
-<!-- Applicable scenarios: Low row-store hit rate, Page Cache easily evicted
-->
-
-By default, Doris provides a **Page-level cache**, where each page stores data
for a single column, so the Page Cache is column-oriented. For row store, a row
contains multiple columns, and the cache may be flushed by large queries.
-
-To improve the hit rate, Doris introduces a separate **Row Cache** that reuses
the LRU Cache mechanism to control memory usage. Enable it through the
following BE configurations:
-
-| Configuration | Default | Description |
-| ---------------------------- | ---------- |
--------------------------------- |
-| `disable_storage_row_cache` | `true` (disabled by default) | Whether to
disable row cache. Set to `false` to enable |
-| `row_cache_mem_limit` | `20%` | Percentage of memory used by the Row Cache |
-
## Performance Tuning Recommendations
<!-- Knowledge type: Performance tuning -->
diff --git
a/i18n/ja/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
b/i18n/ja/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
index 8deaf7ffa64..a55c6a55670 100644
---
a/i18n/ja/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
+++
b/i18n/ja/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
@@ -56,7 +56,6 @@ Doris が管理するキャッシュは、現在すべて LRU 方式でエント
主にログ分析で使用するポイントクエリの実行を高速化します。
```
-- PointQueryRowCache
- PointQueryLookupConnectionCache
```
diff --git
a/i18n/ja/docusaurus-plugin-content-docs/current/key-features/high-concurrency-point-query.mdx
b/i18n/ja/docusaurus-plugin-content-docs/current/key-features/high-concurrency-point-query.mdx
index 7c064825468..28e609479f8 100644
---
a/i18n/ja/docusaurus-plugin-content-docs/current/key-features/high-concurrency-point-query.mdx
+++
b/i18n/ja/docusaurus-plugin-content-docs/current/key-features/high-concurrency-point-query.mdx
@@ -46,17 +46,16 @@ Apache Doris の高同時実行ポイントクエリは、テーブルとクエ
-
**`store_row_column`**:各行を行形式でエンコードしたデータとして保持する隠しカラムを追加するテーブルプロパティです。これにより、BE
は行全体を返す際に N 個のカラムではなく一つのカラムを読み取ります。
- **`SHORT-CIRCUIT`**:プランナーが通常の分散プランを省略し、一つのタブレットに対する一回の RPC
を使う経路にクエリを送ったとき、`EXPLAIN` の出力に表示されるマーカーです。
- **`PreparedStatement`**:MySQL プロトコルを介したサーバー側のステートメントキャッシュです。Apache Doris
は解析済みステートメント、出力式、ディスクリプタテーブルをセッションごとにキャッシュし、`EXECUTE` 呼び出し間で再利用します。
-- **`Row Cache`**:行全体を保持する独立した LRU キャッシュです。分析クエリとポイントクエリが混在するワークロードで、カラム指向の
Page Cache が受けるキャッシュ追い出しの影響を受けずに利用できます。
## Apache Doris の高同時実行ポイントクエリの仕組み {#how}
-Apache Doris の高同時実行ポイントクエリ経路は、ストレージレイアウト、FE
によるプランの書き換え、ショートサーキットでのディスパッチ、サーバー側での `PreparedStatement` の再利用、オプションの Row Cache
を使う BE の行検索という五つの層を連携させます。
+Apache Doris の高同時実行ポイントクエリ経路は、ストレージレイアウト、FE
によるプランの書き換え、ショートサーキットでのディスパッチ、サーバー側での `PreparedStatement` の再利用、BE
の行検索という五つの層を連携させます。
1. **ストレージレイアウト。** テーブル作成時に `store_row_column=true` を設定すると、BE
は各行をカラム指向のセグメントと、行形式でエンコードした隠しカラムの両方に書き込みます。Apache Doris 3.0
以降では、`row_store_columns="k1,v1,v2"` を使って対象を一部のカラムに限定し、ストレージのオーバーヘッドを抑えられます。
2. **プランの書き換え(FE)。** Nereids のルール `LogicalResultSinkToShortCircuitPointQuery`
は、単一の Unique
テーブル、すべてのキーカラムに対する等価の連言述語、結合やサブクエリなし、集計なしというクエリの形を確認します。すべて一致すると、`isShortCircuitQuery`
フラグを `StatementContext` 内で有効にします。
3. **ショートサーキットでのディスパッチ。** FE
はフラグメントの生成と送信の代わりに、`PartitionPruneV2ForShortCircuitPlan`
でバケットを特定し、そのキーを保持し得る一つのタブレットを選び、所有する BE に一回の RPC を送ります。
4. **サーバー側での `PreparedStatement` の再利用。** `useServerPrepStmts=true` の場合、FE は
`ShortCircuitQueryContext` をセッション UUID ごとにキャッシュします。その後の `EXECUTE`
呼び出しでは解析とプランニングをすべて省略し、パラメーター値だけを変更します。
-5. **BE での行検索。** `point_query_executor`
はキーで行を特定し、行形式のカラムを読み取ってバイト列を返します。オプションの Row Cache にヒットした場合は、セグメントの読み取りも省略します。
+5. **BE での行検索。** `point_query_executor` はキーで行を特定し、行形式のカラムを読み取ってバイト列を返します。
## クイックスタート {#quick-start}
@@ -110,7 +109,7 @@ Apache Doris の高同時実行ポイントクエリは、リクエストごと
## 性能と確認方法 {#performance}
-Apache Doris によると、FE の CPU がボトルネックの場合、ショートサーキット経路に加えてサーバー側の
`PreparedStatement` を有効にすると、スループットが 4 倍以上向上します。これは [Prepared Statement
の紹介ページ](./prepared-statement)で、Prepared Statement の観点から示されているものと同じ 4
倍の効果です。二つの効果を重ね合わせたものではありません。数値は行の幅、Row Cache のヒット率、トラフィックを受け持つ FE Observer
の数によって変わるため、ベンチマーク値ではなく計画上の下限として扱ってください。
+Apache Doris によると、FE の CPU がボトルネックの場合、ショートサーキット経路に加えてサーバー側の
`PreparedStatement` を有効にすると、スループットが 4 倍以上向上します。これは [Prepared Statement
の紹介ページ](./prepared-statement)で、Prepared Statement の観点から示されているものと同じ 4
倍の効果です。二つの効果を重ね合わせたものではありません。数値は行の幅とトラフィックを受け持つ FE Observer
の数によって変わるため、ベンチマーク値ではなく計画上の下限として扱ってください。
次の二点で、この経路が有効であることを確認できます。
diff --git
a/i18n/ja/docusaurus-plugin-content-docs/current/key-features/prepared-statement.mdx
b/i18n/ja/docusaurus-plugin-content-docs/current/key-features/prepared-statement.mdx
index 483dd29d089..7d4820c75e8 100644
---
a/i18n/ja/docusaurus-plugin-content-docs/current/key-features/prepared-statement.mdx
+++
b/i18n/ja/docusaurus-plugin-content-docs/current/key-features/prepared-statement.mdx
@@ -115,7 +115,7 @@ Apache Doris のプリペアドステートメントは、Unique Key テーブ
## 性能と検証 {#performance}
-Doris は、FE の CPU がボトルネックとなる一点検索のワークロードで、PreparedStatement によって[スループットが 4
倍以上向上する](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/)と報告しています。これは[高並行性の一点検索の機能紹介](./high-concurrency-point-query)でショートサーキットの観点から示される
4 倍と同じ値であり、二つを掛け合わせられるわけではありません。高並行性に向けた構成全体(Unique Key + Merge-on-Write +
行ストア + 行キャッシュ + ショートサーキット + PreparedStatement)では、16 コア / 64GB のマシンで YCSB
を実行し、[ノードあたり 30,000+
QPS](https://doris.apache.org/blog/How-We-Increased-Database-Query-Concurrency-
[...]
+Doris は、FE の CPU がボトルネックとなる一点検索のワークロードで、PreparedStatement によって[スループットが 4
倍以上向上する](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/)と報告しています。これは[高並行性の一点検索の機能紹介](./high-concurrency-point-query)でショートサーキットの観点から示される
4 倍と同じ値であり、二つを掛け合わせられるわけではありません。高並行性に向けた構成全体では、16 コア / 64GB のマシンで YCSB
を実行し、[ノードあたり 30,000+
QPS](https://doris.apache.org/blog/How-We-Increased-Database-Query-Concurrency-by-20-Times/)に達し、最適化前のベースラインと比べて平均レイテンシーが
96% 減少しました。PreparedStatement 単体の寄与を [...]
次の二点を確認すると、この経路が有効かどうかを判断できます。
diff --git
a/i18n/ja/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
b/i18n/ja/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
index 1f63ab46bec..fc85894ebde 100644
---
a/i18n/ja/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
+++
b/i18n/ja/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
@@ -2,7 +2,7 @@
{
"title": "高同時実行ポイントクエリ",
"language": "ja",
- "description": "Doris
で高同時実行ポイントクエリを有効にする方法。行ストア、ショートサーキット経路、PreparedStatement、行キャッシュを使用して、主キーによるポイントクエリの
QPS と応答速度を大幅に改善します。",
+ "description": "Doris
で高同時実行ポイントクエリを有効にする方法。行ストア、ショートサーキット経路、PreparedStatement を使用して、主キーによるポイントクエリの
QPS と応答速度を大幅に改善します。",
"keywords": [
"Doris 高同時実行ポイントクエリ",
"主キーによるポイントクエリの最適化",
@@ -10,7 +10,6 @@
"行ストア store_row_column",
"Merge-On-Write ポイントクエリ",
"SHORT-CIRCUIT ショートサーキット経路",
- "行キャッシュ",
"FE の高 CPU 使用率によるポイントクエリのボトルネック"
]
}
@@ -30,7 +29,6 @@
| 行ストア | 幅の広いテーブルから行全体を読み取る際、列指向ストレージではランダム I/O が増えるため、行ストアによって I/O
のオーバーヘッドを減らします |
| ショートサーキットクエリ経路(SHORT-CIRCUIT) | 単純なクエリに対して FE
のクエリプランニングと解析は負荷が大きいため、通常のプランニング処理を迂回します |
| PreparedStatement | SQL の解析と式の評価は FE の CPU を消費するため、プランと式をキャッシュして負荷を減らします |
-| 行キャッシュ | 大規模なクエリによって Page Cache の内容は退避されやすいため、専用の行キャッシュでヒット率を高めます |
## 有効化のためのクイックチェックリスト
@@ -41,7 +39,6 @@
- テーブル作成時に `light_schema_change = true` を有効にしている
- クエリには **Key 列に対する等価条件のみ**が含まれ、結合やネストしたサブクエリがない
- PreparedStatement を使用するため、JDBC URL で `useServerPrepStmts=true` を有効にしている
-- (任意)行キャッシュを有効にするため、BE の設定で `disable_storage_row_cache = false` を指定している
- `EXPLAIN` を使用し、実行プランに `SHORT-CIRCUIT` マーカーが含まれることを確認している
## 行ストア
@@ -143,20 +140,6 @@ resultSet = readStatement.executeQuery();
...
```
-## 行キャッシュの有効化
-
-<!-- Knowledge type: Configuration parameter -->
-<!-- Applicable scenarios: Low row-store hit rate, Page Cache easily evicted
-->
-
-Doris はデフォルトで**ページ単位のキャッシュ**を提供します。各ページには単一の列のデータが格納されるため、Page Cache
は列指向です。行ストアでは一行に複数の列が含まれ、キャッシュの内容が大規模なクエリによって退避される可能性があります。
-
-ヒット率を高めるため、Doris はメモリ使用量の制御に LRU Cache の仕組みを再利用した、独立した**行キャッシュ**を導入しています。次の BE
設定で有効にします。
-
-| 設定 | デフォルト値 | 説明 |
-| ---------------------------- | ---------- |
--------------------------------- |
-| `disable_storage_row_cache` | `true`(デフォルトでは無効) | 行キャッシュを無効にするかどうか。`false`
に設定すると有効になります |
-| `row_cache_mem_limit` | `20%` | 行キャッシュが使用するメモリの割合 |
-
## 性能チューニングの推奨事項
<!-- Knowledge type: Performance tuning -->
diff --git
a/i18n/ja/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
b/i18n/ja/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
index 8deaf7ffa64..a55c6a55670 100644
---
a/i18n/ja/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
+++
b/i18n/ja/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
@@ -56,7 +56,6 @@ Doris が管理するキャッシュは、現在すべて LRU 方式でエント
主にログ分析で使用するポイントクエリの実行を高速化します。
```
-- PointQueryRowCache
- PointQueryLookupConnectionCache
```
diff --git
a/i18n/ja/docusaurus-plugin-content-docs/version-4.x/key-features/high-concurrency-point-query.mdx
b/i18n/ja/docusaurus-plugin-content-docs/version-4.x/key-features/high-concurrency-point-query.mdx
index 7c064825468..28e609479f8 100644
---
a/i18n/ja/docusaurus-plugin-content-docs/version-4.x/key-features/high-concurrency-point-query.mdx
+++
b/i18n/ja/docusaurus-plugin-content-docs/version-4.x/key-features/high-concurrency-point-query.mdx
@@ -46,17 +46,16 @@ Apache Doris の高同時実行ポイントクエリは、テーブルとクエ
-
**`store_row_column`**:各行を行形式でエンコードしたデータとして保持する隠しカラムを追加するテーブルプロパティです。これにより、BE
は行全体を返す際に N 個のカラムではなく一つのカラムを読み取ります。
- **`SHORT-CIRCUIT`**:プランナーが通常の分散プランを省略し、一つのタブレットに対する一回の RPC
を使う経路にクエリを送ったとき、`EXPLAIN` の出力に表示されるマーカーです。
- **`PreparedStatement`**:MySQL プロトコルを介したサーバー側のステートメントキャッシュです。Apache Doris
は解析済みステートメント、出力式、ディスクリプタテーブルをセッションごとにキャッシュし、`EXECUTE` 呼び出し間で再利用します。
-- **`Row Cache`**:行全体を保持する独立した LRU キャッシュです。分析クエリとポイントクエリが混在するワークロードで、カラム指向の
Page Cache が受けるキャッシュ追い出しの影響を受けずに利用できます。
## Apache Doris の高同時実行ポイントクエリの仕組み {#how}
-Apache Doris の高同時実行ポイントクエリ経路は、ストレージレイアウト、FE
によるプランの書き換え、ショートサーキットでのディスパッチ、サーバー側での `PreparedStatement` の再利用、オプションの Row Cache
を使う BE の行検索という五つの層を連携させます。
+Apache Doris の高同時実行ポイントクエリ経路は、ストレージレイアウト、FE
によるプランの書き換え、ショートサーキットでのディスパッチ、サーバー側での `PreparedStatement` の再利用、BE
の行検索という五つの層を連携させます。
1. **ストレージレイアウト。** テーブル作成時に `store_row_column=true` を設定すると、BE
は各行をカラム指向のセグメントと、行形式でエンコードした隠しカラムの両方に書き込みます。Apache Doris 3.0
以降では、`row_store_columns="k1,v1,v2"` を使って対象を一部のカラムに限定し、ストレージのオーバーヘッドを抑えられます。
2. **プランの書き換え(FE)。** Nereids のルール `LogicalResultSinkToShortCircuitPointQuery`
は、単一の Unique
テーブル、すべてのキーカラムに対する等価の連言述語、結合やサブクエリなし、集計なしというクエリの形を確認します。すべて一致すると、`isShortCircuitQuery`
フラグを `StatementContext` 内で有効にします。
3. **ショートサーキットでのディスパッチ。** FE
はフラグメントの生成と送信の代わりに、`PartitionPruneV2ForShortCircuitPlan`
でバケットを特定し、そのキーを保持し得る一つのタブレットを選び、所有する BE に一回の RPC を送ります。
4. **サーバー側での `PreparedStatement` の再利用。** `useServerPrepStmts=true` の場合、FE は
`ShortCircuitQueryContext` をセッション UUID ごとにキャッシュします。その後の `EXECUTE`
呼び出しでは解析とプランニングをすべて省略し、パラメーター値だけを変更します。
-5. **BE での行検索。** `point_query_executor`
はキーで行を特定し、行形式のカラムを読み取ってバイト列を返します。オプションの Row Cache にヒットした場合は、セグメントの読み取りも省略します。
+5. **BE での行検索。** `point_query_executor` はキーで行を特定し、行形式のカラムを読み取ってバイト列を返します。
## クイックスタート {#quick-start}
@@ -110,7 +109,7 @@ Apache Doris の高同時実行ポイントクエリは、リクエストごと
## 性能と確認方法 {#performance}
-Apache Doris によると、FE の CPU がボトルネックの場合、ショートサーキット経路に加えてサーバー側の
`PreparedStatement` を有効にすると、スループットが 4 倍以上向上します。これは [Prepared Statement
の紹介ページ](./prepared-statement)で、Prepared Statement の観点から示されているものと同じ 4
倍の効果です。二つの効果を重ね合わせたものではありません。数値は行の幅、Row Cache のヒット率、トラフィックを受け持つ FE Observer
の数によって変わるため、ベンチマーク値ではなく計画上の下限として扱ってください。
+Apache Doris によると、FE の CPU がボトルネックの場合、ショートサーキット経路に加えてサーバー側の
`PreparedStatement` を有効にすると、スループットが 4 倍以上向上します。これは [Prepared Statement
の紹介ページ](./prepared-statement)で、Prepared Statement の観点から示されているものと同じ 4
倍の効果です。二つの効果を重ね合わせたものではありません。数値は行の幅とトラフィックを受け持つ FE Observer
の数によって変わるため、ベンチマーク値ではなく計画上の下限として扱ってください。
次の二点で、この経路が有効であることを確認できます。
diff --git
a/i18n/ja/docusaurus-plugin-content-docs/version-4.x/key-features/prepared-statement.mdx
b/i18n/ja/docusaurus-plugin-content-docs/version-4.x/key-features/prepared-statement.mdx
index 483dd29d089..7d4820c75e8 100644
---
a/i18n/ja/docusaurus-plugin-content-docs/version-4.x/key-features/prepared-statement.mdx
+++
b/i18n/ja/docusaurus-plugin-content-docs/version-4.x/key-features/prepared-statement.mdx
@@ -115,7 +115,7 @@ Apache Doris のプリペアドステートメントは、Unique Key テーブ
## 性能と検証 {#performance}
-Doris は、FE の CPU がボトルネックとなる一点検索のワークロードで、PreparedStatement によって[スループットが 4
倍以上向上する](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/)と報告しています。これは[高並行性の一点検索の機能紹介](./high-concurrency-point-query)でショートサーキットの観点から示される
4 倍と同じ値であり、二つを掛け合わせられるわけではありません。高並行性に向けた構成全体(Unique Key + Merge-on-Write +
行ストア + 行キャッシュ + ショートサーキット + PreparedStatement)では、16 コア / 64GB のマシンで YCSB
を実行し、[ノードあたり 30,000+
QPS](https://doris.apache.org/blog/How-We-Increased-Database-Query-Concurrency-
[...]
+Doris は、FE の CPU がボトルネックとなる一点検索のワークロードで、PreparedStatement によって[スループットが 4
倍以上向上する](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/)と報告しています。これは[高並行性の一点検索の機能紹介](./high-concurrency-point-query)でショートサーキットの観点から示される
4 倍と同じ値であり、二つを掛け合わせられるわけではありません。高並行性に向けた構成全体では、16 コア / 64GB のマシンで YCSB
を実行し、[ノードあたり 30,000+
QPS](https://doris.apache.org/blog/How-We-Increased-Database-Query-Concurrency-by-20-Times/)に達し、最適化前のベースラインと比べて平均レイテンシーが
96% 減少しました。PreparedStatement 単体の寄与を [...]
次の二点を確認すると、この経路が有効かどうかを判断できます。
diff --git
a/i18n/ja/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
b/i18n/ja/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
index 1f63ab46bec..fc85894ebde 100644
---
a/i18n/ja/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
+++
b/i18n/ja/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
@@ -2,7 +2,7 @@
{
"title": "高同時実行ポイントクエリ",
"language": "ja",
- "description": "Doris
で高同時実行ポイントクエリを有効にする方法。行ストア、ショートサーキット経路、PreparedStatement、行キャッシュを使用して、主キーによるポイントクエリの
QPS と応答速度を大幅に改善します。",
+ "description": "Doris
で高同時実行ポイントクエリを有効にする方法。行ストア、ショートサーキット経路、PreparedStatement を使用して、主キーによるポイントクエリの
QPS と応答速度を大幅に改善します。",
"keywords": [
"Doris 高同時実行ポイントクエリ",
"主キーによるポイントクエリの最適化",
@@ -10,7 +10,6 @@
"行ストア store_row_column",
"Merge-On-Write ポイントクエリ",
"SHORT-CIRCUIT ショートサーキット経路",
- "行キャッシュ",
"FE の高 CPU 使用率によるポイントクエリのボトルネック"
]
}
@@ -30,7 +29,6 @@
| 行ストア | 幅の広いテーブルから行全体を読み取る際、列指向ストレージではランダム I/O が増えるため、行ストアによって I/O
のオーバーヘッドを減らします |
| ショートサーキットクエリ経路(SHORT-CIRCUIT) | 単純なクエリに対して FE
のクエリプランニングと解析は負荷が大きいため、通常のプランニング処理を迂回します |
| PreparedStatement | SQL の解析と式の評価は FE の CPU を消費するため、プランと式をキャッシュして負荷を減らします |
-| 行キャッシュ | 大規模なクエリによって Page Cache の内容は退避されやすいため、専用の行キャッシュでヒット率を高めます |
## 有効化のためのクイックチェックリスト
@@ -41,7 +39,6 @@
- テーブル作成時に `light_schema_change = true` を有効にしている
- クエリには **Key 列に対する等価条件のみ**が含まれ、結合やネストしたサブクエリがない
- PreparedStatement を使用するため、JDBC URL で `useServerPrepStmts=true` を有効にしている
-- (任意)行キャッシュを有効にするため、BE の設定で `disable_storage_row_cache = false` を指定している
- `EXPLAIN` を使用し、実行プランに `SHORT-CIRCUIT` マーカーが含まれることを確認している
## 行ストア
@@ -143,20 +140,6 @@ resultSet = readStatement.executeQuery();
...
```
-## 行キャッシュの有効化
-
-<!-- Knowledge type: Configuration parameter -->
-<!-- Applicable scenarios: Low row-store hit rate, Page Cache easily evicted
-->
-
-Doris はデフォルトで**ページ単位のキャッシュ**を提供します。各ページには単一の列のデータが格納されるため、Page Cache
は列指向です。行ストアでは一行に複数の列が含まれ、キャッシュの内容が大規模なクエリによって退避される可能性があります。
-
-ヒット率を高めるため、Doris はメモリ使用量の制御に LRU Cache の仕組みを再利用した、独立した**行キャッシュ**を導入しています。次の BE
設定で有効にします。
-
-| 設定 | デフォルト値 | 説明 |
-| ---------------------------- | ---------- |
--------------------------------- |
-| `disable_storage_row_cache` | `true`(デフォルトでは無効) | 行キャッシュを無効にするかどうか。`false`
に設定すると有効になります |
-| `row_cache_mem_limit` | `20%` | 行キャッシュが使用するメモリの割合 |
-
## 性能チューニングの推奨事項
<!-- Knowledge type: Performance tuning -->
diff --git
a/i18n/ko/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
b/i18n/ko/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
index 2070bc25b67..6c70f37eaee 100644
---
a/i18n/ko/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
+++
b/i18n/ko/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
@@ -56,7 +56,6 @@ Doris가 관리하는 캐시는 현재 모두 LRU 제거 전략을 사용하며,
포인트 쿼리 실행 속도를 높이며, 주로 로그 분석에 사용됩니다.
```
-- PointQueryRowCache
- PointQueryLookupConnectionCache
```
diff --git
a/i18n/ko/docusaurus-plugin-content-docs/current/key-features/columnar-storage.mdx
b/i18n/ko/docusaurus-plugin-content-docs/current/key-features/columnar-storage.mdx
index bf2bd1e856e..91be433723a 100644
---
a/i18n/ko/docusaurus-plugin-content-docs/current/key-features/columnar-storage.mdx
+++
b/i18n/ko/docusaurus-plugin-content-docs/current/key-features/columnar-storage.mdx
@@ -108,7 +108,7 @@ Apache Doris 컬럼형 스토리지는 기본이자 유일한 OLAP 형식이므
**적합하지 않은 경우**
-- 수천 QPS로 실행하는 기본 키 기반 `SELECT *` 조회. 각 컬럼을 별도로 읽으므로 컬럼 수가 많은 행의 단건 쿼리는 N배의
I/O 비용을 치릅니다. [고동시성 포인트 쿼리](./high-concurrency-point-query) 경로를 사용하세요. 이 경로는
Unique-Key Merge-on-Write 테이블에 `"store_row_column" = "true"`를 설정하여 행 캐시 컬럼을
추가합니다.
+- 수천 QPS로 실행하는 기본 키 기반 `SELECT *` 조회. 각 컬럼을 별도로 읽으므로 컬럼 수가 많은 행의 단건 쿼리는 N배의
I/O 비용을 치릅니다. [고동시성 포인트 쿼리](./high-concurrency-point-query) 경로를 사용하세요. 이 경로는
Unique-Key Merge-on-Write 테이블에 `"store_row_column" = "true"`를 설정하여 행 형식 컬럼을
추가합니다.
- 프로파일링 없이 `compression`이나 `storage_page_size`를 조정하는 경우. 기본값(LZ4F, 64 KB)은
대부분의 워크로드에 적합합니다. CPU보다 스토리지 비용이 더 중요할 때만 ZSTD로 전환하고, 작은 컬럼 때문에 불필요한 압축 해제 작업이
발생할 때만 페이지 크기를 줄이세요.
- "원시 컬럼을 보기 위해" 인코딩을 비활성화하는 경우. 원시 모드는 없습니다. 코덱은 벗겨 낼 수 있는 계층이 아니라 파일 형식의
일부입니다.
- 행 지향 스키마에서 적은 컬럼을 읽는 단건 조회의 해결책으로 컬럼형 스토리지를 사용하는 경우. 모든 쿼리가 `WHERE id = ?`이고
행 하나를 반환한다면, 다른 압축 코덱이 아니라 다른 시스템이나 행 스토리지 확장이 필요합니다.
diff --git
a/i18n/ko/docusaurus-plugin-content-docs/current/key-features/high-concurrency-point-query.mdx
b/i18n/ko/docusaurus-plugin-content-docs/current/key-features/high-concurrency-point-query.mdx
index d0723de1d9d..831154f9abf 100644
---
a/i18n/ko/docusaurus-plugin-content-docs/current/key-features/high-concurrency-point-query.mdx
+++
b/i18n/ko/docusaurus-plugin-content-docs/current/key-features/high-concurrency-point-query.mdx
@@ -45,17 +45,16 @@ Apache Doris의 고동시성 포인트 쿼리는 테이블과 쿼리가 모두
- **`store_row_column`**: 각 행을 행 단위로 인코딩한 blob으로 보관하는 숨겨진 컬럼을 추가하는 테이블 속성입니다.
따라서 BE는 전체 행을 반환할 때 N개 컬럼 대신 컬럼 하나를 읽습니다.
- **`SHORT-CIRCUIT`**: `EXPLAIN` 출력에 표시되는 마커로, 플래너가 일반적인 분산 실행 계획을 건너뛰고 단일
tablet, 단일 RPC 경로로 쿼리를 라우팅했음을 나타냅니다.
- **`PreparedStatement`**: MySQL 프로토콜을 통한 서버 측 구문 캐싱입니다. Apache Doris는 파싱된 구문,
출력 표현식, descriptor 테이블을 세션별로 캐시한 뒤 여러 `EXECUTE` 호출에서 재사용합니다.
-- **`Row Cache`**: 전체 행을 보관하는 별도의 LRU 캐시입니다. 분석 쿼리와 포인트 쿼리가 혼재하는 워크로드에서 컬럼 기반
Page Cache가 겪는 축출 압박을 견딥니다.
## Apache Doris 고동시성 포인트 쿼리는 어떻게 동작하나요? {#how}
-Apache Doris의 고동시성 포인트 쿼리 경로는 스토리지 레이아웃, FE 실행 계획 재작성, short-circuit 디스패치, 서버
측 `PreparedStatement` 재사용, 선택적으로 Row Cache를 사용하는 BE 행 조회라는 다섯 계층을 연결합니다.
+Apache Doris의 고동시성 포인트 쿼리 경로는 스토리지 레이아웃, FE 실행 계획 재작성, short-circuit 디스패치, 서버
측 `PreparedStatement` 재사용, BE 행 조회라는 다섯 계층을 연결합니다.
1. **스토리지 레이아웃.** 테이블 생성 시 `store_row_column=true`를 설정하면 BE는 각 행을 컬럼 기반 세그먼트와
행 단위로 인코딩한 숨겨진 컬럼에 모두 기록합니다. Apache Doris 3.0부터는
`row_store_columns="k1,v1,v2"`로 일부 컬럼에만 적용하여 스토리지 오버헤드를 제한할 수 있습니다.
2. **실행 계획 재작성(FE).** Nereids 규칙인 `LogicalResultSinkToShortCircuitPointQuery`는
쿼리의 형태를 검사합니다. 단일 Unique 테이블을 사용하고, 모든 키 컬럼에 동등 조건이 있으며, 조인이나 서브쿼리, 집계가 없어야
합니다. 모든 조건이 일치하면 `isShortCircuitQuery` 플래그를 `StatementContext`에서 활성화합니다.
3. **Short-circuit 디스패치.** FE는 fragment를 생성하여 전송하는 대신,
`PartitionPruneV2ForShortCircuitPlan`을 통해 버킷을 결정하고 해당 키를 포함할 수 있는 tablet 하나를
선택한 뒤, 이를 보유한 BE에 단일 RPC를 전송합니다.
4. **서버 측 `PreparedStatement` 재사용.** `useServerPrepStmts=true`를 사용하면 FE는
`ShortCircuitQueryContext`를 세션 UUID별로 캐시합니다. 이후의 `EXECUTE` 호출은 파싱과 실행 계획 수립을
완전히 건너뛰며, 매개변수 값만 변경됩니다.
-5. **BE 행 조회.** `point_query_executor`는 키로 행을 찾고, 행 형식 컬럼을 읽어 바이트를 반환합니다. 선택
사항인 Row Cache에서 캐시 히트가 발생하면 세그먼트 읽기까지 건너뜁니다.
+5. **BE 행 조회.** `point_query_executor`는 키로 행을 찾고, 행 형식 컬럼을 읽어 바이트를 반환합니다.
## 빠른 시작 {#quick-start}
@@ -109,7 +108,7 @@ Apache Doris의 고동시성 포인트 쿼리는 요청마다 기본 키로 행
## 성능 및 검증 {#performance}
-Apache Doris에 따르면 FE CPU가 병목일 때 short-circuit 경로에 서버 측 `PreparedStatement`를
추가로 활성화하면 처리량이 4배 이상 향상됩니다. 이는 [Prepared Statement 카드](./prepared-statement)에서
prepared statement 관점으로 언급한 4배와 같은 효과이며, 서로 중첩할 수 있는 두 가지 효과가 아니라 하나의 통합된
효과입니다. 수치는 행의 폭, Row Cache 적중률, 트래픽을 처리하는 FE Observers 수에 따라 달라지므로, 벤치마크 수치가
아니라 계획을 세울 때의 하한 기준으로 보세요.
+Apache Doris에 따르면 FE CPU가 병목일 때 short-circuit 경로에 서버 측 `PreparedStatement`를
추가로 활성화하면 처리량이 4배 이상 향상됩니다. 이는 [Prepared Statement 카드](./prepared-statement)에서
prepared statement 관점으로 언급한 4배와 같은 효과이며, 서로 중첩할 수 있는 두 가지 효과가 아니라 하나의 통합된
효과입니다. 수치는 행의 폭과 트래픽을 처리하는 FE Observers 수에 따라 달라지므로, 벤치마크 수치가 아니라 계획을 세울 때의 하한
기준으로 보세요.
다음 두 가지를 확인하면 이 경로가 활성화되어 있는지 알 수 있습니다.
diff --git
a/i18n/ko/docusaurus-plugin-content-docs/current/key-features/prepared-statement.mdx
b/i18n/ko/docusaurus-plugin-content-docs/current/key-features/prepared-statement.mdx
index fc200c7de1c..bc9da8cec53 100644
---
a/i18n/ko/docusaurus-plugin-content-docs/current/key-features/prepared-statement.mdx
+++
b/i18n/ko/docusaurus-plugin-content-docs/current/key-features/prepared-statement.mdx
@@ -114,7 +114,7 @@ Apache Doris의 Prepared Statement는 Unique Key 테이블에 대한 높은 QPS
## 성능 및 검증 {#performance}
-Doris에 따르면 FE CPU가 병목인 포인트 쿼리 워크로드에서 PreparedStatement를 사용하면 [처리량이 4x 이상
개선됩니다](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/).
이는 [고동시성 포인트 쿼리 기능 카드](./high-concurrency-point-query)에서 short-circuit 관점으로
설명한 4x와 동일한 수치입니다. 두 효과를 합친 개선 폭이므로 각각을 곱해서 계산하면 안 됩니다. 전체 고동시성 구성(Unique Key +
Merge-on-Write + 행 저장소 + 행 캐시 + short-circuit + PreparedStatement)은 16코어 / 64GB
머신의 YCSB에서 [노드당 30,000+
QPS](https://doris.apache.org/blog/How-We-Increased-Database-Query-C [...]
+Doris에 따르면 FE CPU가 병목인 포인트 쿼리 워크로드에서 PreparedStatement를 사용하면 [처리량이 4x 이상
개선됩니다](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/).
이는 [고동시성 포인트 쿼리 기능 카드](./high-concurrency-point-query)에서 short-circuit 관점으로
설명한 4x와 동일한 수치입니다. 두 효과를 합친 개선 폭이므로 각각을 곱해서 계산하면 안 됩니다. 전체 고동시성 구성은 16코어 / 64GB
머신의 YCSB에서 [노드당 30,000+
QPS](https://doris.apache.org/blog/How-We-Increased-Database-Query-Concurrency-by-20-Times/)에
도달하며, 최적화하지 않은 기준 구성보다 평균 지연 시간이 96% 줄어듭니다. 나머지 구성과 분리 [...]
다음 두 가지를 확인하면 해당 경로가 사용 중인지 알 수 있습니다.
diff --git
a/i18n/ko/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
b/i18n/ko/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
index 89ff617f7c0..1f4f1f6b4d8 100644
---
a/i18n/ko/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
+++
b/i18n/ko/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
@@ -2,7 +2,7 @@
{
"title": "고동시성 포인트 쿼리",
"language": "ko",
- "description": "Doris에서 고동시성 포인트 쿼리를 활성화하는 방법은 무엇일까요? 행 저장소, short-circuit
경로, PreparedStatement, 행 캐시를 통해 기본 키 포인트 쿼리의 QPS와 응답 지연 시간을 크게 개선할 수 있습니다.",
+ "description": "Doris에서 고동시성 포인트 쿼리를 활성화하는 방법은 무엇일까요? 행 저장소, short-circuit
경로, PreparedStatement를 통해 기본 키 포인트 쿼리의 QPS와 응답 지연 시간을 크게 개선할 수 있습니다.",
"keywords": [
"Doris 고동시성 포인트 쿼리",
"기본 키 포인트 쿼리 최적화",
@@ -10,7 +10,6 @@
"행 저장소 store_row_column",
"Merge-On-Write 포인트 쿼리",
"SHORT-CIRCUIT 단축 경로",
- "행 캐시",
"FE CPU 사용량 과다로 인한 포인트 쿼리 병목"
]
}
@@ -30,7 +29,6 @@
| 행 저장소 | 열이 많은 테이블에서 행 전체를 읽으면 열 지향 스토리지의 랜덤 IO가 증가합니다. 행 저장소는 IO 오버헤드를 줄입니다 |
| Short-Circuit 쿼리 경로(SHORT-CIRCUIT) | 단순한 쿼리에서는 FE의 쿼리 계획 및 파싱 작업이 지나치게
무겁습니다. short-circuit 경로는 일반적인 계획 수립 과정을 우회합니다 |
| PreparedStatement | SQL 파싱과 표현식 평가가 FE CPU를 소모합니다. 계획과 표현식을 캐시하면 오버헤드가 줄어듭니다
|
-| 행 캐시 | Page Cache는 대규모 쿼리로 인해 쉽게 축출됩니다. 전용 행 캐시는 적중률을 높입니다 |
## 빠른 활성화를 위한 체크리스트 {#quick-enablement-checklist}
@@ -41,7 +39,6 @@
- 테이블 생성 시 `light_schema_change = true`를 활성화해야 합니다
- 쿼리에는 **Key 열에 대한 동등 조건만** 포함되어야 하며, 조인이나 중첩 서브쿼리가 없어야 합니다
- JDBC URL에서 `useServerPrepStmts=true`를 활성화해 PreparedStatement를 사용해야 합니다
-- (선택 사항) BE 설정 `disable_storage_row_cache = false`를 지정해 행 캐시를 활성화합니다
- `EXPLAIN`을 사용해 실행 계획에 `SHORT-CIRCUIT` 표시가 포함되어 있는지 확인합니다
## 행 저장소 {#row-store}
@@ -143,20 +140,6 @@ resultSet = readStatement.executeQuery();
...
```
-## 행 캐시 활성화 {#enabling-row-cache}
-
-<!-- Knowledge type: Configuration parameter -->
-<!-- Applicable scenarios: Low row-store hit rate, Page Cache easily evicted
-->
-
-Doris는 기본적으로 **페이지 단위 캐시**를 제공합니다. 각 페이지는 단일 열의 데이터를 저장하므로 Page Cache는 열
지향적입니다. 행 저장소에서는 한 행에 여러 열이 포함되며, 대규모 쿼리로 인해 캐시가 비워질 수 있습니다.
-
-적중률을 높이기 위해 Doris는 LRU Cache 메커니즘을 재사용하여 메모리 사용량을 제어하는 별도의 **행 캐시**를 제공합니다. 다음
BE 설정으로 활성화할 수 있습니다.
-
-| 설정 | 기본값 | 설명 |
-| ---------------------------- | ---------- |
--------------------------------- |
-| `disable_storage_row_cache` | `true` (기본적으로 비활성화) | 행 캐시를 비활성화할지 여부입니다.
활성화하려면 `false`로 설정합니다 |
-| `row_cache_mem_limit` | `20%` | 행 캐시가 사용하는 메모리의 비율 |
-
## 성능 튜닝 권장 사항 {#performance-tuning-recommendations}
<!-- Knowledge type: Performance tuning -->
diff --git
a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
index 2070bc25b67..6c70f37eaee 100644
---
a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
+++
b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
@@ -56,7 +56,6 @@ Doris가 관리하는 캐시는 현재 모두 LRU 제거 전략을 사용하며,
포인트 쿼리 실행 속도를 높이며, 주로 로그 분석에 사용됩니다.
```
-- PointQueryRowCache
- PointQueryLookupConnectionCache
```
diff --git
a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/key-features/columnar-storage.mdx
b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/key-features/columnar-storage.mdx
index bf2bd1e856e..91be433723a 100644
---
a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/key-features/columnar-storage.mdx
+++
b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/key-features/columnar-storage.mdx
@@ -108,7 +108,7 @@ Apache Doris 컬럼형 스토리지는 기본이자 유일한 OLAP 형식이므
**적합하지 않은 경우**
-- 수천 QPS로 실행하는 기본 키 기반 `SELECT *` 조회. 각 컬럼을 별도로 읽으므로 컬럼 수가 많은 행의 단건 쿼리는 N배의
I/O 비용을 치릅니다. [고동시성 포인트 쿼리](./high-concurrency-point-query) 경로를 사용하세요. 이 경로는
Unique-Key Merge-on-Write 테이블에 `"store_row_column" = "true"`를 설정하여 행 캐시 컬럼을
추가합니다.
+- 수천 QPS로 실행하는 기본 키 기반 `SELECT *` 조회. 각 컬럼을 별도로 읽으므로 컬럼 수가 많은 행의 단건 쿼리는 N배의
I/O 비용을 치릅니다. [고동시성 포인트 쿼리](./high-concurrency-point-query) 경로를 사용하세요. 이 경로는
Unique-Key Merge-on-Write 테이블에 `"store_row_column" = "true"`를 설정하여 행 형식 컬럼을
추가합니다.
- 프로파일링 없이 `compression`이나 `storage_page_size`를 조정하는 경우. 기본값(LZ4F, 64 KB)은
대부분의 워크로드에 적합합니다. CPU보다 스토리지 비용이 더 중요할 때만 ZSTD로 전환하고, 작은 컬럼 때문에 불필요한 압축 해제 작업이
발생할 때만 페이지 크기를 줄이세요.
- "원시 컬럼을 보기 위해" 인코딩을 비활성화하는 경우. 원시 모드는 없습니다. 코덱은 벗겨 낼 수 있는 계층이 아니라 파일 형식의
일부입니다.
- 행 지향 스키마에서 적은 컬럼을 읽는 단건 조회의 해결책으로 컬럼형 스토리지를 사용하는 경우. 모든 쿼리가 `WHERE id = ?`이고
행 하나를 반환한다면, 다른 압축 코덱이 아니라 다른 시스템이나 행 스토리지 확장이 필요합니다.
diff --git
a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/key-features/high-concurrency-point-query.mdx
b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/key-features/high-concurrency-point-query.mdx
index d0723de1d9d..831154f9abf 100644
---
a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/key-features/high-concurrency-point-query.mdx
+++
b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/key-features/high-concurrency-point-query.mdx
@@ -45,17 +45,16 @@ Apache Doris의 고동시성 포인트 쿼리는 테이블과 쿼리가 모두
- **`store_row_column`**: 각 행을 행 단위로 인코딩한 blob으로 보관하는 숨겨진 컬럼을 추가하는 테이블 속성입니다.
따라서 BE는 전체 행을 반환할 때 N개 컬럼 대신 컬럼 하나를 읽습니다.
- **`SHORT-CIRCUIT`**: `EXPLAIN` 출력에 표시되는 마커로, 플래너가 일반적인 분산 실행 계획을 건너뛰고 단일
tablet, 단일 RPC 경로로 쿼리를 라우팅했음을 나타냅니다.
- **`PreparedStatement`**: MySQL 프로토콜을 통한 서버 측 구문 캐싱입니다. Apache Doris는 파싱된 구문,
출력 표현식, descriptor 테이블을 세션별로 캐시한 뒤 여러 `EXECUTE` 호출에서 재사용합니다.
-- **`Row Cache`**: 전체 행을 보관하는 별도의 LRU 캐시입니다. 분석 쿼리와 포인트 쿼리가 혼재하는 워크로드에서 컬럼 기반
Page Cache가 겪는 축출 압박을 견딥니다.
## Apache Doris 고동시성 포인트 쿼리는 어떻게 동작하나요? {#how}
-Apache Doris의 고동시성 포인트 쿼리 경로는 스토리지 레이아웃, FE 실행 계획 재작성, short-circuit 디스패치, 서버
측 `PreparedStatement` 재사용, 선택적으로 Row Cache를 사용하는 BE 행 조회라는 다섯 계층을 연결합니다.
+Apache Doris의 고동시성 포인트 쿼리 경로는 스토리지 레이아웃, FE 실행 계획 재작성, short-circuit 디스패치, 서버
측 `PreparedStatement` 재사용, BE 행 조회라는 다섯 계층을 연결합니다.
1. **스토리지 레이아웃.** 테이블 생성 시 `store_row_column=true`를 설정하면 BE는 각 행을 컬럼 기반 세그먼트와
행 단위로 인코딩한 숨겨진 컬럼에 모두 기록합니다. Apache Doris 3.0부터는
`row_store_columns="k1,v1,v2"`로 일부 컬럼에만 적용하여 스토리지 오버헤드를 제한할 수 있습니다.
2. **실행 계획 재작성(FE).** Nereids 규칙인 `LogicalResultSinkToShortCircuitPointQuery`는
쿼리의 형태를 검사합니다. 단일 Unique 테이블을 사용하고, 모든 키 컬럼에 동등 조건이 있으며, 조인이나 서브쿼리, 집계가 없어야
합니다. 모든 조건이 일치하면 `isShortCircuitQuery` 플래그를 `StatementContext`에서 활성화합니다.
3. **Short-circuit 디스패치.** FE는 fragment를 생성하여 전송하는 대신,
`PartitionPruneV2ForShortCircuitPlan`을 통해 버킷을 결정하고 해당 키를 포함할 수 있는 tablet 하나를
선택한 뒤, 이를 보유한 BE에 단일 RPC를 전송합니다.
4. **서버 측 `PreparedStatement` 재사용.** `useServerPrepStmts=true`를 사용하면 FE는
`ShortCircuitQueryContext`를 세션 UUID별로 캐시합니다. 이후의 `EXECUTE` 호출은 파싱과 실행 계획 수립을
완전히 건너뛰며, 매개변수 값만 변경됩니다.
-5. **BE 행 조회.** `point_query_executor`는 키로 행을 찾고, 행 형식 컬럼을 읽어 바이트를 반환합니다. 선택
사항인 Row Cache에서 캐시 히트가 발생하면 세그먼트 읽기까지 건너뜁니다.
+5. **BE 행 조회.** `point_query_executor`는 키로 행을 찾고, 행 형식 컬럼을 읽어 바이트를 반환합니다.
## 빠른 시작 {#quick-start}
@@ -109,7 +108,7 @@ Apache Doris의 고동시성 포인트 쿼리는 요청마다 기본 키로 행
## 성능 및 검증 {#performance}
-Apache Doris에 따르면 FE CPU가 병목일 때 short-circuit 경로에 서버 측 `PreparedStatement`를
추가로 활성화하면 처리량이 4배 이상 향상됩니다. 이는 [Prepared Statement 카드](./prepared-statement)에서
prepared statement 관점으로 언급한 4배와 같은 효과이며, 서로 중첩할 수 있는 두 가지 효과가 아니라 하나의 통합된
효과입니다. 수치는 행의 폭, Row Cache 적중률, 트래픽을 처리하는 FE Observers 수에 따라 달라지므로, 벤치마크 수치가
아니라 계획을 세울 때의 하한 기준으로 보세요.
+Apache Doris에 따르면 FE CPU가 병목일 때 short-circuit 경로에 서버 측 `PreparedStatement`를
추가로 활성화하면 처리량이 4배 이상 향상됩니다. 이는 [Prepared Statement 카드](./prepared-statement)에서
prepared statement 관점으로 언급한 4배와 같은 효과이며, 서로 중첩할 수 있는 두 가지 효과가 아니라 하나의 통합된
효과입니다. 수치는 행의 폭과 트래픽을 처리하는 FE Observers 수에 따라 달라지므로, 벤치마크 수치가 아니라 계획을 세울 때의 하한
기준으로 보세요.
다음 두 가지를 확인하면 이 경로가 활성화되어 있는지 알 수 있습니다.
diff --git
a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/key-features/prepared-statement.mdx
b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/key-features/prepared-statement.mdx
index fc200c7de1c..bc9da8cec53 100644
---
a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/key-features/prepared-statement.mdx
+++
b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/key-features/prepared-statement.mdx
@@ -114,7 +114,7 @@ Apache Doris의 Prepared Statement는 Unique Key 테이블에 대한 높은 QPS
## 성능 및 검증 {#performance}
-Doris에 따르면 FE CPU가 병목인 포인트 쿼리 워크로드에서 PreparedStatement를 사용하면 [처리량이 4x 이상
개선됩니다](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/).
이는 [고동시성 포인트 쿼리 기능 카드](./high-concurrency-point-query)에서 short-circuit 관점으로
설명한 4x와 동일한 수치입니다. 두 효과를 합친 개선 폭이므로 각각을 곱해서 계산하면 안 됩니다. 전체 고동시성 구성(Unique Key +
Merge-on-Write + 행 저장소 + 행 캐시 + short-circuit + PreparedStatement)은 16코어 / 64GB
머신의 YCSB에서 [노드당 30,000+
QPS](https://doris.apache.org/blog/How-We-Increased-Database-Query-C [...]
+Doris에 따르면 FE CPU가 병목인 포인트 쿼리 워크로드에서 PreparedStatement를 사용하면 [처리량이 4x 이상
개선됩니다](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/).
이는 [고동시성 포인트 쿼리 기능 카드](./high-concurrency-point-query)에서 short-circuit 관점으로
설명한 4x와 동일한 수치입니다. 두 효과를 합친 개선 폭이므로 각각을 곱해서 계산하면 안 됩니다. 전체 고동시성 구성은 16코어 / 64GB
머신의 YCSB에서 [노드당 30,000+
QPS](https://doris.apache.org/blog/How-We-Increased-Database-Query-Concurrency-by-20-Times/)에
도달하며, 최적화하지 않은 기준 구성보다 평균 지연 시간이 96% 줄어듭니다. 나머지 구성과 분리 [...]
다음 두 가지를 확인하면 해당 경로가 사용 중인지 알 수 있습니다.
diff --git
a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
index 89ff617f7c0..1f4f1f6b4d8 100644
---
a/i18n/ko/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
+++
b/i18n/ko/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
@@ -2,7 +2,7 @@
{
"title": "고동시성 포인트 쿼리",
"language": "ko",
- "description": "Doris에서 고동시성 포인트 쿼리를 활성화하는 방법은 무엇일까요? 행 저장소, short-circuit
경로, PreparedStatement, 행 캐시를 통해 기본 키 포인트 쿼리의 QPS와 응답 지연 시간을 크게 개선할 수 있습니다.",
+ "description": "Doris에서 고동시성 포인트 쿼리를 활성화하는 방법은 무엇일까요? 행 저장소, short-circuit
경로, PreparedStatement를 통해 기본 키 포인트 쿼리의 QPS와 응답 지연 시간을 크게 개선할 수 있습니다.",
"keywords": [
"Doris 고동시성 포인트 쿼리",
"기본 키 포인트 쿼리 최적화",
@@ -10,7 +10,6 @@
"행 저장소 store_row_column",
"Merge-On-Write 포인트 쿼리",
"SHORT-CIRCUIT 단축 경로",
- "행 캐시",
"FE CPU 사용량 과다로 인한 포인트 쿼리 병목"
]
}
@@ -30,7 +29,6 @@
| 행 저장소 | 열이 많은 테이블에서 행 전체를 읽으면 열 지향 스토리지의 랜덤 IO가 증가합니다. 행 저장소는 IO 오버헤드를 줄입니다 |
| Short-Circuit 쿼리 경로(SHORT-CIRCUIT) | 단순한 쿼리에서는 FE의 쿼리 계획 및 파싱 작업이 지나치게
무겁습니다. short-circuit 경로는 일반적인 계획 수립 과정을 우회합니다 |
| PreparedStatement | SQL 파싱과 표현식 평가가 FE CPU를 소모합니다. 계획과 표현식을 캐시하면 오버헤드가 줄어듭니다
|
-| 행 캐시 | Page Cache는 대규모 쿼리로 인해 쉽게 축출됩니다. 전용 행 캐시는 적중률을 높입니다 |
## 빠른 활성화를 위한 체크리스트 {#quick-enablement-checklist}
@@ -41,7 +39,6 @@
- 테이블 생성 시 `light_schema_change = true`를 활성화해야 합니다
- 쿼리에는 **Key 열에 대한 동등 조건만** 포함되어야 하며, 조인이나 중첩 서브쿼리가 없어야 합니다
- JDBC URL에서 `useServerPrepStmts=true`를 활성화해 PreparedStatement를 사용해야 합니다
-- (선택 사항) BE 설정 `disable_storage_row_cache = false`를 지정해 행 캐시를 활성화합니다
- `EXPLAIN`을 사용해 실행 계획에 `SHORT-CIRCUIT` 표시가 포함되어 있는지 확인합니다
## 행 저장소 {#row-store}
@@ -143,20 +140,6 @@ resultSet = readStatement.executeQuery();
...
```
-## 행 캐시 활성화 {#enabling-row-cache}
-
-<!-- Knowledge type: Configuration parameter -->
-<!-- Applicable scenarios: Low row-store hit rate, Page Cache easily evicted
-->
-
-Doris는 기본적으로 **페이지 단위 캐시**를 제공합니다. 각 페이지는 단일 열의 데이터를 저장하므로 Page Cache는 열
지향적입니다. 행 저장소에서는 한 행에 여러 열이 포함되며, 대규모 쿼리로 인해 캐시가 비워질 수 있습니다.
-
-적중률을 높이기 위해 Doris는 LRU Cache 메커니즘을 재사용하여 메모리 사용량을 제어하는 별도의 **행 캐시**를 제공합니다. 다음
BE 설정으로 활성화할 수 있습니다.
-
-| 설정 | 기본값 | 설명 |
-| ---------------------------- | ---------- |
--------------------------------- |
-| `disable_storage_row_cache` | `true` (기본적으로 비활성화) | 행 캐시를 비활성화할지 여부입니다.
활성화하려면 `false`로 설정합니다 |
-| `row_cache_mem_limit` | `20%` | 행 캐시가 사용하는 메모리의 비율 |
-
## 성능 튜닝 권장 사항 {#performance-tuning-recommendations}
<!-- Knowledge type: Performance tuning -->
diff --git
a/i18n/ru/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
b/i18n/ru/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
index c3f464d0204..c0724b4527f 100644
---
a/i18n/ru/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
+++
b/i18n/ru/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
@@ -56,7 +56,6 @@
Ускоряет выполнение точечных запросов и используется главным образом для
анализа журналов.
```
-- PointQueryRowCache
- PointQueryLookupConnectionCache
```
diff --git
a/i18n/ru/docusaurus-plugin-content-docs/current/key-features/columnar-storage.mdx
b/i18n/ru/docusaurus-plugin-content-docs/current/key-features/columnar-storage.mdx
index 88c5021e56e..f5d4e65bec2 100644
---
a/i18n/ru/docusaurus-plugin-content-docs/current/key-features/columnar-storage.mdx
+++
b/i18n/ru/docusaurus-plugin-content-docs/current/key-features/columnar-storage.mdx
@@ -108,7 +108,7 @@ ORDER BY hits DESC;
**Неподходящие сценарии**
-- Поиск по первичному ключу с `SELECT *` при тысячах QPS. Каждый столбец
читается отдельно, поэтому точечный запрос к широкой строке требует в N раз
больше операций ввода-вывода. Используйте механизм [высокопараллельных точечных
запросов](./high-concurrency-point-query), который добавляет столбец с
кэшированными строками с помощью `"store_row_column" = "true"` в таблицу
Unique-Key Merge-on-Write.
+- Поиск по первичному ключу с `SELECT *` при тысячах QPS. Каждый столбец
читается отдельно, поэтому точечный запрос к широкой строке требует в N раз
больше операций ввода-вывода. Используйте механизм [высокопараллельных точечных
запросов](./high-concurrency-point-query), который добавляет столбец с
построчным форматом с помощью `"store_row_column" = "true"` в таблицу
Unique-Key Merge-on-Write.
- Настройка `compression` или `storage_page_size` без профилирования. Значения
по умолчанию (LZ4F, 64 KB) подходят для большинства нагрузок. Переходите на
ZSTD, только если стоимость хранения важнее затрат CPU; уменьшайте размер
страницы, только если при распаковке небольших столбцов выполняется лишняя
работа.
- Отключение кодирования, чтобы «увидеть столбец в исходном виде». Режима без
кодирования нет. Кодек является частью формата файла, а не слоем, который можно
убрать.
- Попытка ускорить точечные запросы с выборкой небольшого числа столбцов в
строчной схеме за счёт колоночного хранения. Если каждый запрос имеет вид
`WHERE id = ?` и возвращает одну строку, вам нужна другая система или
расширение для строчного хранения, а не другой кодек сжатия.
diff --git
a/i18n/ru/docusaurus-plugin-content-docs/current/key-features/high-concurrency-point-query.mdx
b/i18n/ru/docusaurus-plugin-content-docs/current/key-features/high-concurrency-point-query.mdx
index d563eca342f..63ad5add9dd 100644
---
a/i18n/ru/docusaurus-plugin-content-docs/current/key-features/high-concurrency-point-query.mdx
+++
b/i18n/ru/docusaurus-plugin-content-docs/current/key-features/high-concurrency-point-query.mdx
@@ -45,17 +45,16 @@ featureCard:
- **`store_row_column`**: свойство таблицы, которое добавляет скрытый столбец,
хранящий каждую строку в виде blob со строчным кодированием. Благодаря этому BE
читает один столбец вместо N, чтобы вернуть целую строку.
- **`SHORT-CIRCUIT`**: метка в выводе `EXPLAIN`, которая появляется, когда
планировщик обходит обычный распределённый план и направляет запрос по пути с
одним tablet и одним RPC.
- **`PreparedStatement`**: серверное кеширование подготовленных запросов по
протоколу MySQL. Apache Doris кеширует разобранный запрос, выражения результата
и таблицу дескрипторов для каждой сессии, а затем повторно использует их при
вызовах `EXECUTE`.
-- **`Row Cache`**: отдельный кеш LRU, в котором хранятся целые строки. Он
выдерживает давление вытеснения, которому подвергается колоночный Page Cache
при смешанной нагрузке из аналитических и точечных запросов.
## Как работают точечные запросы при высокой конкурентной нагрузке в Apache
Doris? {#how}
-Путь выполнения точечных запросов при высокой конкурентной нагрузке в Apache
Doris объединяет пять уровней: организацию хранения, преобразование плана на
FE, отправку по сокращённому пути, повторное использование серверного
`PreparedStatement` и поиск строки на BE с необязательным Row Cache.
+Путь выполнения точечных запросов при высокой конкурентной нагрузке в Apache
Doris объединяет пять уровней: организацию хранения, преобразование плана на
FE, отправку по сокращённому пути, повторное использование серверного
`PreparedStatement` и поиск строки на BE.
1. **Организация хранения.** Если при создании таблицы задать
`store_row_column=true`, BE записывает каждую строку и в колоночные сегменты, и
в скрытый столбец со строчным кодированием. Начиная с Apache Doris 3.0 можно
ограничить строчное хранение подмножеством столбцов с помощью
`row_store_columns="k1,v1,v2"`, чтобы сократить накладные расходы на хранение.
2. **Преобразование плана (FE).** Правило Nereids
`LogicalResultSinkToShortCircuitPointQuery` проверяет структуру запроса: одна
таблица Unique, конъюнктивные условия равенства для каждого ключевого столбца,
отсутствие соединений, подзапросов и агрегаций. Если все условия выполнены,
правило устанавливает флаг `isShortCircuitQuery` в `StatementContext`.
3. **Отправка по сокращённому пути.** Вместо создания и отправки фрагментов FE
определяет бакет с помощью `PartitionPruneV2ForShortCircuitPlan`, выбирает
единственный tablet, в котором может находиться ключ, и отправляет один RPC на
BE, которому принадлежит этот tablet.
4. **Повторное использование серверного `PreparedStatement`.** При
`useServerPrepStmts=true` FE кеширует `ShortCircuitQueryContext` по UUID
сессии. Последующие вызовы `EXECUTE` полностью пропускают разбор и
планирование; меняются только значения параметров.
-5. **Поиск строки на BE.** Компонент `point_query_executor` находит строку по
ключу, читает столбец со строчным форматом и возвращает байты. Дополнительный
Row Cache при попадании в кеш позволяет пропустить даже чтение сегмента.
+5. **Поиск строки на BE.** Компонент `point_query_executor` находит строку по
ключу, читает столбец со строчным форматом и возвращает байты.
## Быстрый старт {#quick-start}
@@ -109,7 +108,7 @@ EXPLAIN SELECT * FROM tbl_point_query WHERE k1 = 42;
## Производительность и проверка {#performance}
-По данным Apache Doris, включение серверного `PreparedStatement` в дополнение
к сокращённому пути выполнения повышает пропускную способность более чем в 4
раза, когда узким местом является CPU FE. Это тот же рост в 4 раза, который
рассматривается со стороны подготовленных запросов в [карточке «Подготовленные
запросы»](./prepared-statement): единый совокупный эффект, а не два независимых
прироста, которые можно совместить. Результаты зависят от ширины строки, доли
попаданий в кеш строк и [...]
+По данным Apache Doris, включение серверного `PreparedStatement` в дополнение
к сокращённому пути выполнения повышает пропускную способность более чем в 4
раза, когда узким местом является CPU FE. Это тот же рост в 4 раза, который
рассматривается со стороны подготовленных запросов в [карточке «Подготовленные
запросы»](./prepared-statement): единый совокупный эффект, а не два независимых
прироста, которые можно совместить. Результаты зависят от ширины строки и числа
FE Observers, принимаю [...]
Две проверки позволяют убедиться, что этот путь используется:
diff --git
a/i18n/ru/docusaurus-plugin-content-docs/current/key-features/prepared-statement.mdx
b/i18n/ru/docusaurus-plugin-content-docs/current/key-features/prepared-statement.mdx
index 2758e12290e..fd80bb523c7 100644
---
a/i18n/ru/docusaurus-plugin-content-docs/current/key-features/prepared-statement.mdx
+++
b/i18n/ru/docusaurus-plugin-content-docs/current/key-features/prepared-statement.mdx
@@ -114,7 +114,7 @@ Stmt=EXECUTE(-2147481418)
## Производительность и проверка {#performance}
-Doris сообщает об [увеличении пропускной способности в 4 раза и
более](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/)
благодаря PreparedStatement в нагрузках с точечными запросами, где узким
местом является CPU FE. Это тот же прирост в 4 раза, который описан с точки
зрения short-circuit в [карточке функции «Точечные запросы с высокой
конкурентностью»](./high-concurrency-point-query): единый совокупный эффект, а
не два независимых ускорения, которые мож [...]
+Doris сообщает об [увеличении пропускной способности в 4 раза и
более](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/)
благодаря PreparedStatement в нагрузках с точечными запросами, где узким
местом является CPU FE. Это тот же прирост в 4 раза, который описан с точки
зрения short-circuit в [карточке функции «Точечные запросы с высокой
конкурентностью»](./high-concurrency-point-query): единый совокупный эффект, а
не два независимых ускорения, которые мож [...]
Две проверки позволяют убедиться, что этот путь выполнения используется:
diff --git
a/i18n/ru/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
b/i18n/ru/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
index d6233529c3f..ada3b8f1aa0 100644
---
a/i18n/ru/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
+++
b/i18n/ru/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
@@ -2,7 +2,7 @@
{
"title": "Точечные запросы при высокой конкурентной нагрузке",
"language": "ru",
- "description": "Как включить точечные запросы при высокой конкурентной
нагрузке в Doris? Значительно повысьте QPS точечных запросов по первичному
ключу и сократите время отклика с помощью построчного хранения, сокращённого
пути выполнения, PreparedStatement и кеша строк.",
+ "description": "Как включить точечные запросы при высокой конкурентной
нагрузке в Doris? Значительно повысьте QPS точечных запросов по первичному
ключу и сократите время отклика с помощью построчного хранения, сокращённого
пути выполнения и PreparedStatement.",
"keywords": [
"точечные запросы в Doris при высокой конкурентной нагрузке",
"оптимизация точечных запросов по первичному ключу",
@@ -10,7 +10,6 @@
"построчное хранение store_row_column",
"точечные запросы Merge-On-Write",
"сокращённый путь SHORT-CIRCUIT",
- "кеш строк",
"высокая загрузка CPU на FE как узкое место точечных запросов"
]
}
@@ -30,7 +29,6 @@
| Построчное хранение (Row Store) | При чтении целых строк широких таблиц
колоночное хранение увеличивает объём случайного ввода-вывода; построчное
хранение снижает эти затраты |
| Сокращённый путь выполнения запросов Short-Circuit (SHORT-CIRCUIT) |
Планирование и разбор простых запросов на FE требуют слишком много ресурсов;
сокращённый путь позволяет обойти обычный процесс планирования |
| PreparedStatement | Разбор SQL и вычисление выражений потребляют ресурсы CPU
на FE; кеширование плана и выражений снижает эти затраты |
-| Кеш строк (Row Cache) | Крупные запросы легко вытесняют данные из Page
Cache; отдельный кеш строк повышает долю попаданий |
## Контрольный список для быстрого включения {#quick-enablement-checklist}
@@ -41,7 +39,6 @@
- При создании таблицы включён параметр `light_schema_change = true`
- Запрос содержит только **условия равенства по столбцам Key**, без соединений
и вложенных подзапросов
- В JDBC URL включён параметр `useServerPrepStmts=true` для использования
PreparedStatement
-- (Необязательно) На BE задан параметр `disable_storage_row_cache = false` для
включения кеша строк
- С помощью `EXPLAIN` убедитесь, что план выполнения содержит маркер
`SHORT-CIRCUIT`
## Построчное хранение (Row Store) {#row-store}
@@ -143,20 +140,6 @@ resultSet = readStatement.executeQuery();
...
```
-## Включение кеша строк (Row Cache) {#enabling-row-cache}
-
-<!-- Knowledge type: Configuration parameter -->
-<!-- Applicable scenarios: Low row-store hit rate, Page Cache easily evicted
-->
-
-По умолчанию Doris предоставляет **кеш на уровне страниц**, в котором каждая
страница хранит данные одного столбца, поэтому Page Cache ориентирован на
столбцы. При построчном хранении строка содержит несколько столбцов, и крупные
запросы могут вытеснять данные из кеша.
-
-Чтобы повысить долю попаданий, Doris предоставляет отдельный **кеш строк (Row
Cache)**, использующий механизм LRU Cache для управления потреблением памяти.
Включите его с помощью следующих параметров BE:
-
-| Параметр | Значение по умолчанию | Описание |
-| ---------------------------- | ---------- |
--------------------------------- |
-| `disable_storage_row_cache` | `true` (по умолчанию отключён) | Отключать ли
кеш строк. Для включения задайте `false` |
-| `row_cache_mem_limit` | `20%` | Доля памяти, используемая Row Cache |
-
## Рекомендации по настройке производительности
{#performance-tuning-recommendations}
<!-- Knowledge type: Performance tuning -->
diff --git
a/i18n/ru/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
b/i18n/ru/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
index c3f464d0204..c0724b4527f 100644
---
a/i18n/ru/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
+++
b/i18n/ru/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
@@ -56,7 +56,6 @@
Ускоряет выполнение точечных запросов и используется главным образом для
анализа журналов.
```
-- PointQueryRowCache
- PointQueryLookupConnectionCache
```
diff --git
a/i18n/ru/docusaurus-plugin-content-docs/version-4.x/key-features/columnar-storage.mdx
b/i18n/ru/docusaurus-plugin-content-docs/version-4.x/key-features/columnar-storage.mdx
index 88c5021e56e..f5d4e65bec2 100644
---
a/i18n/ru/docusaurus-plugin-content-docs/version-4.x/key-features/columnar-storage.mdx
+++
b/i18n/ru/docusaurus-plugin-content-docs/version-4.x/key-features/columnar-storage.mdx
@@ -108,7 +108,7 @@ ORDER BY hits DESC;
**Неподходящие сценарии**
-- Поиск по первичному ключу с `SELECT *` при тысячах QPS. Каждый столбец
читается отдельно, поэтому точечный запрос к широкой строке требует в N раз
больше операций ввода-вывода. Используйте механизм [высокопараллельных точечных
запросов](./high-concurrency-point-query), который добавляет столбец с
кэшированными строками с помощью `"store_row_column" = "true"` в таблицу
Unique-Key Merge-on-Write.
+- Поиск по первичному ключу с `SELECT *` при тысячах QPS. Каждый столбец
читается отдельно, поэтому точечный запрос к широкой строке требует в N раз
больше операций ввода-вывода. Используйте механизм [высокопараллельных точечных
запросов](./high-concurrency-point-query), который добавляет столбец с
построчным форматом с помощью `"store_row_column" = "true"` в таблицу
Unique-Key Merge-on-Write.
- Настройка `compression` или `storage_page_size` без профилирования. Значения
по умолчанию (LZ4F, 64 KB) подходят для большинства нагрузок. Переходите на
ZSTD, только если стоимость хранения важнее затрат CPU; уменьшайте размер
страницы, только если при распаковке небольших столбцов выполняется лишняя
работа.
- Отключение кодирования, чтобы «увидеть столбец в исходном виде». Режима без
кодирования нет. Кодек является частью формата файла, а не слоем, который можно
убрать.
- Попытка ускорить точечные запросы с выборкой небольшого числа столбцов в
строчной схеме за счёт колоночного хранения. Если каждый запрос имеет вид
`WHERE id = ?` и возвращает одну строку, вам нужна другая система или
расширение для строчного хранения, а не другой кодек сжатия.
diff --git
a/i18n/ru/docusaurus-plugin-content-docs/version-4.x/key-features/high-concurrency-point-query.mdx
b/i18n/ru/docusaurus-plugin-content-docs/version-4.x/key-features/high-concurrency-point-query.mdx
index d563eca342f..63ad5add9dd 100644
---
a/i18n/ru/docusaurus-plugin-content-docs/version-4.x/key-features/high-concurrency-point-query.mdx
+++
b/i18n/ru/docusaurus-plugin-content-docs/version-4.x/key-features/high-concurrency-point-query.mdx
@@ -45,17 +45,16 @@ featureCard:
- **`store_row_column`**: свойство таблицы, которое добавляет скрытый столбец,
хранящий каждую строку в виде blob со строчным кодированием. Благодаря этому BE
читает один столбец вместо N, чтобы вернуть целую строку.
- **`SHORT-CIRCUIT`**: метка в выводе `EXPLAIN`, которая появляется, когда
планировщик обходит обычный распределённый план и направляет запрос по пути с
одним tablet и одним RPC.
- **`PreparedStatement`**: серверное кеширование подготовленных запросов по
протоколу MySQL. Apache Doris кеширует разобранный запрос, выражения результата
и таблицу дескрипторов для каждой сессии, а затем повторно использует их при
вызовах `EXECUTE`.
-- **`Row Cache`**: отдельный кеш LRU, в котором хранятся целые строки. Он
выдерживает давление вытеснения, которому подвергается колоночный Page Cache
при смешанной нагрузке из аналитических и точечных запросов.
## Как работают точечные запросы при высокой конкурентной нагрузке в Apache
Doris? {#how}
-Путь выполнения точечных запросов при высокой конкурентной нагрузке в Apache
Doris объединяет пять уровней: организацию хранения, преобразование плана на
FE, отправку по сокращённому пути, повторное использование серверного
`PreparedStatement` и поиск строки на BE с необязательным Row Cache.
+Путь выполнения точечных запросов при высокой конкурентной нагрузке в Apache
Doris объединяет пять уровней: организацию хранения, преобразование плана на
FE, отправку по сокращённому пути, повторное использование серверного
`PreparedStatement` и поиск строки на BE.
1. **Организация хранения.** Если при создании таблицы задать
`store_row_column=true`, BE записывает каждую строку и в колоночные сегменты, и
в скрытый столбец со строчным кодированием. Начиная с Apache Doris 3.0 можно
ограничить строчное хранение подмножеством столбцов с помощью
`row_store_columns="k1,v1,v2"`, чтобы сократить накладные расходы на хранение.
2. **Преобразование плана (FE).** Правило Nereids
`LogicalResultSinkToShortCircuitPointQuery` проверяет структуру запроса: одна
таблица Unique, конъюнктивные условия равенства для каждого ключевого столбца,
отсутствие соединений, подзапросов и агрегаций. Если все условия выполнены,
правило устанавливает флаг `isShortCircuitQuery` в `StatementContext`.
3. **Отправка по сокращённому пути.** Вместо создания и отправки фрагментов FE
определяет бакет с помощью `PartitionPruneV2ForShortCircuitPlan`, выбирает
единственный tablet, в котором может находиться ключ, и отправляет один RPC на
BE, которому принадлежит этот tablet.
4. **Повторное использование серверного `PreparedStatement`.** При
`useServerPrepStmts=true` FE кеширует `ShortCircuitQueryContext` по UUID
сессии. Последующие вызовы `EXECUTE` полностью пропускают разбор и
планирование; меняются только значения параметров.
-5. **Поиск строки на BE.** Компонент `point_query_executor` находит строку по
ключу, читает столбец со строчным форматом и возвращает байты. Дополнительный
Row Cache при попадании в кеш позволяет пропустить даже чтение сегмента.
+5. **Поиск строки на BE.** Компонент `point_query_executor` находит строку по
ключу, читает столбец со строчным форматом и возвращает байты.
## Быстрый старт {#quick-start}
@@ -109,7 +108,7 @@ EXPLAIN SELECT * FROM tbl_point_query WHERE k1 = 42;
## Производительность и проверка {#performance}
-По данным Apache Doris, включение серверного `PreparedStatement` в дополнение
к сокращённому пути выполнения повышает пропускную способность более чем в 4
раза, когда узким местом является CPU FE. Это тот же рост в 4 раза, который
рассматривается со стороны подготовленных запросов в [карточке «Подготовленные
запросы»](./prepared-statement): единый совокупный эффект, а не два независимых
прироста, которые можно совместить. Результаты зависят от ширины строки, доли
попаданий в кеш строк и [...]
+По данным Apache Doris, включение серверного `PreparedStatement` в дополнение
к сокращённому пути выполнения повышает пропускную способность более чем в 4
раза, когда узким местом является CPU FE. Это тот же рост в 4 раза, который
рассматривается со стороны подготовленных запросов в [карточке «Подготовленные
запросы»](./prepared-statement): единый совокупный эффект, а не два независимых
прироста, которые можно совместить. Результаты зависят от ширины строки и числа
FE Observers, принимаю [...]
Две проверки позволяют убедиться, что этот путь используется:
diff --git
a/i18n/ru/docusaurus-plugin-content-docs/version-4.x/key-features/prepared-statement.mdx
b/i18n/ru/docusaurus-plugin-content-docs/version-4.x/key-features/prepared-statement.mdx
index 2758e12290e..fd80bb523c7 100644
---
a/i18n/ru/docusaurus-plugin-content-docs/version-4.x/key-features/prepared-statement.mdx
+++
b/i18n/ru/docusaurus-plugin-content-docs/version-4.x/key-features/prepared-statement.mdx
@@ -114,7 +114,7 @@ Stmt=EXECUTE(-2147481418)
## Производительность и проверка {#performance}
-Doris сообщает об [увеличении пропускной способности в 4 раза и
более](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/)
благодаря PreparedStatement в нагрузках с точечными запросами, где узким
местом является CPU FE. Это тот же прирост в 4 раза, который описан с точки
зрения short-circuit в [карточке функции «Точечные запросы с высокой
конкурентностью»](./high-concurrency-point-query): единый совокупный эффект, а
не два независимых ускорения, которые мож [...]
+Doris сообщает об [увеличении пропускной способности в 4 раза и
более](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/)
благодаря PreparedStatement в нагрузках с точечными запросами, где узким
местом является CPU FE. Это тот же прирост в 4 раза, который описан с точки
зрения short-circuit в [карточке функции «Точечные запросы с высокой
конкурентностью»](./high-concurrency-point-query): единый совокупный эффект, а
не два независимых ускорения, которые мож [...]
Две проверки позволяют убедиться, что этот путь выполнения используется:
diff --git
a/i18n/ru/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
b/i18n/ru/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
index d6233529c3f..ada3b8f1aa0 100644
---
a/i18n/ru/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
+++
b/i18n/ru/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
@@ -2,7 +2,7 @@
{
"title": "Точечные запросы при высокой конкурентной нагрузке",
"language": "ru",
- "description": "Как включить точечные запросы при высокой конкурентной
нагрузке в Doris? Значительно повысьте QPS точечных запросов по первичному
ключу и сократите время отклика с помощью построчного хранения, сокращённого
пути выполнения, PreparedStatement и кеша строк.",
+ "description": "Как включить точечные запросы при высокой конкурентной
нагрузке в Doris? Значительно повысьте QPS точечных запросов по первичному
ключу и сократите время отклика с помощью построчного хранения, сокращённого
пути выполнения и PreparedStatement.",
"keywords": [
"точечные запросы в Doris при высокой конкурентной нагрузке",
"оптимизация точечных запросов по первичному ключу",
@@ -10,7 +10,6 @@
"построчное хранение store_row_column",
"точечные запросы Merge-On-Write",
"сокращённый путь SHORT-CIRCUIT",
- "кеш строк",
"высокая загрузка CPU на FE как узкое место точечных запросов"
]
}
@@ -30,7 +29,6 @@
| Построчное хранение (Row Store) | При чтении целых строк широких таблиц
колоночное хранение увеличивает объём случайного ввода-вывода; построчное
хранение снижает эти затраты |
| Сокращённый путь выполнения запросов Short-Circuit (SHORT-CIRCUIT) |
Планирование и разбор простых запросов на FE требуют слишком много ресурсов;
сокращённый путь позволяет обойти обычный процесс планирования |
| PreparedStatement | Разбор SQL и вычисление выражений потребляют ресурсы CPU
на FE; кеширование плана и выражений снижает эти затраты |
-| Кеш строк (Row Cache) | Крупные запросы легко вытесняют данные из Page
Cache; отдельный кеш строк повышает долю попаданий |
## Контрольный список для быстрого включения {#quick-enablement-checklist}
@@ -41,7 +39,6 @@
- При создании таблицы включён параметр `light_schema_change = true`
- Запрос содержит только **условия равенства по столбцам Key**, без соединений
и вложенных подзапросов
- В JDBC URL включён параметр `useServerPrepStmts=true` для использования
PreparedStatement
-- (Необязательно) На BE задан параметр `disable_storage_row_cache = false` для
включения кеша строк
- С помощью `EXPLAIN` убедитесь, что план выполнения содержит маркер
`SHORT-CIRCUIT`
## Построчное хранение (Row Store) {#row-store}
@@ -143,20 +140,6 @@ resultSet = readStatement.executeQuery();
...
```
-## Включение кеша строк (Row Cache) {#enabling-row-cache}
-
-<!-- Knowledge type: Configuration parameter -->
-<!-- Applicable scenarios: Low row-store hit rate, Page Cache easily evicted
-->
-
-По умолчанию Doris предоставляет **кеш на уровне страниц**, в котором каждая
страница хранит данные одного столбца, поэтому Page Cache ориентирован на
столбцы. При построчном хранении строка содержит несколько столбцов, и крупные
запросы могут вытеснять данные из кеша.
-
-Чтобы повысить долю попаданий, Doris предоставляет отдельный **кеш строк (Row
Cache)**, использующий механизм LRU Cache для управления потреблением памяти.
Включите его с помощью следующих параметров BE:
-
-| Параметр | Значение по умолчанию | Описание |
-| ---------------------------- | ---------- |
--------------------------------- |
-| `disable_storage_row_cache` | `true` (по умолчанию отключён) | Отключать ли
кеш строк. Для включения задайте `false` |
-| `row_cache_mem_limit` | `20%` | Доля памяти, используемая Row Cache |
-
## Рекомендации по настройке производительности
{#performance-tuning-recommendations}
<!-- Knowledge type: Performance tuning -->
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
index 712ee4b1b1c..7fc796573db 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
@@ -56,7 +56,6 @@ Doris 自己管理的 Cache 目前均为 LRU 淘汰策略,均支持单独通
加速点查询执行,主要用于日志分析。
```
-- PointQueryRowCache
- PointQueryLookupConnectionCache
```
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
index dec621db18e..c4b1d4bd585 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/query-acceleration/high-concurrent-point-query.md
@@ -2,7 +2,7 @@
{
"title": "高并发点查",
"language": "zh-CN",
- "description": "如何在 Doris 中开启高并发点查?通过行存、短路径、PreparedStatement
与行缓存,显著提升主键点查 QPS 与响应延迟。",
+ "description": "如何在 Doris 中开启高并发点查?通过行存、短路径和 PreparedStatement,显著提升主键点查
QPS 与响应延迟。",
"keywords": [
"Doris 高并发点查",
"主键点查优化",
@@ -10,7 +10,6 @@
"行存 store_row_column",
"Merge-On-Write 点查",
"SHORT-CIRCUIT 短路径",
- "行缓存 row cache",
"FE CPU 高 点查瓶颈"
]
}
@@ -30,7 +29,6 @@
| 行存(Row Store) | 列存对宽表整行读取会放大随机 IO,引入行存减少 IO 开销 |
| 短查询路径(SHORT-CIRCUIT) | FE 的查询规划/解析对简单查询过重,短路径绕过常规规划流程 |
| PreparedStatement | SQL 解析与表达式计算占用 FE CPU,缓存计划/表达式以降低开销 |
-| 行缓存(Row Cache) | Page Cache 易被大查询淘汰,引入独立行缓存提高命中率 |
## 快速开启清单
@@ -41,7 +39,6 @@
- 建表时开启 `light_schema_change = true`
- 查询语句仅包含 **Key 列等值条件**,无 join 与嵌套子查询
- JDBC URL 开启 `useServerPrepStmts=true` 使用 PreparedStatement
-- (可选)BE 配置 `disable_storage_row_cache = false` 开启行缓存
- 通过 `EXPLAIN` 验证执行计划中存在 `SHORT-CIRCUIT` 标记
## 行存(Row Store)
@@ -143,20 +140,6 @@ resultSet = readStatement.executeQuery();
...
```
-## 开启行缓存(Row Cache)
-
-<!-- 知识类型: 配置参数 -->
-<!-- 适用场景: 行存命中率低、Page Cache 易被淘汰 -->
-
-Doris 默认提供 **Page 级别的 Cache**,每个 Page 中存储某一列的数据,因此 Page Cache
是面向列的缓存。对于行存而言,一行包括多列数据,缓存可能被大查询冲刷掉。
-
-为提升命中率,Doris 单独引入了**行缓存(Row Cache)**,复用 LRU Cache 机制保障内存使用。通过以下 BE 配置开启:
-
-| 配置项 | 默认值 | 说明 |
-| ---------------------------- | ---------- |
--------------------------------- |
-| `disable_storage_row_cache` | `true`(默认不开启)| 是否关闭行缓存,设置为 `false` 开启 |
-| `row_cache_mem_limit` | `20%` | Row Cache 占用内存的百分比 |
-
## 性能优化建议
<!-- 知识类型: 性能调优 -->
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
index 712ee4b1b1c..7fc796573db 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
@@ -56,7 +56,6 @@ Doris 自己管理的 Cache 目前均为 LRU 淘汰策略,均支持单独通
加速点查询执行,主要用于日志分析。
```
-- PointQueryRowCache
- PointQueryLookupConnectionCache
```
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.x/query-acceleration/high-concurrent-point-query.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.x/query-acceleration/high-concurrent-point-query.md
index adb0d718282..0ecfe3fd3c1 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.x/query-acceleration/high-concurrent-point-query.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.x/query-acceleration/high-concurrent-point-query.md
@@ -88,14 +88,6 @@ PROPERTIES (
...
```
-## 开启行缓存
-
-Doris 中有针对 Page 级别的 Cache,每个 Page 中存的是某一列的数据,所以 Page cache
是针对列的缓存,对于前面提到的行存,一行里包括了多列数据,缓存可能被大查询给刷掉,为了增加行缓存命中率,单独引入了行存缓存,行缓存复用了 Doris 中的
LRU Cache 机制来保障内存的使用,通过指定下面的的 BE 配置来开启
-
-- `disable_storage_row_cache` 是否开启行缓存,默认不开启
-
-- `row_cache_mem_limit` 指定 Row cache 占用内存的百分比,默认 20% 内存
-
## 性能优化
1. 通常,通过增加 Observer 数量来提升处理 query 能力是有效的
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
index 712ee4b1b1c..7fc796573db 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
@@ -56,7 +56,6 @@ Doris 自己管理的 Cache 目前均为 LRU 淘汰策略,均支持单独通
加速点查询执行,主要用于日志分析。
```
-- PointQueryRowCache
- PointQueryLookupConnectionCache
```
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
index dec621db18e..c4b1d4bd585 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-4.x/query-acceleration/high-concurrent-point-query.md
@@ -2,7 +2,7 @@
{
"title": "高并发点查",
"language": "zh-CN",
- "description": "如何在 Doris 中开启高并发点查?通过行存、短路径、PreparedStatement
与行缓存,显著提升主键点查 QPS 与响应延迟。",
+ "description": "如何在 Doris 中开启高并发点查?通过行存、短路径和 PreparedStatement,显著提升主键点查
QPS 与响应延迟。",
"keywords": [
"Doris 高并发点查",
"主键点查优化",
@@ -10,7 +10,6 @@
"行存 store_row_column",
"Merge-On-Write 点查",
"SHORT-CIRCUIT 短路径",
- "行缓存 row cache",
"FE CPU 高 点查瓶颈"
]
}
@@ -30,7 +29,6 @@
| 行存(Row Store) | 列存对宽表整行读取会放大随机 IO,引入行存减少 IO 开销 |
| 短查询路径(SHORT-CIRCUIT) | FE 的查询规划/解析对简单查询过重,短路径绕过常规规划流程 |
| PreparedStatement | SQL 解析与表达式计算占用 FE CPU,缓存计划/表达式以降低开销 |
-| 行缓存(Row Cache) | Page Cache 易被大查询淘汰,引入独立行缓存提高命中率 |
## 快速开启清单
@@ -41,7 +39,6 @@
- 建表时开启 `light_schema_change = true`
- 查询语句仅包含 **Key 列等值条件**,无 join 与嵌套子查询
- JDBC URL 开启 `useServerPrepStmts=true` 使用 PreparedStatement
-- (可选)BE 配置 `disable_storage_row_cache = false` 开启行缓存
- 通过 `EXPLAIN` 验证执行计划中存在 `SHORT-CIRCUIT` 标记
## 行存(Row Store)
@@ -143,20 +140,6 @@ resultSet = readStatement.executeQuery();
...
```
-## 开启行缓存(Row Cache)
-
-<!-- 知识类型: 配置参数 -->
-<!-- 适用场景: 行存命中率低、Page Cache 易被淘汰 -->
-
-Doris 默认提供 **Page 级别的 Cache**,每个 Page 中存储某一列的数据,因此 Page Cache
是面向列的缓存。对于行存而言,一行包括多列数据,缓存可能被大查询冲刷掉。
-
-为提升命中率,Doris 单独引入了**行缓存(Row Cache)**,复用 LRU Cache 机制保障内存使用。通过以下 BE 配置开启:
-
-| 配置项 | 默认值 | 说明 |
-| ---------------------------- | ---------- |
--------------------------------- |
-| `disable_storage_row_cache` | `true`(默认不开启)| 是否关闭行缓存,设置为 `false` 开启 |
-| `row_cache_mem_limit` | `20%` | Row Cache 占用内存的百分比 |
-
## 性能优化建议
<!-- 知识类型: 性能调优 -->
diff --git a/releasenotes/v2.0/release-2.0.0.md
b/releasenotes/v2.0/release-2.0.0.md
index 7883378dfa3..17de05414bd 100644
--- a/releasenotes/v2.0/release-2.0.0.md
+++ b/releasenotes/v2.0/release-2.0.0.md
@@ -53,7 +53,7 @@ A smartphone manufacturer tested Apache Doris 2.0.0 in their
user behavior analy
In scenarios like e-commerce order queries and express tracking, a huge number
of end data users search for a certain data record simultaneously. These are
what we call high-concurrency point queries, which can bring huge pressure on
the system. A traditional solution is to introduce Key-Value stores like Apache
HBase for such queries, and Redis as a cache layer to ease the burden, but that
means redundant storage and higher maintenance costs.
-For a column-oriented DBMS like Apache Doris, the I/O usage of point queries
will be multiplied. We need neater execution. Thus, on the basis of columnar
storage, we added row storage format and row cache to increase row reading
efficiency, short-circuit plans to speed up data retrieval, and prepared
statements to reduce frontend overheads.
+For a column-oriented DBMS like Apache Doris, the I/O usage of point queries
will be multiplied. We need neater execution. Thus, on the basis of columnar
storage, we added a row storage format to increase row reading efficiency,
short-circuit plans to speed up data retrieval, and prepared statements to
reduce frontend overheads.
After these optimizations, Apache Doris 2.0 reached a concurrency level of
**30,000 QPS per node** on YCSB on a 16 Core 64G cloud server with 4×1T hard
drives, representing an improvement of **20 times** compared to its older
version. This makes Apache Doris a good alternative to HBase in
high-concurrency scenarios, so that users don't need to endure extra
maintenance costs and redundant storage brought by complicated tech stacks.
@@ -207,7 +207,7 @@ This feature allows for higher availability of data,
read/write workload separat
- A limit has been imposed on the depth of the expression tree. The default
value is 200;
- The single quote in the return value of array string has been changed to
double quote;
- The Doris processes are renamed to DorisFE and DorisBE.
-- The functions AES and SM4 with two arguments' behaviour changed. See more
informations in [relative function
docs](../../sql-manual/sql-functions/scalar-functions/encrypt-digest-functions/sm4-encrypt.md)
+- The functions AES and SM4 with two arguments' behaviour changed. See more
informations in [relative function
docs](../../versioned_docs/version-3.x/sql-manual/sql-functions/scalar-functions/encrypt-digest-functions/sm4-encrypt.md)
## Embarking on the 2.0.0 Journey
diff --git
a/versioned_docs/version-3.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
b/versioned_docs/version-3.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
index 280f4522c7a..934b33ec50e 100644
---
a/versioned_docs/version-3.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
+++
b/versioned_docs/version-3.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
@@ -56,7 +56,6 @@ Speed up inverted index.
Speed up point query execution, mainly used for log analysis.
```
-- PointQueryRowCache
- PointQueryLookupConnectionCache
```
diff --git
a/versioned_docs/version-3.x/query-acceleration/high-concurrent-point-query.md
b/versioned_docs/version-3.x/query-acceleration/high-concurrent-point-query.md
index 295aa42235c..96594f25f71 100644
---
a/versioned_docs/version-3.x/query-acceleration/high-concurrent-point-query.md
+++
b/versioned_docs/version-3.x/query-acceleration/high-concurrent-point-query.md
@@ -110,13 +110,6 @@ In order to reduce CPU cost for parsing query SQL and SQL
expressions, we provid
...
```
-## Enable row cache
-Doris has a page-level cache that stores data for a specific column in each
page. Therefore, the page cache is a column-based cache. For the row storage
mentioned earlier, a row contains data for multiple columns, and the cache may
be evicted by large queries, which can reduce the hit rate. To increase the hit
rate of the row cache, a separate row cache is introduced, which reuses the LRU
cache mechanism in Doris to ensure memory usage. You can enable it by
specifying the following BE co [...]
-
-- `disable_storage_row_cache` : Whether to enable the row cache. It is not
enabled by default.
-
-- `row_cache_mem_limit` : Specifies the percentage of memory occupied by the
row cache. The default is 20% of memory.
-
## Performance Optimization
1. Generally, it is effective to improve query processing capabilities by
increasing the number of Observers.
diff --git
a/versioned_docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
b/versioned_docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
index 280f4522c7a..934b33ec50e 100644
---
a/versioned_docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
+++
b/versioned_docs/version-4.x/admin-manual/trouble-shooting/memory-management/memory-analysis/doris-cache-memory-analysis.md
@@ -56,7 +56,6 @@ Speed up inverted index.
Speed up point query execution, mainly used for log analysis.
```
-- PointQueryRowCache
- PointQueryLookupConnectionCache
```
diff --git a/versioned_docs/version-4.x/key-features/columnar-storage.mdx
b/versioned_docs/version-4.x/key-features/columnar-storage.mdx
index 5055969e917..80b53bb96af 100644
--- a/versioned_docs/version-4.x/key-features/columnar-storage.mdx
+++ b/versioned_docs/version-4.x/key-features/columnar-storage.mdx
@@ -108,7 +108,7 @@ Apache Doris columnar storage is the default and only OLAP
format, so every anal
**Not a good fit**
-- `SELECT *` lookups by primary key at thousands of QPS. Each column is a
separate read, so a wide-row point query pays N times the I/O. Reach for the
[High-Concurrency Point Query](./high-concurrency-point-query) path, which adds
a row-cached column with `"store_row_column" = "true"` on top of a Unique-Key
Merge-on-Write table.
+- `SELECT *` lookups by primary key at thousands of QPS. Each column is a
separate read, so a wide-row point query pays N times the I/O. Reach for the
[High-Concurrency Point Query](./high-concurrency-point-query) path, which adds
a row-format column with `"store_row_column" = "true"` on top of a Unique-Key
Merge-on-Write table.
- Tweaking `compression` or `storage_page_size` without a profile. The
defaults (LZ4F, 64 KB) fit most workloads. Move to ZSTD only when storage cost
matters more than CPU; shrink the page size only when small columns are wasting
decompression work.
- Disabling encodings to "see the raw column." There is no raw mode. The codec
is part of the file format, not a layer you peel off.
- Treating columnar storage as a fix for narrow point lookups on a
row-oriented schema. If every query is `WHERE id = ?` and returns one row, you
want a different system or the row-store extension, not a different compression
codec.
diff --git
a/versioned_docs/version-4.x/key-features/high-concurrency-point-query.mdx
b/versioned_docs/version-4.x/key-features/high-concurrency-point-query.mdx
index 24a45a253dc..457d1cdc93f 100644
--- a/versioned_docs/version-4.x/key-features/high-concurrency-point-query.mdx
+++ b/versioned_docs/version-4.x/key-features/high-concurrency-point-query.mdx
@@ -45,17 +45,16 @@ The Apache Doris high-concurrency point query is a
four-layer optimization that
- **`store_row_column`**: a table property that adds a hidden column holding
each row in a row-encoded blob, so the BE reads one column instead of N to
return a whole row.
- **`SHORT-CIRCUIT`**: a marker in `EXPLAIN` output that appears once the
planner has skipped the normal distributed plan and routed the query through a
single-tablet, single-RPC path.
- **`PreparedStatement`**: server-side statement caching over the MySQL
protocol. Apache Doris caches the parsed statement, output expressions, and
descriptor table per session, then reuses them across `EXECUTE` calls.
-- **`Row Cache`**: a separate LRU cache that holds whole rows. It survives the
eviction pressure that the columnar Page Cache suffers under mixed analytical
and point-query workloads.
## How does the Apache Doris high-concurrency point query work? {#how}
-The Apache Doris high-concurrency point query path threads five layers
together: storage layout, FE plan rewrite, short-circuit dispatch, server-side
`PreparedStatement` reuse, and a BE row lookup with optional Row Cache.
+The Apache Doris high-concurrency point query path threads five layers
together: storage layout, FE plan rewrite, short-circuit dispatch, server-side
`PreparedStatement` reuse, and a BE row lookup.
1. **Storage layout.** When you set `store_row_column=true` at table creation,
the BE writes each row both into the columnar segments and into a row-encoded
hidden column. From Apache Doris 3.0 onward you can scope this to a subset with
`row_store_columns="k1,v1,v2"` to limit the storage overhead.
2. **Plan rewrite (FE).** The Nereids rule
`LogicalResultSinkToShortCircuitPointQuery` checks the query shape: single
Unique table, equality conjuncts on every key column, no joins or subqueries,
no aggregations. If everything matches, it flips the `isShortCircuitQuery` flag
in the `StatementContext`.
3. **Short-circuit dispatch.** Instead of building fragments and shipping
them, the FE resolves the bucket through `PartitionPruneV2ForShortCircuitPlan`,
picks the one tablet that can hold the key, and sends a single RPC to the BE
that owns it.
4. **Server-side `PreparedStatement` reuse.** With `useServerPrepStmts=true`,
the FE caches the `ShortCircuitQueryContext` per session UUID. Subsequent
`EXECUTE` calls skip parsing and planning entirely; only the parameter values
change.
-5. **BE row lookup.** The `point_query_executor` locates the row by key, reads
the row-format column, and returns the bytes. The optional Row Cache
short-circuits even the segment read on a hit.
+5. **BE row lookup.** The `point_query_executor` locates the row by key, reads
the row-format column, and returns the bytes.
## Quick start {#quick-start}
@@ -109,7 +108,7 @@ The Apache Doris high-concurrency point query fits any
online service that reads
## Performance and verification {#performance}
-Apache Doris reports that enabling server-side `PreparedStatement` on top of
the short-circuit path delivers more than a 4x throughput improvement when FE
CPU is the bottleneck. This is the same 4x cited from the prepared-statement
angle in the [Prepared Statement card](./prepared-statement) — one combined
gain, not two stackable ones. Numbers depend on row width, row cache hit rate,
and how many FE Observers absorb traffic, so treat that as a planning floor,
not a benchmark.
+Apache Doris reports that enabling server-side `PreparedStatement` on top of
the short-circuit path delivers more than a 4x throughput improvement when FE
CPU is the bottleneck. This is the same 4x cited from the prepared-statement
angle in the [Prepared Statement card](./prepared-statement) — one combined
gain, not two stackable ones. Numbers depend on row width and how many FE
Observers absorb traffic, so treat that as a planning floor, not a benchmark.
Two checks tell you the path is live:
diff --git a/versioned_docs/version-4.x/key-features/prepared-statement.mdx
b/versioned_docs/version-4.x/key-features/prepared-statement.mdx
index d7476837106..b40eeedfae9 100644
--- a/versioned_docs/version-4.x/key-features/prepared-statement.mdx
+++ b/versioned_docs/version-4.x/key-features/prepared-statement.mdx
@@ -114,7 +114,7 @@ Apache Doris prepared statements fit high-QPS point queries
on Unique Key tables
## Performance and verification {#performance}
-Doris reports a [4x or better throughput
improvement](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/)
from PreparedStatement on point-query workloads where FE CPU is the
bottleneck. This is the same 4x cited from the short-circuit angle in the
[High-Concurrency Point Query card](./high-concurrency-point-query) — one
combined gain, not two stackable ones. The full high-concurrency stack (Unique
Key + Merge-on-Write + row store + row cache + short-circuit [...]
+Doris reports a [4x or better throughput
improvement](https://doris.apache.org/docs/2.1/query-acceleration/high-concurrent-point-query/)
from PreparedStatement on point-query workloads where FE CPU is the
bottleneck. This is the same 4x cited from the short-circuit angle in the
[High-Concurrency Point Query card](./high-concurrency-point-query) — one
combined gain, not two stackable ones. The full high-concurrency stack reaches
[30,000+ QPS per node](https://doris.apache.org/blog/How-We- [...]
Two checks tell you the path is live:
diff --git
a/versioned_docs/version-4.x/query-acceleration/high-concurrent-point-query.md
b/versioned_docs/version-4.x/query-acceleration/high-concurrent-point-query.md
index e3fa54da517..e3acb064654 100644
---
a/versioned_docs/version-4.x/query-acceleration/high-concurrent-point-query.md
+++
b/versioned_docs/version-4.x/query-acceleration/high-concurrent-point-query.md
@@ -2,7 +2,7 @@
{
"title": "High-Concurrency Point Query",
"language": "en",
- "description": "How to enable high-concurrency point queries in Doris?
Significantly improve primary-key point-query QPS and response latency through
row store, short-circuit path, PreparedStatement, and row cache.",
+ "description": "How to enable high-concurrency point queries in Doris?
Significantly improve primary-key point-query QPS and response latency through
row store, short-circuit path, and PreparedStatement.",
"keywords": [
"Doris high-concurrency point query",
"primary-key point-query optimization",
@@ -10,7 +10,6 @@
"row store store_row_column",
"Merge-On-Write point query",
"SHORT-CIRCUIT short path",
- "row cache",
"FE high CPU point-query bottleneck"
]
}
@@ -30,7 +29,6 @@ To address this, Doris applies optimizations at the following
layers:
| Row Store | Columnar storage amplifies random IO when reading whole rows of
wide tables; row store reduces IO overhead |
| Short-Circuit query path (SHORT-CIRCUIT) | FE query planning and parsing is
too heavy for simple queries; the short-circuit path bypasses the regular
planning flow |
| PreparedStatement | SQL parsing and expression evaluation consume FE CPU;
caching the plan and expressions reduces overhead |
-| Row Cache | The Page Cache is easily evicted by large queries; a dedicated
row cache improves hit rate |
## Quick Enablement Checklist
@@ -41,7 +39,6 @@ Before using high-concurrency point queries, confirm that all
of the following c
- `light_schema_change = true` is enabled at table creation
- The query contains only **equality conditions on Key columns**, with no
joins or nested subqueries
- The JDBC URL has `useServerPrepStmts=true` enabled to use PreparedStatement
-- (Optional) BE configuration `disable_storage_row_cache = false` is set to
enable row cache
- Use `EXPLAIN` to verify that the execution plan contains the `SHORT-CIRCUIT`
marker
## Row Store
@@ -143,20 +140,6 @@ resultSet = readStatement.executeQuery();
...
```
-## Enabling Row Cache
-
-<!-- Knowledge type: Configuration parameter -->
-<!-- Applicable scenarios: Low row-store hit rate, Page Cache easily evicted
-->
-
-By default, Doris provides a **Page-level cache**, where each page stores data
for a single column, so the Page Cache is column-oriented. For row store, a row
contains multiple columns, and the cache may be flushed by large queries.
-
-To improve the hit rate, Doris introduces a separate **Row Cache** that reuses
the LRU Cache mechanism to control memory usage. Enable it through the
following BE configurations:
-
-| Configuration | Default | Description |
-| ---------------------------- | ---------- |
--------------------------------- |
-| `disable_storage_row_cache` | `true` (disabled by default) | Whether to
disable row cache. Set to `false` to enable |
-| `row_cache_mem_limit` | `20%` | Percentage of memory used by the Row Cache |
-
## Performance Tuning Recommendations
<!-- Knowledge type: Performance tuning -->
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]