-
+对于 TiDB Cloud Starter 集群,按如下步骤获取集群连接字符串并配置环境变量:
-本文档使用 [OpenAI](https://platform.openai.com/docs/introduction) 作为嵌入模型生成向量嵌入。在此步骤中,你需要提供集群的连接字符串和 [OpenAI API 密钥](https://platform.openai.com/docs/quickstart/step-2-set-up-your-api-key)。
+1. 进入 [**Clusters**](https://tidbcloud.com/console/clusters) 页面,点击目标集群名称进入集群概览页。
-运行以下代码,配置环境变量。代码运行后,系统会提示输入连接字符串和 OpenAI API 密钥:
+2. 点击右上角的 **Connect**,弹出连接对话框。
-```python
-# Use getpass to securely prompt for environment variables in your terminal.
-import getpass
-import os
+3. 确认连接对话框中的配置与你的运行环境一致。
-# Connection string format: "mysql+pymysql://
:@:4000/?ssl_ca=/etc/ssl/cert.pem&ssl_verify_cert=true&ssl_verify_identity=true"
-tidb_connection_string = getpass.getpass("TiDB Connection String:")
-os.environ["OPENAI_API_KEY"] = getpass.getpass("OpenAI API Key:")
-```
+ - **Connection Type** 选择 `Public`。
+ - **Branch** 选择 `main`。
+ - **Connect With** 选择 `SQLAlchemy`。
+ - **Operating System** 选择与你环境一致的操作系统。
-以 macOS 为例,集群的连接字符串如下所示:
-
-```dotenv
-TIDB_DATABASE_URL="mysql+pymysql://:@:/"
-# 例如:TIDB_DATABASE_URL="mysql+pymysql://root@127.0.0.1:4000/test"
-```
+4. 点击 **PyMySQL** 标签页,复制连接字符串。
-请替换连接字符串中的参数为你的 TiDB 实际对应的值。如果你在本机运行 TiDB,默认 `` 地址为 `127.0.0.1`。`` 初始密码为空,若你是第一次启动集群,则无需带上此字段。
+ > **提示:**
+ >
+ > 如果你还未设置密码,可点击 **Generate Password** 生成随机密码。
-以下为各参数的解释:
-
-- ``:连接 TiDB 集群的用户名。
-- ``:连接 TiDB 集群的密码。
-- ``:TiDB 集群的主机地址。
-- ``:TiDB 集群的端口号。
-- ``:要连接的数据库名称。
+5. 配置环境变量。
-
+ 本文档以 [OpenAI](https://platform.openai.com/docs/introduction) 作为嵌入模型提供方。在此步骤,你需要提供上一步获取的连接字符串和你的 [OpenAI API key](https://platform.openai.com/docs/quickstart/step-2-set-up-your-api-key)。
-
+ 运行以下代码配置环境变量。你将被提示输入连接字符串和 OpenAI API key:
-对于 TiDB Cloud Serverless 集群,请按照以下步骤获取集群的连接字符串,然后配置环境变量:
+ ```python
+ # 使用 getpass 在终端安全地输入环境变量。
+ import getpass
+ import os
-1. 在 TiDB Cloud 的 [**Clusters**](https://tidbcloud.com/console/clusters) 页面,单击你的 TiDB Cloud Serverless 集群名,进入集群的 **Overview** 页面。
+ # 从 TiDB Cloud 控制台复制你的连接字符串。
+ # 连接字符串格式:"mysql+pymysql://
:@:4000/?ssl_ca=/etc/ssl/cert.pem&ssl_verify_cert=true&ssl_verify_identity=true"
+ tidb_connection_string = getpass.getpass("TiDB Connection String:")
+ os.environ["OPENAI_API_KEY"] = getpass.getpass("OpenAI API Key:")
+ ```
-2. 点击右上角的 **Connect** 按钮,将会弹出连接对话框。
+
+
-3. 确认对话框中的配置和你的运行环境一致。
+本文档以 [OpenAI](https://platform.openai.com/docs/introduction) 作为嵌入模型提供方。在此步骤,你需要提供上一步获取的连接字符串和你的 [OpenAI API key](https://platform.openai.com/docs/quickstart/step-2-set-up-your-api-key)。
- - **Connection Type** 为 `Public`。
- - **Branch** 选择 `main`。
- - **Connect With** 选择 `SQLAlchemy`。
- - **Operating System** 为你的运行环境。
+运行以下代码配置环境变量。你将被提示输入连接字符串和 OpenAI API key:
-4. 点击 **PyMySQL** 选项卡,复制连接字符串。
+```python
+# 使用 getpass 在终端安全地输入环境变量。
+import getpass
+import os
- > **Tip:**
- >
- > 如果你还没有设置密码,点击 **Generate Password** 生成一个随机密码。
+# 连接字符串格式:"mysql+pymysql://
:@:4000/?ssl_ca=/etc/ssl/cert.pem&ssl_verify_cert=true&ssl_verify_identity=true"
+tidb_connection_string = getpass.getpass("TiDB Connection String:")
+os.environ["OPENAI_API_KEY"] = getpass.getpass("OpenAI API Key:")
+```
-5. 配置环境变量。
+以 macOS 为例,集群连接字符串如下:
- 本文档使用 [OpenAI](https://platform.openai.com/docs/introduction) 作为嵌入模型生成向量嵌入。在此步骤中,你需要提供从上一步中获取的连接字符串和 [OpenAI API 密钥](https://platform.openai.com/docs/quickstart/step-2-set-up-your-api-key)。
+```dotenv
+TIDB_DATABASE_URL="mysql+pymysql://:@:/"
+# 例如:TIDB_DATABASE_URL="mysql+pymysql://root@127.0.0.1:4000/test"
+```
- 运行以下代码,配置环境变量。代码运行后,系统会提示输入连接字符串和 OpenAI API 密钥:
+你需要根据你的 TiDB 集群实际情况修改连接参数的值。如果你在本地运行 TiDB,`` 默认为 `127.0.0.1`。初始 `` 为空,因此首次启动集群时可以省略该字段。
- ```python
- # Use getpass to securely prompt for environment variables in your terminal.
- import getpass
- import os
+各参数说明如下:
- # Copy your connection string from the TiDB Cloud console.
- # Connection string format: "mysql+pymysql://:@:4000/?ssl_ca=/etc/ssl/cert.pem&ssl_verify_cert=true&ssl_verify_identity=true"
- tidb_connection_string = getpass.getpass("TiDB Connection String:")
- os.environ["OPENAI_API_KEY"] = getpass.getpass("OpenAI API Key:")
- ```
+- ``:连接 TiDB 集群的用户名。
+- ``:连接 TiDB 集群的密码。
+- ``:TiDB 集群的主机。
+- ``:TiDB 集群的端口。
+- ``:你要连接的数据库名称。
-### 第 4 步:加载样本文档
+### 步骤 4. 加载示例文档
-#### 4.1 下载样本文档
+#### 步骤 4.1 下载示例文档
-在你的项目目录中创建一个名为 `data/how_to/` 的目录,然后从 [langchain-ai/langchain](https://github.com/langchain-ai/langchain) 代码库中下载样本文档 [`state_of_the_union.txt`](https://github.com/langchain-ai/langchain/blob/master/docs/docs/how_to/state_of_the_union.txt)。
+在你的项目目录下,新建 `data/how_to/` 目录,并从 [langchain-ai/langchain](https://github.com/langchain-ai/langchain) GitHub 仓库下载示例文档 [`state_of_the_union.txt`](https://github.com/langchain-ai/langchain/blob/master/docs/docs/how_to/state_of_the_union.txt)。
```shell
-mkdir -p 'data/how_to/'
-wget 'https://raw.githubusercontent.com/langchain-ai/langchain/master/docs/docs/how_to/state_of_the_union.txt' -O 'data/how_to/state_of_the_union.txt'
+!mkdir -p 'data/how_to/'
+!wget 'https://raw.githubusercontent.com/langchain-ai/langchain/master/docs/docs/how_to/state_of_the_union.txt' -O 'data/how_to/state_of_the_union.txt'
```
-#### 4.2 加载并分割文档
+#### 步骤 4.2 加载并切分文档
-从 `data/how_to/state_of_the_union.txt` 中加载示例文档,并使用 `CharacterTextSplitter` 将其分割成每块约 1000 个字符的文本块。
+从 `data/how_to/state_of_the_union.txt` 加载示例文档,并使用 `CharacterTextSplitter` 将其切分为约 1,000 个字符的块。
```python
loader = TextLoader("data/how_to/state_of_the_union.txt")
@@ -166,11 +166,11 @@ text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
docs = text_splitter.split_documents(documents)
```
-### 第 5 步:生成并存储文档向量
+### 步骤 5. 嵌入并存储文档向量
-TiDB 支持使用余弦距离 (`cosine`) 和欧式距离 (`L2`) 来评估向量之间的相似性。在存储向量时,默认使用余弦距离。
+TiDB 向量存储支持余弦距离(`cosine`)和欧氏距离(`l2`)两种向量相似度度量方式。默认策略为余弦距离。
-以下代码将在 TiDB 中创建一个 `embedded_documents` 表,该表针对向量搜索进行了优化。
+以下代码将在 TiDB 中创建一个名为 `embedded_documents` 的表,该表已针对向量搜索进行了优化。
```python
embeddings = OpenAIEmbeddings()
@@ -179,23 +179,23 @@ vector_store = TiDBVectorStore.from_documents(
embedding=embeddings,
table_name="embedded_documents",
connection_string=tidb_connection_string,
- distance_strategy="cosine", # default, another option is "l2"
+ distance_strategy="cosine", # 默认,另一个选项为 "l2"
)
```
-成功执行后,你可以直接查看和访问 TiDB 数据库中的 `embedded_documents` 表。
+执行成功后,你可以直接在 TiDB 数据库中查看和访问 `embedded_documents` 表。
-### 第 6 步:执行向量搜索
+### 步骤 6. 执行向量搜索
-本节将展示如何在 `state_of_the_union.txt` 文档中查询 "What did the president say about Ketanji Brown Jackson"。
+本步骤演示如何在文档 `state_of_the_union.txt` 中搜索 “What did the president say about Ketanji Brown Jackson”。
```python
query = "What did the president say about Ketanji Brown Jackson"
```
-#### 方式一:使用 `similarity_search_with_score()`
+#### 选项 1:使用 `similarity_search_with_score()`
-`similarity_search_with_score()` 方法用于计算文档内容与查询语句之间的向量距离。该距离是一个相似度的得分,其计算方式由所选的 `distance_strategy` 决定。该方法会返回得分最低的前 `k` 个文档。得分越低,说明文档与你的查询语句之间的相似度越高。
+`similarity_search_with_score()` 方法会计算文档与查询在向量空间中的距离。该距离作为相似度分数,由所选的 `distance_strategy` 决定。该方法返回分数最低的前 `k` 个文档。分数越低,文档与查询的相似度越高。
```python
docs_with_score = vector_store.similarity_search_with_score(query, k=3)
@@ -252,9 +252,9 @@ First, beat the opioid epidemic.
-#### 方式二:使用 `similarity_search_with_relevance_scores()` 方法
+#### 选项 2:使用 `similarity_search_with_relevance_scores()`
-`similarity_search_with_relevance_scores()` 方法会返回相关性得分最高的前 `k`个文档。分数越高,说明文档内容与你的查询语句之间的相似度越高。
+`similarity_search_with_relevance_scores()` 方法返回相关性分数最高的前 `k` 个文档。分数越高,文档与查询的相似度越高。
```python
docs_with_relevance_score = vector_store.similarity_search_with_relevance_scores(query, k=2)
@@ -297,9 +297,9 @@ We’re securing commitments and supporting partners in South and Central Americ
-### 用作检索器
+### 作为检索器使用
-在 Langchain 中,[检索器](https://python.langchain.com/v0.2/docs/concepts/#retrievers)是一个接口,用于响应非结构化查询,检索相关文档。相比于向量存储,检索器可以为你提供更多的功能。以下代码演示了如何将 TiDB 向量存储用作检索器。
+在 LangChain 中,[retriever](https://python.langchain.com/v0.2/docs/concepts/#retrievers) 是一个用于非结构化查询搜索文档的接口,功能比向量存储更丰富。以下代码演示如何将 TiDB 向量存储作为检索器使用。
```python
retriever = vector_store.as_retriever(
@@ -329,25 +329,25 @@ And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketan
### 移除向量存储
-要删除现有的 TiDB 向量存储,可以使用 `drop_vectorstore()` 方法:
+如需移除已存在的 TiDB 向量存储,可使用 `drop_vectorstore()` 方法:
```python
vector_store.drop_vectorstore()
```
-## 使用元数据过滤器进行搜索
+## 使用元信息过滤进行搜索
-为了优化搜索,你可以使用元数据过滤器来筛选出符合特定条件的近邻结果。
+你可以通过元信息过滤,进一步筛选搜索结果,仅返回符合过滤条件的最近邻结果。
-### 支持的元数据类型
+### 支持的元信息类型
-在 TiDB 向量存储中,每个文档都可以与元数据配对。元数据的结构是 JSON 对象中的键值对 (key-value pairs) 形式。键 (key) 的类型是字符串,而值 (value) 可以是以下任何类型:
+TiDB 向量存储中的每个文档都可以携带元信息,结构为 JSON 对象的键值对。键始终为字符串,值可以是以下类型之一:
- 字符串
-- 数值:整数或浮点数
-- Boolean:`true` 或 `false`
+- 数值:整数型或浮点型
+- 布尔型:`true` 或 `false`
-例如,下面是一个有效的元数据格式:
+例如,以下是一个有效的元信息负载:
```json
{
@@ -356,22 +356,22 @@ vector_store.drop_vectorstore()
}
```
-### 元数据过滤器语法
+### 元信息过滤语法
可用的过滤器包括:
-- `$or`:选择符合任意一个指定条件的向量。
-- `$and`:选择符合所有指定条件的向量。
+- `$or`:匹配任意一个条件的向量。
+- `$and`:同时匹配所有条件的向量。
- `$eq`:等于指定值。
- `$ne`:不等于指定值。
- `$gt`:大于指定值。
-- `$gte`:大于或等于指定值。
+- `$gte`:大于等于指定值。
- `$lt`:小于指定值。
-- `$lte`:小于或等于指定值。
-- `$in`:在指定的值数组中。
+- `$lte`:小于等于指定值。
+- `$in`:在指定值数组中。
- `$nin`:不在指定值数组中。
-假如一个文档的元数据如下:
+如果某文档的元信息如下:
```json
{
@@ -380,7 +380,7 @@ vector_store.drop_vectorstore()
}
```
-以下元数据筛选器均可匹配到该文档:
+以下元信息过滤器均可匹配该文档:
```json
{ "page": 12 }
@@ -413,11 +413,11 @@ vector_store.drop_vectorstore()
}
```
-TiDB 会将元数据过滤器中的每个键值对视为一个独立的过滤条件,并使用 `AND` 逻辑操作符将这些条件组合起来。
+在元信息过滤器中,TiDB 会将每个键值对视为独立的过滤子句,并使用 `AND` 逻辑运算符将这些子句组合。
### 示例
-以下示例代码向 `TiDBVectorStore` 添加了两个文档,并为每个文档添加了一个 `title` 字段作为元数据:
+以下示例向 `TiDBVectorStore` 添加两个文档,并为每个文档添加 `title` 字段作为元信息:
```python
vector_store.add_texts(
@@ -439,7 +439,7 @@ vector_store.add_texts(
UUID('08dcd2ba-9f16-4f29-a9b7-18141f8edae3')]
```
-使用元数据过滤器进行相似性搜索:
+使用元信息过滤器进行相似度搜索:
```python
docs_with_score = vector_store.similarity_search_with_score(
@@ -461,21 +461,21 @@ TiDB Vector offers advanced, high-speed vector processing capabilities, enhancin
--------------------------------------------------------------------------------
```
-## 进阶用法示例:旅行代理
+## 高级用例示例:旅行社
-本节演示如何将 Langchain 和 TiDB 向量搜索相结合,应用于旅行代理的场景。该场景的目标是为客户创建个性化的旅行报告,帮助他们找到具备特定设施(例如干净的休息室和素食选项)的机场。
+本节演示将向量搜索与 LangChain 集成的旅行社场景。目标是为客户生成个性化旅行报告,帮助他们查找拥有特定设施(如干净的休息室和素食选项)的机场。
-该示例包括两个主要步骤:
+流程主要分为两步:
-1. 对机场介绍中进行语义搜索,以找出符合所需设施的机场代码。
-2. 执行 SQL 查询,将这些代码与航线信息相结合,以便突出显示符合用户偏好的航空公司和目的地。
+1. 对机场评论进行语义搜索,找出符合所需设施的机场代码。
+2. 执行 SQL 查询,将这些代码与航线信息关联,突出显示符合用户偏好的航空公司和目的地。
### 准备数据
-首先,创建一个表来存储机场航线数据:
+首先,创建用于存储机场航线数据的表:
```python
-# 创建表格以存储飞行计划数据。
+# 创建用于存储航班计划数据的表。
vector_store.tidb_vector_client.execute(
"""CREATE TABLE airplan_routes (
id INT AUTO_INCREMENT PRIMARY KEY,
@@ -491,7 +491,7 @@ vector_store.tidb_vector_client.execute(
);"""
)
-# 在 airplan_routes 和向量表中插入一些样本数据。
+# 向 airplan_routes 和向量表插入一些示例数据。
vector_store.tidb_vector_client.execute(
"""INSERT INTO airplan_routes (
airport_code,
@@ -533,7 +533,7 @@ vector_store.add_texts(
### 执行语义搜索
-以下代码可以搜索到有清洁设施和素食选择的机场:
+以下代码搜索拥有干净设施和素食选项的机场:
```python
retriever = vector_store.as_retriever(
@@ -562,15 +562,15 @@ Comfortable seating in lounge areas and diverse food selections, including veget
--------------------------------------------------------------------------------
```
-### 检索详细的机场信息
+### 获取机场详细信息
-从搜索结果中提取机场代码,查询数据库中的详细航线信息:
+从搜索结果中提取机场代码,并查询数据库获取详细航线信息:
```python
-# Extracting airport codes from the metadata
+# 从元信息中提取机场代码
airport_codes = [review.metadata["airport_code"] for review in reviews]
-# Executing a query to get the airport details
+# 执行查询获取机场详情
search_query = "SELECT * FROM airplan_routes WHERE airport_code IN :codes"
params = {"codes": tuple(airport_codes)}
@@ -585,14 +585,14 @@ airport_details.get("result")
(2, 'LAX', 'AA', 'ORD', 'Direct LAX to ORD route.', datetime.timedelta(seconds=14400), 3, 'Airbus A320', Decimal('149.99'), 'None')]
```
-### 简化流程
+### 流程简化
-你也可以使用单个 SQL 查询来简化整个流程:
+你也可以通过单条 SQL 查询简化整个流程:
```python
search_query = f"""
SELECT
- VEC_Cosine_Distance(se.embedding, :query_vector) as distance,
+ VEC_COSINE_DISTANCE(se.embedding, :query_vector) as distance,
ar.*,
se.document as airport_review
FROM
@@ -618,7 +618,7 @@ airport_details.get("result")
### 清理数据
-最后,删除创建的表,清理资源:
+最后,通过删除创建的表来清理资源:
```python
vector_store.tidb_vector_client.execute("DROP TABLE airplan_routes")
@@ -630,7 +630,7 @@ vector_store.tidb_vector_client.execute("DROP TABLE airplan_routes")
{'success': True, 'result': 0, 'error': None}
```
-## 另请参阅
+## 相关文档
-- [向量数据类型](/vector-search-data-types.md)
-- [向量搜索索引](/vector-search-index.md)
\ No newline at end of file
+- [向量数据类型](/ai/reference/vector-search-data-types.md)
+- [向量搜索索引](/ai/reference/vector-search-index.md)
diff --git a/ai/integrations/vector-search-integrate-with-llamaindex.md b/ai/integrations/vector-search-integrate-with-llamaindex.md
new file mode 100644
index 000000000000..5b24c3276e0d
--- /dev/null
+++ b/ai/integrations/vector-search-integrate-with-llamaindex.md
@@ -0,0 +1,316 @@
+---
+title: 集成向量搜索与 LlamaIndex
+summary: 学习如何将 TiDB 向量搜索与 LlamaIndex 集成。
+aliases: ['/zh/tidb/stable/vector-search-integrate-with-llamaindex/','/zh/tidb/dev/vector-search-integrate-with-llamaindex/','/zh/tidbcloud/vector-search-integrate-with-llamaindex/']
+---
+
+# 集成向量搜索与 LlamaIndex
+
+本教程演示如何将 [TiDB 向量搜索](/ai/concepts/vector-search-overview.md) 与 [LlamaIndex](https://www.llamaindex.ai) 集成。
+
+> **注意:**
+>
+> - 向量搜索功能目前为 beta 版本,可能会在未提前通知的情况下发生变更。如果你发现了 bug,可以在 GitHub 上提交 [issue](https://github.com/pingcap/tidb/issues)。
+> - 向量搜索功能适用于 [TiDB 自托管](/overview.md)、[TiDB Cloud Starter](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#starter)、[TiDB Cloud Essential](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#essential) 和 [TiDB Cloud Dedicated](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#tidb-cloud-dedicated)。对于 TiDB 自托管和 TiDB Cloud Dedicated,TiDB 版本需为 v8.4.0 或更高(推荐 v8.5.0 或更高)。
+
+> **提示**
+>
+> 你可以在 Jupyter Notebook 中查看完整的 [示例代码](https://github.com/run-llama/llama_index/blob/main/docs/docs/examples/vector_stores/TiDBVector.ipynb),或直接在 [Colab](https://colab.research.google.com/github/run-llama/llama_index/blob/main/docs/docs/examples/vector_stores/TiDBVector.ipynb) 在线环境中运行。
+
+## 前置条件
+
+完成本教程,你需要:
+
+- 已安装 [Python 3.8 或更高版本](https://www.python.org/downloads/)。
+- 已安装 [Jupyter Notebook](https://jupyter.org/install)。
+- 已安装 [Git](https://git-scm.com/downloads)。
+- 一个 TiDB 集群。
+
+**如果你还没有 TiDB 集群,可以按如下方式创建:**
+
+- (推荐)参照 [创建 TiDB Cloud Starter 集群](/develop/dev-guide-build-cluster-in-cloud.md) 创建属于你自己的 TiDB Cloud 集群。
+- 参照 [部署本地测试 TiDB 集群](/quick-start-with-tidb.md#deploy-a-local-test-cluster) 或 [部署生产环境 TiDB 集群](/production-deployment-using-tiup.md) 创建本地集群。
+
+## 快速开始
+
+本节将提供分步指导,帮助你将 TiDB 向量搜索与 LlamaIndex 集成,实现语义搜索。
+
+### 步骤 1. 新建 Jupyter Notebook 文件
+
+在根目录下新建一个名为 `integrate_with_llamaindex.ipynb` 的 Jupyter Notebook 文件:
+
+```shell
+touch integrate_with_llamaindex.ipynb
+```
+
+### 步骤 2. 安装所需依赖
+
+在你的项目目录下,运行以下命令安装所需的依赖包:
+
+```shell
+pip install llama-index-vector-stores-tidbvector
+pip install llama-index
+```
+
+在 Jupyter Notebook 中打开 `integrate_with_llamaindex.ipynb` 文件,并添加以下代码以导入所需包:
+
+```python
+import textwrap
+
+from llama_index.core import SimpleDirectoryReader, StorageContext
+from llama_index.core import VectorStoreIndex
+from llama_index.vector_stores.tidbvector import TiDBVectorStore
+```
+
+### 步骤 3. 配置环境变量
+
+根据你选择的 TiDB 部署方式,配置环境变量。
+
+
+
+
+对于 TiDB Cloud Starter 集群,按以下步骤获取集群连接字符串并配置环境变量:
+
+1. 进入 [**Clusters**](https://tidbcloud.com/console/clusters) 页面,点击目标集群名称进入其概览页面。
+
+2. 点击右上角的 **Connect**,弹出连接对话框。
+
+3. 确认连接对话框中的配置与你的运行环境一致。
+
+ - **Connection Type** 设置为 `Public`。
+ - **Branch** 设置为 `main`。
+ - **Connect With** 设置为 `SQLAlchemy`。
+ - **Operating System** 与你的环境一致。
+
+4. 点击 **PyMySQL** 标签页,复制连接字符串。
+
+ > **提示:**
+ >
+ > 如果你还未设置密码,可点击 **Generate Password** 生成随机密码。
+
+5. 配置环境变量。
+
+ 本文档以 [OpenAI](https://platform.openai.com/docs/introduction) 作为嵌入模型提供方。在此步骤中,你需要提供上一步获取的连接字符串和你的 [OpenAI API key](https://platform.openai.com/docs/quickstart/step-2-set-up-your-api-key)。
+
+ 运行以下代码配置环境变量。你将被提示输入连接字符串和 OpenAI API key:
+
+ ```python
+ # 使用 getpass 在终端安全地输入环境变量。
+ import getpass
+ import os
+
+ # 从 TiDB Cloud 控制台复制你的连接字符串。
+ # 连接字符串格式:"mysql+pymysql://
:@:4000/?ssl_ca=/etc/ssl/cert.pem&ssl_verify_cert=true&ssl_verify_identity=true"
+ tidb_connection_string = getpass.getpass("TiDB Connection String:")
+ os.environ["OPENAI_API_KEY"] = getpass.getpass("OpenAI API Key:")
+ ```
+
+
+
+
+本文档以 [OpenAI](https://platform.openai.com/docs/introduction) 作为嵌入模型提供方。在此步骤中,你需要提供 TiDB 集群的连接字符串和你的 [OpenAI API key](https://platform.openai.com/docs/quickstart/step-2-set-up-your-api-key)。
+
+运行以下代码配置环境变量。你将被提示输入连接字符串和 OpenAI API key:
+
+```python
+# 使用 getpass 在终端安全地输入环境变量。
+import getpass
+import os
+
+# 连接字符串格式:"mysql+pymysql://
:@:4000/?ssl_ca=/etc/ssl/cert.pem&ssl_verify_cert=true&ssl_verify_identity=true"
+tidb_connection_string = getpass.getpass("TiDB Connection String:")
+os.environ["OPENAI_API_KEY"] = getpass.getpass("OpenAI API Key:")
+```
+
+以 macOS 为例,集群连接字符串如下:
+
+```dotenv
+TIDB_DATABASE_URL="mysql+pymysql://:@:/"
+# 例如:TIDB_DATABASE_URL="mysql+pymysql://root@127.0.0.1:4000/test"
+```
+
+你需要根据自己的 TiDB 集群修改连接字符串中的参数。如果你在本地运行 TiDB,`` 默认为 `127.0.0.1`。初始 `` 为空,因此首次启动集群时可以省略该字段。
+
+各参数说明如下:
+
+- ``:连接 TiDB 集群的用户名。
+- ``:连接 TiDB 集群的密码。
+- ``:TiDB 集群的主机。
+- ``:TiDB 集群的端口。
+- ``:你要连接的数据库名称。
+
+
+
+
+
+### 步骤 4. 加载示例文档
+
+#### 步骤 4.1 下载示例文档
+
+在你的项目目录下,新建 `data/paul_graham/` 目录,并从 [run-llama/llama_index](https://github.com/run-llama/llama_index) GitHub 仓库下载示例文档 [`paul_graham_essay.txt`](https://github.com/run-llama/llama_index/blob/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt)。
+
+```shell
+!mkdir -p 'data/paul_graham/'
+!wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/docs/examples/data/paul_graham/paul_graham_essay.txt' -O 'data/paul_graham/paul_graham_essay.txt'
+```
+
+#### 步骤 4.2 加载文档
+
+使用 `SimpleDirectoryReader` 类从 `data/paul_graham/paul_graham_essay.txt` 加载示例文档。
+
+```python
+documents = SimpleDirectoryReader("./data/paul_graham").load_data()
+print("Document ID:", documents[0].doc_id)
+
+for index, document in enumerate(documents):
+ document.metadata = {"book": "paul_graham"}
+```
+
+### 步骤 5. 嵌入并存储文档向量
+
+#### 步骤 5.1 初始化 TiDB 向量存储
+
+以下代码将在 TiDB 中创建一个名为 `paul_graham_test` 的表,并针对向量搜索进行了优化。
+
+```python
+tidbvec = TiDBVectorStore(
+ connection_string=tidb_connection_string,
+ table_name="paul_graham_test",
+ distance_strategy="cosine",
+ vector_dimension=1536,
+ drop_existing_table=False,
+)
+```
+
+执行成功后,你可以在 TiDB 数据库中直接查看和访问 `paul_graham_test` 表。
+
+#### 步骤 5.2 生成并存储嵌入向量
+
+以下代码将解析文档、生成嵌入向量,并将其存储到 TiDB 向量存储中。
+
+```python
+storage_context = StorageContext.from_defaults(vector_store=tidbvec)
+index = VectorStoreIndex.from_documents(
+ documents, storage_context=storage_context, show_progress=True
+)
+```
+
+预期输出如下:
+
+```plain
+Parsing nodes: 100%|██████████| 1/1 [00:00<00:00, 8.76it/s]
+Generating embeddings: 100%|██████████| 21/21 [00:02<00:00, 8.22it/s]
+```
+
+### 步骤 6. 执行向量搜索
+
+以下代码基于 TiDB 向量存储创建查询引擎,并执行语义相似度搜索。
+
+```python
+query_engine = index.as_query_engine()
+response = query_engine.query("What did the author do?")
+print(textwrap.fill(str(response), 100))
+```
+
+> **注意**
+>
+> `TiDBVectorStore` 仅支持 [`default`](https://docs.llamaindex.ai/en/stable/api_reference/storage/vector_store/?h=vectorstorequerymode#llama_index.core.vector_stores.types.VectorStoreQueryMode) 查询模式。
+
+预期输出如下:
+
+```plain
+The author worked on writing, programming, building microcomputers, giving talks at conferences,
+publishing essays online, developing spam filters, painting, hosting dinner parties, and purchasing
+a building for office use.
+```
+
+### 步骤 7. 使用元信息过滤器进行搜索
+
+为了进一步优化搜索结果,你可以使用元信息过滤器,仅搜索符合过滤条件的最近邻结果。
+
+#### 使用 `book != "paul_graham"` 过滤器查询
+
+以下示例将排除 `metadata` 字段 `book` 为 `"paul_graham"` 的结果:
+
+```python
+from llama_index.core.vector_stores.types import (
+ MetadataFilter,
+ MetadataFilters,
+)
+
+query_engine = index.as_query_engine(
+ filters=MetadataFilters(
+ filters=[
+ MetadataFilter(key="book", value="paul_graham", operator="!="),
+ ]
+ ),
+ similarity_top_k=2,
+)
+response = query_engine.query("What did the author learn?")
+print(textwrap.fill(str(response), 100))
+```
+
+预期输出如下:
+
+```plain
+Empty Response
+```
+
+#### 使用 `book == "paul_graham"` 过滤器查询
+
+以下示例仅返回 `metadata` 字段 `book` 为 `"paul_graham"` 的文档:
+
+```python
+from llama_index.core.vector_stores.types import (
+ MetadataFilter,
+ MetadataFilters,
+)
+
+query_engine = index.as_query_engine(
+ filters=MetadataFilters(
+ filters=[
+ MetadataFilter(key="book", value="paul_graham", operator="=="),
+ ]
+ ),
+ similarity_top_k=2,
+)
+response = query_engine.query("What did the author learn?")
+print(textwrap.fill(str(response), 100))
+```
+
+预期输出如下:
+
+```plain
+The author learned programming on an IBM 1401 using an early version of Fortran in 9th grade, then
+later transitioned to working with microcomputers like the TRS-80 and Apple II. Additionally, the
+author studied philosophy in college but found it unfulfilling, leading to a switch to studying AI.
+Later on, the author attended art school in both the US and Italy, where they observed a lack of
+substantial teaching in the painting department.
+```
+
+### 步骤 8. 删除文档
+
+从索引中删除第一个文档:
+
+```python
+tidbvec.delete(documents[0].doc_id)
+```
+
+检查文档是否已被删除:
+
+```python
+query_engine = index.as_query_engine()
+response = query_engine.query("What did the author learn?")
+print(textwrap.fill(str(response), 100))
+```
+
+预期输出如下:
+
+```plain
+Empty Response
+```
+
+## 另请参阅
+
+- [向量数据类型](/ai/reference/vector-search-data-types.md)
+- [向量搜索索引](/ai/reference/vector-search-index.md)
diff --git a/ai/integrations/vector-search-integrate-with-peewee.md b/ai/integrations/vector-search-integrate-with-peewee.md
new file mode 100644
index 000000000000..3c43d6ec5f87
--- /dev/null
+++ b/ai/integrations/vector-search-integrate-with-peewee.md
@@ -0,0 +1,252 @@
+---
+title: 集成 TiDB 向量搜索与 peewee
+summary: 学习如何将 TiDB 向量搜索与 peewee 集成,以存储嵌入向量并执行语义搜索。
+aliases: ['/zh/tidb/stable/vector-search-integrate-with-peewee/','/zh/tidb/dev/vector-search-integrate-with-peewee/','/zh/tidbcloud/vector-search-integrate-with-peewee/']
+---
+
+# 集成 TiDB 向量搜索与 peewee
+
+本教程将指导你如何使用 [peewee](https://docs.peewee-orm.com/) 与 [TiDB 向量搜索](/ai/concepts/vector-search-overview.md) 进行交互,存储嵌入向量,并执行向量搜索查询。
+
+> **注意:**
+>
+> - 向量搜索功能目前为 beta 版本,可能会在未提前通知的情况下发生变更。如果你发现了 bug,可以在 GitHub 上提交 [issue](https://github.com/pingcap/tidb/issues)。
+> - 向量搜索功能适用于 [TiDB 自托管](/overview.md)、[TiDB Cloud Starter](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#starter)、[TiDB Cloud Essential](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#essential) 和 [TiDB Cloud Dedicated](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#tidb-cloud-dedicated)。对于 TiDB 自托管和 TiDB Cloud Dedicated,TiDB 版本需为 v8.4.0 或更高(推荐 v8.5.0 或更高)。
+
+## 前置条件
+
+完成本教程,你需要:
+
+- 已安装 [Python 3.8 或更高版本](https://www.python.org/downloads/)。
+- 已安装 [Git](https://git-scm.com/downloads)。
+- 一个 TiDB 集群。
+
+**如果你还没有 TiDB 集群,可以按如下方式创建:**
+
+- (推荐)参考 [创建 TiDB Cloud Starter 集群](/develop/dev-guide-build-cluster-in-cloud.md) 创建属于你自己的 TiDB Cloud 集群。
+- 参考 [部署本地测试 TiDB 集群](/quick-start-with-tidb.md#deploy-a-local-test-cluster) 或 [部署生产环境 TiDB 集群](/production-deployment-using-tiup.md) 创建本地集群。
+
+## 运行示例应用
+
+你可以按照以下步骤快速学习如何将 TiDB 向量搜索与 peewee 集成。
+
+### 第 1 步:克隆仓库
+
+将 [`tidb-vector-python`](https://github.com/pingcap/tidb-vector-python) 仓库克隆到本地:
+
+```shell
+git clone https://github.com/pingcap/tidb-vector-python.git
+```
+
+### 第 2 步:创建虚拟环境
+
+为你的项目创建虚拟环境:
+
+```bash
+cd tidb-vector-python/examples/orm-peewee-quickstart
+python3 -m venv .venv
+source .venv/bin/activate
+```
+
+### 第 3 步:安装所需依赖
+
+为示例项目安装所需依赖:
+
+```bash
+pip install -r requirements.txt
+```
+
+或者,你也可以为你的项目单独安装以下包:
+
+```bash
+pip install peewee pymysql python-dotenv tidb-vector
+```
+
+### 第 4 步:配置环境变量
+
+根据你选择的 TiDB 部署方式配置环境变量。
+
+
+
+
+对于 TiDB Cloud Starter 集群,按如下步骤获取集群连接字符串并配置环境变量:
+
+1. 进入 [**Clusters**](https://tidbcloud.com/console/clusters) 页面,点击目标集群名称进入其概览页面。
+
+2. 点击右上角的 **Connect**,弹出连接对话框。
+
+3. 确保连接对话框中的配置与你的运行环境一致。
+
+ - **Connection Type** 设置为 `Public`。
+ - **Branch** 设置为 `main`。
+ - **Connect With** 设置为 `General`。
+ - **Operating System** 与你的环境一致。
+
+ > **提示:**
+ >
+ > 如果你的程序运行在 Windows Subsystem for Linux (WSL) 中,请切换到对应的 Linux 发行版。
+
+4. 从连接对话框中复制连接参数。
+
+ > **提示:**
+ >
+ > 如果你还未设置密码,请点击 **Generate Password** 生成随机密码。
+
+5. 在 Python 项目的根目录下创建 `.env` 文件,并将连接参数粘贴到对应的环境变量中。
+
+ - `TIDB_HOST`:TiDB 集群的主机。
+ - `TIDB_PORT`:TiDB 集群的端口。
+ - `TIDB_USERNAME`:连接 TiDB 集群的用户名。
+ - `TIDB_PASSWORD`:连接 TiDB 集群的密码。
+ - `TIDB_DATABASE`:要连接的数据库名称。
+ - `TIDB_CA_PATH`:根证书文件的路径。
+
+ 以下为 macOS 示例:
+
+ ```dotenv
+ TIDB_HOST=gateway01.****.prod.aws.tidbcloud.com
+ TIDB_PORT=4000
+ TIDB_USERNAME=********.root
+ TIDB_PASSWORD=********
+ TIDB_DATABASE=test
+ TIDB_CA_PATH=/etc/ssl/cert.pem
+ ```
+
+
+
+
+对于自托管的 TiDB 集群,在 Python 项目的根目录下创建 `.env` 文件。将以下内容复制到 `.env` 文件中,并根据你的 TiDB 集群连接参数修改环境变量的值:
+
+```dotenv
+TIDB_HOST=127.0.0.1
+TIDB_PORT=4000
+TIDB_USERNAME=root
+TIDB_PASSWORD=
+TIDB_DATABASE=test
+```
+
+如果你在本地运行 TiDB,`TIDB_HOST` 默认为 `127.0.0.1`。初始 `TIDB_PASSWORD` 为空,因此如果是首次启动集群,可以省略该字段。
+
+各参数说明如下:
+
+- `TIDB_HOST`:TiDB 集群的主机。
+- `TIDB_PORT`:TiDB 集群的端口。
+- `TIDB_USERNAME`:连接 TiDB 集群的用户名。
+- `TIDB_PASSWORD`:连接 TiDB 集群的密码。
+- `TIDB_DATABASE`:你要连接的数据库名称。
+
+
+
+
+
+### 第 5 步:运行示例
+
+```bash
+python peewee-quickstart.py
+```
+
+示例输出:
+
+```text
+Get 3-nearest neighbor documents:
+ - distance: 0.00853986601633272
+ document: fish
+ - distance: 0.12712843905603044
+ document: dog
+ - distance: 0.7327387580875756
+ document: tree
+Get documents within a certain distance:
+ - distance: 0.00853986601633272
+ document: fish
+ - distance: 0.12712843905603044
+ document: dog
+```
+
+## 示例代码片段
+
+你可以参考以下示例代码片段开发你的应用。
+
+### 创建向量表
+
+#### 连接 TiDB 集群
+
+```python
+import os
+import dotenv
+
+from peewee import Model, MySQLDatabase, SQL, TextField
+from tidb_vector.peewee import VectorField
+
+dotenv.load_dotenv()
+
+# Using `pymysql` as the driver.
+connect_kwargs = {
+ 'ssl_verify_cert': True,
+ 'ssl_verify_identity': True,
+}
+
+# Using `mysqlclient` as the driver.
+# connect_kwargs = {
+# 'ssl_mode': 'VERIFY_IDENTITY',
+# 'ssl': {
+# # Root certificate default path
+# # https://docs.pingcap.com/tidbcloud/secure-connections-to-serverless-clusters/#root-certificate-default-path
+# 'ca': os.environ.get('TIDB_CA_PATH', '/path/to/ca.pem'),
+# },
+# }
+
+db = MySQLDatabase(
+ database=os.environ.get('TIDB_DATABASE', 'test'),
+ user=os.environ.get('TIDB_USERNAME', 'root'),
+ password=os.environ.get('TIDB_PASSWORD', ''),
+ host=os.environ.get('TIDB_HOST', 'localhost'),
+ port=int(os.environ.get('TIDB_PORT', '4000')),
+ **connect_kwargs,
+)
+```
+
+#### 定义向量列
+
+创建一个包含名为 `peewee_demo_documents` 的表,并存储 3 维向量。
+
+```python
+class Document(Model):
+ class Meta:
+ database = db
+ table_name = 'peewee_demo_documents'
+
+ content = TextField()
+ embedding = VectorField(3)
+```
+
+### 存储带嵌入向量的文档
+
+```python
+Document.create(content='dog', embedding=[1, 2, 1])
+Document.create(content='fish', embedding=[1, 2, 4])
+Document.create(content='tree', embedding=[1, 0, 0])
+```
+
+### 搜索最近邻文档
+
+基于余弦距离函数,搜索与查询向量 `[1, 2, 3]` 语义最接近的前 3 个文档。
+
+```python
+distance = Document.embedding.cosine_distance([1, 2, 3]).alias('distance')
+results = Document.select(Document, distance).order_by(distance).limit(3)
+```
+
+### 搜索距离在指定范围内的文档
+
+搜索与查询向量 `[1, 2, 3]` 的余弦距离小于 0.2 的文档。
+
+```python
+distance_expression = Document.embedding.cosine_distance([1, 2, 3])
+distance = distance_expression.alias('distance')
+results = Document.select(Document, distance).where(distance_expression < 0.2).order_by(distance).limit(3)
+```
+
+## 另请参阅
+
+- [向量数据类型](/ai/reference/vector-search-data-types.md)
+- [向量搜索索引](/ai/reference/vector-search-index.md)
diff --git a/ai/integrations/vector-search-integrate-with-sqlalchemy.md b/ai/integrations/vector-search-integrate-with-sqlalchemy.md
new file mode 100644
index 000000000000..2d87de409c6e
--- /dev/null
+++ b/ai/integrations/vector-search-integrate-with-sqlalchemy.md
@@ -0,0 +1,223 @@
+---
+title: 集成 TiDB 向量搜索与 SQLAlchemy
+summary: 学习如何将 TiDB 向量搜索与 SQLAlchemy 集成,以存储嵌入向量并执行语义搜索。
+aliases: ['/zh/tidb/stable/vector-search-integrate-with-sqlalchemy/','/zh/tidb/dev/vector-search-integrate-with-sqlalchemy/','/zh/tidbcloud/vector-search-integrate-with-sqlalchemy/']
+---
+
+# 集成 TiDB 向量搜索与 SQLAlchemy
+
+本教程将指导你如何使用 [SQLAlchemy](https://www.sqlalchemy.org/) 与 [TiDB 向量搜索](/ai/concepts/vector-search-overview.md) 进行交互,存储嵌入向量,并执行向量搜索查询。
+
+> **注意:**
+>
+> - 向量搜索功能目前为 beta 版本,可能会在无提前通知的情况下发生变更。如果你发现了 bug,可以在 GitHub 上提交 [issue](https://github.com/pingcap/tidb/issues)。
+> - 向量搜索功能适用于 [TiDB 自托管](/overview.md)、[TiDB Cloud Starter](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#starter)、[TiDB Cloud Essential](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#essential) 和 [TiDB Cloud Dedicated](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#tidb-cloud-dedicated)。对于 TiDB 自托管和 TiDB Cloud Dedicated,TiDB 版本需为 v8.4.0 或更高(推荐 v8.5.0 及以上)。
+
+## 前置条件
+
+完成本教程,你需要:
+
+- 已安装 [Python 3.8 或更高版本](https://www.python.org/downloads/)。
+- 已安装 [Git](https://git-scm.com/downloads)。
+- 一个 TiDB 集群。
+
+**如果你还没有 TiDB 集群,可以按如下方式创建:**
+
+- (推荐)参考 [创建 TiDB Cloud Starter 集群](/develop/dev-guide-build-cluster-in-cloud.md) 创建属于你自己的 TiDB Cloud 集群。
+- 参考 [部署本地测试 TiDB 集群](/quick-start-with-tidb.md#deploy-a-local-test-cluster) 或 [部署生产环境 TiDB 集群](/production-deployment-using-tiup.md) 创建本地集群。
+
+## 运行示例应用
+
+你可以按照以下步骤快速学习如何将 TiDB 向量搜索与 SQLAlchemy 集成。
+
+### 第 1 步:克隆仓库
+
+将 `tidb-vector-python` 仓库克隆到本地:
+
+```shell
+git clone https://github.com/pingcap/tidb-vector-python.git
+```
+
+### 第 2 步:创建虚拟环境
+
+为你的项目创建一个虚拟环境:
+
+```bash
+cd tidb-vector-python/examples/orm-sqlalchemy-quickstart
+python3 -m venv .venv
+source .venv/bin/activate
+```
+
+### 第 3 步:安装所需依赖
+
+为示例项目安装所需依赖:
+
+```bash
+pip install -r requirements.txt
+```
+
+或者,你也可以为你的项目单独安装以下包:
+
+```bash
+pip install pymysql python-dotenv sqlalchemy tidb-vector
+```
+
+### 第 4 步:配置环境变量
+
+根据你选择的 TiDB 部署方式配置环境变量。
+
+
+
+
+对于 TiDB Cloud Starter 集群,按以下步骤获取集群连接字符串并配置环境变量:
+
+1. 进入 [**Clusters**](https://tidbcloud.com/console/clusters) 页面,点击目标集群名称进入集群概览页。
+
+2. 点击右上角的 **Connect**,弹出连接对话框。
+
+3. 确认连接对话框中的配置与你的环境一致。
+
+ - **Connection Type** 设置为 `Public`。
+ - **Branch** 设置为 `main`。
+ - **Connect With** 设置为 `SQLAlchemy`。
+ - **Operating System** 与你的环境一致。
+
+ > **提示:**
+ >
+ > 如果你的程序运行在 Windows Subsystem for Linux (WSL) 中,请切换到对应的 Linux 发行版。
+
+4. 点击 **PyMySQL** 标签页并复制连接字符串。
+
+ > **提示:**
+ >
+ > 如果你还未设置密码,可点击 **Generate Password** 生成随机密码。
+
+5. 在你的 Python 项目根目录下创建 `.env` 文件,并将连接字符串粘贴进去。
+
+ 以下为 macOS 示例:
+
+ ```dotenv
+ TIDB_DATABASE_URL="mysql+pymysql://
.root:@gateway01..prod.aws.tidbcloud.com:4000/test?ssl_ca=/etc/ssl/cert.pem&ssl_verify_cert=true&ssl_verify_identity=true"
+ ```
+
+
+
+
+对于自托管的 TiDB 集群,在你的 Python 项目根目录下创建 `.env` 文件。将以下内容复制到 `.env` 文件中,并根据你的 TiDB 集群连接参数修改环境变量的值:
+
+```dotenv
+TIDB_DATABASE_URL="mysql+pymysql://
:@:/"
+# 例如:TIDB_DATABASE_URL="mysql+pymysql://root@127.0.0.1:4000/test"
+```
+
+如果你在本地运行 TiDB,`` 默认为 `127.0.0.1`。初始 `` 为空,因此如果是首次启动集群,可以省略该字段。
+
+各参数说明如下:
+
+- ``:连接 TiDB 集群的用户名。
+- ``:连接 TiDB 集群的密码。
+- ``:TiDB 集群的主机。
+- ``:TiDB 集群的端口。
+- ``:你要连接的数据库名称。
+
+
+
+
+
+### 第 5 步:运行示例
+
+```bash
+python sqlalchemy-quickstart.py
+```
+
+示例输出:
+
+```text
+Get 3-nearest neighbor documents:
+ - distance: 0.00853986601633272
+ document: fish
+ - distance: 0.12712843905603044
+ document: dog
+ - distance: 0.7327387580875756
+ document: tree
+Get documents within a certain distance:
+ - distance: 0.00853986601633272
+ document: fish
+ - distance: 0.12712843905603044
+ document: dog
+```
+
+## 示例代码片段
+
+你可以参考以下示例代码片段开发你的应用。
+
+### 创建向量表
+
+#### 连接 TiDB 集群
+
+```python
+import os
+import dotenv
+
+from sqlalchemy import Column, Integer, create_engine, Text
+from sqlalchemy.orm import declarative_base, Session
+from tidb_vector.sqlalchemy import VectorType
+
+dotenv.load_dotenv()
+
+tidb_connection_string = os.environ['TIDB_DATABASE_URL']
+engine = create_engine(tidb_connection_string)
+```
+
+#### 定义向量列
+
+创建一个包含名为 `embedding` 的 3 维向量列的表。
+
+```python
+Base = declarative_base()
+
+class Document(Base):
+ __tablename__ = 'sqlalchemy_demo_documents'
+ id = Column(Integer, primary_key=True)
+ content = Column(Text)
+ embedding = Column(VectorType(3))
+```
+
+### 存储带嵌入向量的文档
+
+```python
+with Session(engine) as session:
+ session.add(Document(content="dog", embedding=[1, 2, 1]))
+ session.add(Document(content="fish", embedding=[1, 2, 4]))
+ session.add(Document(content="tree", embedding=[1, 0, 0]))
+ session.commit()
+```
+
+### 搜索最近邻文档
+
+基于余弦距离函数,搜索与查询向量 `[1, 2, 3]` 语义最接近的前 3 个文档。
+
+```python
+with Session(engine) as session:
+ distance = Document.embedding.cosine_distance([1, 2, 3]).label('distance')
+ results = session.query(
+ Document, distance
+ ).order_by(distance).limit(3).all()
+```
+
+### 搜索距离在指定范围内的文档
+
+搜索与查询向量 `[1, 2, 3]` 余弦距离小于 0.2 的文档。
+
+```python
+with Session(engine) as session:
+ distance = Document.embedding.cosine_distance([1, 2, 3]).label('distance')
+ results = session.query(
+ Document, distance
+ ).filter(distance < 0.2).order_by(distance).limit(3).all()
+```
+
+## 另请参阅
+
+- [向量数据类型](/ai/reference/vector-search-data-types.md)
+- [向量搜索索引](/ai/reference/vector-search-index.md)
diff --git a/ai/integrations/vector-search-integration-overview.md b/ai/integrations/vector-search-integration-overview.md
new file mode 100644
index 000000000000..38547e5b9b77
--- /dev/null
+++ b/ai/integrations/vector-search-integration-overview.md
@@ -0,0 +1,50 @@
+---
+title: 向量搜索集成概览
+summary: TiDB 向量搜索集成的概览,包括支持的 AI 框架、嵌入模型和 ORM 库。
+aliases: ['/zh/tidb/stable/vector-search-integration-overview/','/zh/tidb/dev/vector-search-integration-overview/','/zh/tidbcloud/vector-search-integration-overview/']
+---
+
+# 向量搜索集成概览
+
+本文档概述了 TiDB 向量搜索的集成方式,包括支持的 AI 框架、嵌入模型和对象关系映射(ORM)库。
+
+> **注意:**
+>
+> - 向量搜索功能目前为 beta 版本,可能会在未提前通知的情况下发生变更。如果你发现了 bug,可以在 GitHub 上提交 [issue](https://github.com/pingcap/tidb/issues)。
+> - 向量搜索功能适用于 [TiDB 自托管](/overview.md)、[TiDB Cloud Starter](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#starter)、[TiDB Cloud Essential](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#essential) 和 [TiDB Cloud Dedicated](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#tidb-cloud-dedicated)。对于 TiDB 自托管和 TiDB Cloud Dedicated,TiDB 版本需为 v8.4.0 或更高(推荐 v8.5.0 或更高)。
+
+## AI 框架
+
+TiDB 官方支持以下 AI 框架,帮助你轻松将基于这些框架开发的 AI 应用与 TiDB 向量搜索集成。
+
+| AI 框架 | 教程 |
+|--------------|----------------------------------------------------------------------------------------------|
+| LangChain | [与 LangChain 集成向量搜索](/ai/integrations/vector-search-integrate-with-langchain.md) |
+| LlamaIndex | [与 LlamaIndex 集成向量搜索](/ai/integrations/vector-search-integrate-with-llamaindex.md) |
+
+你还可以将 TiDB 用于 AI 应用的文档存储、知识图谱存储等多种场景。
+
+## 嵌入模型与服务
+
+TiDB 向量搜索支持存储最多 16383 维的向量,能够满足大多数嵌入模型的需求。
+
+你可以使用自部署的开源嵌入模型,或第三方嵌入 API 生成向量。
+
+下表列出了一些主流嵌入服务提供商及其对应的集成教程。
+
+| 嵌入服务提供商 | 教程 |
+|----------------|-------------------------------------------------------------------------------------------------------------|
+| Jina AI | [与 Jina AI Embeddings API 集成向量搜索](/ai/integrations/vector-search-integrate-with-jinaai-embedding.md) |
+
+## 对象关系映射(ORM)库
+
+你可以将 TiDB 向量搜索与 ORM 库集成,以便与 TiDB 数据库进行交互。
+
+下表列出了支持的 ORM 库及其对应的集成教程:
+
+| 语言 | ORM/客户端 | 安装说明 | 教程 |
+|----------|--------------------|-----------------------------------|----------|
+| Python | TiDB Vector Client | `pip install tidb-vector[client]` | [使用 Python 开始向量搜索](/ai/quickstart-via-python.md) |
+| Python | SQLAlchemy | `pip install tidb-vector` | [集成 TiDB 向量搜索与 SQLAlchemy](/ai/integrations/vector-search-integrate-with-sqlalchemy.md)
+| Python | peewee | `pip install tidb-vector` | [集成 TiDB 向量搜索与 peewee](/ai/integrations/vector-search-integrate-with-peewee.md) |
+| Python | Django | `pip install django-tidb[vector]` | [将 TiDB 向量搜索集成到 Django ORM](/ai/integrations/vector-search-integrate-with-django-orm.md)
\ No newline at end of file
diff --git a/ai/quickstart-via-python.md b/ai/quickstart-via-python.md
new file mode 100644
index 000000000000..25903f6ead98
--- /dev/null
+++ b/ai/quickstart-via-python.md
@@ -0,0 +1,245 @@
+---
+title: 使用 Python 快速上手 TiDB + AI
+summary: 学习如何使用 Python SDK 在 TiDB 中开始向量搜索。
+aliases: ['/zh/tidb/stable/vector-search-get-started-using-python/','/zh/tidb/dev/vector-search-get-started-using-python/','/zh/tidbcloud/vector-search-get-started-using-python/']
+---
+
+# 使用 Python 快速上手 TiDB + AI
+
+本文档演示了如何使用 Python SDK 在 TiDB 中开始 [向量搜索](/ai/concepts/vector-search-overview.md)。跟随本文中的步骤,你将构建你的第一个基于 TiDB 的 AI 应用。
+
+通过学习本教程,你将掌握:
+
+- 使用 TiDB Python SDK 连接 TiDB。
+- 利用主流嵌入模型生成文本嵌入向量。
+- 将向量存储到 TiDB 表中。
+- 使用向量相似度进行语义搜索。
+
+> **注意:**
+>
+> - 向量搜索功能目前为 beta 版本,可能会在未提前通知的情况下发生变更。如果你发现了 bug,可以在 GitHub 上提交 [issue](https://github.com/pingcap/tidb/issues)。
+> - 向量搜索功能适用于 [TiDB 自托管](/overview.md)、[TiDB Cloud Starter](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#starter)、[TiDB Cloud Essential](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#essential) 和 [TiDB Cloud Dedicated](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#tidb-cloud-dedicated)。对于 TiDB 自托管和 TiDB Cloud Dedicated,TiDB 版本需为 v8.4.0 或更高(推荐 v8.5.0 及以上)。
+
+## 前置条件
+
+- 访问 [tidbcloud.com](https://tidbcloud.com/) 免费创建一个 TiDB Cloud Starter 集群,或使用 [tiup playground](https://docs.pingcap.com/tidb/stable/quick-start-with-tidb/#deploy-a-local-test-cluster) 在本地部署一个 TiDB 集群进行测试。
+
+## 安装
+
+[pytidb](https://github.com/pingcap/pytidb) 是官方的 TiDB Python SDK,旨在帮助开发者高效构建 AI 应用。
+
+安装 Python SDK,请运行以下命令:
+
+```bash
+pip install pytidb
+```
+
+如需使用内置嵌入 function,可安装 `models` 扩展(可选):
+
+```bash
+pip install "pytidb[models]"
+```
+
+## 连接数据库
+
+
+
+
+你可以在 [TiDB Cloud 控制台](https://tidbcloud.com/clusters) 获取这些连接参数:
+
+1. 进入 [Clusters 页面](https://tidbcloud.com/clusters),点击目标集群名称进入其概览页面。
+2. 点击右上角的 **Connect**。此时会弹出连接对话框,显示连接参数。
+
+例如,连接参数如下所示:
+
+```text
+HOST: gateway01.us-east-1.prod.shared.aws.tidbcloud.com
+PORT: 4000
+USERNAME: 4EfqPF23YKBxaQb.root
+PASSWORD: abcd1234
+DATABASE: test
+CA: /etc/ssl/cert.pem
+```
+
+对应的 Python 代码如下,用于连接 TiDB Cloud Starter 集群:
+
+```python
+from pytidb import TiDBClient
+
+client = TiDBClient.connect(
+ host="gateway01.us-east-1.prod.shared.aws.tidbcloud.com",
+ port=4000,
+ username="4EfqPF23YKBxaQb.root",
+ password="abcd1234",
+ database="test",
+)
+```
+
+> **注意:**
+>
+> 上述示例仅用于演示。你需要使用你自己的参数,并妥善保管。
+
+
+
+
+以下是连接 TiDB 自托管的基本示例:
+
+```python
+from pytidb import TiDBClient
+
+client = TiDBClient.connect(
+ host="localhost",
+ port=4000,
+ username="root",
+ password="",
+ database="test",
+ ensure_db=True,
+)
+```
+
+> **注意:**
+>
+> 请根据你的实际部署情况 update 连接参数。
+
+
+
+
+连接成功后,你可以使用 `client` 对象进行表操作、数据查询等。
+
+## 创建嵌入 function
+
+在使用 [嵌入模型](/ai/concepts/vector-search-overview.md#embedding-model) 时,你可以利用嵌入 function 在插入和查询阶段自动将数据向量化。该功能原生支持 OpenAI、Jina AI、Hugging Face、Sentence Transformers 等主流嵌入模型。
+
+
+
+
+前往 [OpenAI 平台](https://platform.openai.com/api-keys) 创建你的 API key 用于嵌入。
+
+```python
+from pytidb.embeddings import EmbeddingFunction
+
+text_embed = EmbeddingFunction(
+ model_name="openai/text-embedding-3-small",
+ api_key="",
+)
+```
+
+
+
+
+前往 [Jina AI](https://jina.ai/embeddings/) 创建你的 API key 用于嵌入。
+
+```python
+from pytidb.embeddings import EmbeddingFunction
+
+text_embed = EmbeddingFunction(
+ model_name="jina/jina-embeddings-v3",
+ api_key="",
+)
+```
+
+
+
+
+## 创建表
+
+例如,创建一个名为 `chunks` 的表,包含以下字段:
+
+- `id` (int):chunk 的 ID。
+- `text` (text):chunk 的文本内容。
+- `text_vec` (vector):文本的向量嵌入。
+- `user_id` (int):创建该 chunk 的用户 ID。
+
+```python hl_lines="6"
+from pytidb.schema import TableModel, Field, VectorField
+
+class Chunk(TableModel):
+ id: int | None = Field(default=None, primary_key=True)
+ text: str = Field()
+ text_vec: list[float] = text_embed.VectorField(source_field="text")
+ user_id: int = Field()
+
+table = client.create_table(schema=Chunk, if_exists="overwrite")
+```
+
+创建完成后,你可以使用 `table` 对象插入数据、搜索数据等。
+
+## 插入数据
+
+现在让我们向表中添加一些示例数据。
+
+```python
+table.bulk_insert([
+ # 👇 文本会被 Auto Embedding 并填充到 `text_vec` 字段中。
+ Chunk(text="PyTiDB is a Python library for developers to connect to TiDB.", user_id=2),
+ Chunk(text="LlamaIndex is a framework for building AI applications.", user_id=2),
+ Chunk(text="OpenAI is a company and platform that provides AI models service and tools.", user_id=3),
+])
+```
+
+## 搜索最近邻
+
+要搜索给定 query 的最近邻,可以使用 `table.search()` method。该 method 默认执行 [向量搜索](/ai/guides/vector-search.md)。
+
+```python
+table.search(
+ # 👇 直接传入 query 文本,会 Auto Embedding 为 query 向量。
+ "A library for my artificial intelligence software"
+)
+.limit(3).to_list()
+```
+
+在本例中,向量搜索会将 query 向量与 `chunks` 表中 `text_vec` 字段存储的向量进行比较,并根据相似度得分返回最相关的前 3 条结果。
+
+`_distance` 越小,表示两个向量越相似。
+
+```json title="期望输出"
+[
+ {
+ 'id': 2,
+ 'text': 'LlamaIndex is a framework for building AI applications.',
+ 'text_vec': [...],
+ 'user_id': 2,
+ '_distance': 0.5719928358786761,
+ '_score': 0.4280071641213239
+ },
+ {
+ 'id': 3,
+ 'text': 'OpenAI is a company and platform that provides AI models service and tools.',
+ 'text_vec': [...],
+ 'user_id': 3,
+ '_distance': 0.603133726213383,
+ '_score': 0.396866273786617
+ },
+ {
+ 'id': 1,
+ 'text': 'PyTiDB is a Python library for developers to connect to TiDB.',
+ 'text_vec': [...],
+ 'user_id': 2,
+ '_distance': 0.6202191842385758,
+ '_score': 0.3797808157614242
+ }
+]
+```
+
+## 删除数据
+
+要从表中删除指定行,可以使用 `table.delete()` method:
+
+```python
+table.delete({
+ "id": 1
+})
+```
+
+## 删除表
+
+当你不再需要某个表时,可以使用 `client.drop_table()` method 删除:
+
+```python
+client.drop_table("chunks")
+```
+
+## 后续步骤
+
+- 了解 TiDB 中 [向量搜索](/ai/guides/vector-search.md)、[全文搜索](/ai/guides/vector-search-full-text-search-python.md) 和 [混合搜索](/ai/guides/vector-search-hybrid-search.md) 的更多细节。
\ No newline at end of file
diff --git a/ai/quickstart-via-sql.md b/ai/quickstart-via-sql.md
new file mode 100644
index 000000000000..c960d3e9a477
--- /dev/null
+++ b/ai/quickstart-via-sql.md
@@ -0,0 +1,177 @@
+---
+title: 通过 SQL 快速上手 TiDB + AI
+summary: 学习如何仅使用 SQL 语句快速上手 TiDB 向量搜索,为你的生成式 AI 应用提供支持。
+aliases: ['/zh/tidb/stable/vector-search-get-started-using-sql/','/zh/tidb/dev/vector-search-get-started-using-sql/','/zh/tidbcloud/vector-search-get-started-using-sql/']
+---
+
+# 通过 SQL 快速上手 TiDB + AI
+
+TiDB 扩展了 MySQL 语法以支持[向量搜索](/ai/concepts/vector-search-overview.md),并引入了新的[向量数据类型](/ai/reference/vector-search-data-types.md)以及若干[向量函数](/ai/reference/vector-search-functions-and-operators.md)。
+
+本文档演示了如何仅使用 SQL 语句快速上手 TiDB 向量搜索。你将学习如何使用 [MySQL 命令行客户端](https://dev.mysql.com/doc/refman/8.4/en/mysql.html)完成以下操作:
+
+- 连接到你的 TiDB 集群。
+- 创建向量表。
+- 存储向量嵌入。
+- 执行向量搜索查询。
+
+> **注意:**
+>
+> - 向量搜索功能目前为 beta 版本,可能会在未提前通知的情况下发生变更。如果你发现了 bug,可以在 GitHub 上提交 [issue](https://github.com/pingcap/tidb/issues)。
+> - 向量搜索功能适用于 [TiDB 自托管](/overview.md)、[TiDB Cloud Starter](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#starter)、[TiDB Cloud Essential](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#essential) 和 [TiDB Cloud Dedicated](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#tidb-cloud-dedicated)。对于 TiDB 自托管和 TiDB Cloud Dedicated,TiDB 版本需为 v8.4.0 或更高(推荐 v8.5.0 或更高)。
+
+## 前置条件
+
+要完成本文档中的步骤,你需要:
+
+- 在本地安装 [MySQL 命令行客户端](https://dev.mysql.com/doc/refman/8.4/en/mysql.html)(MySQL CLI)。
+- 一个 TiDB 集群。
+
+**如果你还没有 TiDB 集群,可以按如下方式创建:**
+
+- (推荐)参考[创建 TiDB Cloud Starter 集群](/develop/dev-guide-build-cluster-in-cloud.md)来创建属于你自己的 TiDB Cloud 集群。
+- 参考[部署本地测试 TiDB 集群](/quick-start-with-tidb.md#deploy-a-local-test-cluster)或[部署生产环境 TiDB 集群](/production-deployment-using-tiup.md)来创建本地集群。
+
+## 快速上手
+
+### 步骤 1. 连接到 TiDB 集群
+
+根据你选择的 TiDB 部署方式,连接到你的 TiDB 集群。
+
+
+
+
+1. 进入 [**Clusters**](https://tidbcloud.com/console/clusters) 页面,然后点击目标集群名称进入其概览页面。
+
+2. 点击右上角的 **Connect**,弹出连接对话框。
+
+3. 在连接对话框中,从 **Connect With** 下拉列表中选择 **MySQL CLI**,并保持 **Connection Type** 的默认设置为 **Public**。
+
+4. 如果你还未设置密码,点击 **Generate Password** 生成一个随机密码。
+
+5. 复制连接命令并粘贴到你的终端中。以下是 macOS 的示例:
+
+ ```bash
+ mysql -u '
.root' -h '' -P 4000 -D 'test' --ssl-mode=VERIFY_IDENTITY --ssl-ca=/etc/ssl/cert.pem -p''
+ ```
+
+
+
+
+当你自托管的 TiDB 集群启动后,在终端中执行集群连接命令。
+
+以下是 macOS 的示例连接命令:
+
+```bash
+mysql --comments --host 127.0.0.1 --port 4000 -u root
+```
+
+
+
+
+
+### 步骤 2. 创建向量表
+
+在创建表时,你可以通过指定 `VECTOR` 数据类型,将某一列定义为[向量](/ai/concepts/vector-search-overview.md#vector-embedding)列。
+
+例如,要创建一个包含三维 `VECTOR` 列的 `embedded_documents` 表,可在 MySQL CLI 中执行如下 SQL 语句:
+
+```sql
+USE test;
+CREATE TABLE embedded_documents (
+ id INT PRIMARY KEY,
+ -- Column to store the original content of the document.
+ document TEXT,
+ -- Column to store the vector representation of the document.
+ embedding VECTOR(3)
+);
+```
+
+预期输出如下:
+
+```text
+Query OK, 0 rows affected (0.27 sec)
+```
+
+### 步骤 3. 向表中插入向量嵌入
+
+向 `embedded_documents` 表中插入三条带有[向量嵌入](/ai/concepts/vector-search-overview.md#vector-embedding)的文档:
+
+```sql
+INSERT INTO embedded_documents
+VALUES
+ (1, 'dog', '[1,2,1]'),
+ (2, 'fish', '[1,2,4]'),
+ (3, 'tree', '[1,0,0]');
+```
+
+预期输出如下:
+
+```
+Query OK, 3 rows affected (0.15 sec)
+Records: 3 Duplicates: 0 Warnings: 0
+```
+
+> **注意**
+>
+> 本示例简化了向量嵌入的维度,仅使用三维向量进行演示。
+>
+> 在实际应用中,[嵌入模型](/ai/concepts/vector-search-overview.md#embedding-model)通常会生成数百甚至数千维的向量嵌入。
+
+### 步骤 4. 查询向量表
+
+为验证文档是否已正确插入,可查询 `embedded_documents` 表:
+
+```sql
+SELECT * FROM embedded_documents;
+```
+
+预期输出如下:
+
+```sql
++----+----------+-----------+
+| id | document | embedding |
++----+----------+-----------+
+| 1 | dog | [1,2,1] |
+| 2 | fish | [1,2,4] |
+| 3 | tree | [1,0,0] |
++----+----------+-----------+
+3 rows in set (0.15 sec)
+```
+
+### 步骤 5. 执行向量搜索查询
+
+与全文搜索类似,用户在使用向量搜索时会向应用提供搜索词。
+
+本例中,搜索词为 “a swimming animal”,其对应的向量嵌入假定为 `[1,2,3]`。在实际应用中,你需要使用嵌入模型将用户的搜索词转换为向量嵌入。
+
+执行如下 SQL 语句,TiDB 会通过计算并排序表中向量嵌入与 `[1,2,3]` 的余弦距离(`vec_cosine_distance`),找出距离最近的三条文档。
+
+```sql
+SELECT id, document, vec_cosine_distance(embedding, '[1,2,3]') AS distance
+FROM embedded_documents
+ORDER BY distance
+LIMIT 3;
+```
+
+预期输出如下:
+
+```plain
++----+----------+---------------------+
+| id | document | distance |
++----+----------+---------------------+
+| 2 | fish | 0.00853986601633272 |
+| 1 | dog | 0.12712843905603044 |
+| 3 | tree | 0.7327387580875756 |
++----+----------+---------------------+
+3 rows in set (0.15 sec)
+```
+
+搜索结果中的三条数据按照与查询向量的距离升序排列:距离越小,`document` 与搜索向量的相关性越高。
+
+因此,根据输出,最有可能的“swimming animal”是 fish,其次可能是会游泳的 dog。
+
+## 另请参阅
+
+- [向量数据类型](/ai/reference/vector-search-data-types.md)
+- [向量搜索索引](/ai/reference/vector-search-index.md)
diff --git a/ai/reference/vector-search-changelogs.md b/ai/reference/vector-search-changelogs.md
new file mode 100644
index 000000000000..17632e056500
--- /dev/null
+++ b/ai/reference/vector-search-changelogs.md
@@ -0,0 +1,19 @@
+---
+title: 向量搜索更新日志
+summary: 了解 TiDB 向量搜索功能的新特性、兼容性变更、改进和缺陷修复。
+aliases: ['/zh/tidbcloud/vector-search-changelogs/']
+---
+
+# 向量搜索更新日志
+
+## 2025 年 7 月 15 日
+
+- TiDB 向量搜索(beta)现已在 TiDB Cloud Dedicated(TiDB >= v8.4)集群中可用。
+
+## 2024 年 6 月 25 日
+
+- TiDB 向量搜索(beta)现已在所有区域的 TiDB Cloud Starter 集群中对所有用户开放。
+
+## 2024 年 4 月 1 日
+
+- TiDB 向量搜索(beta)现已在 EU 区域的 TiDB Cloud Starter 集群中对受邀用户开放。
\ No newline at end of file
diff --git a/ai/reference/vector-search-data-types.md b/ai/reference/vector-search-data-types.md
new file mode 100644
index 000000000000..eeb6c03d66ba
--- /dev/null
+++ b/ai/reference/vector-search-data-types.md
@@ -0,0 +1,248 @@
+---
+title: 向量数据类型
+summary: 了解 TiDB 中的向量数据类型。
+aliases: ['/zh/tidb/stable/vector-search-data-types/','/zh/tidb/dev/vector-search-data-types/','/zh/tidbcloud/vector-search-data-types/']
+---
+
+# 向量数据类型
+
+向量是一组浮点数序列,例如 `[0.3, 0.5, -0.1, ...]`。TiDB 提供了向量数据类型,专门针对高效存储和查询在 AI 应用中广泛使用的向量嵌入进行了优化。
+
+> **注意:**
+>
+> - 向量数据类型目前为 Beta 版本,可能会在未提前通知的情况下发生变更。如果你发现了 bug,可以在 GitHub 上提交 [issue](https://github.com/pingcap/tidb/issues)。
+> - 向量数据类型适用于 [TiDB 自托管](/overview.md)、[TiDB Cloud Starter](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#starter)、[TiDB Cloud Essential](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#essential) 和 [TiDB Cloud Dedicated](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#tidb-cloud-dedicated)。对于 TiDB 自托管和 TiDB Cloud Dedicated,TiDB 版本需为 v8.4.0 或更高(推荐 v8.5.0 或更高)。
+
+目前支持以下向量数据类型:
+
+- `VECTOR`:任意维度的单精度浮点数序列。
+- `VECTOR(D)`:固定维度 `D` 的单精度浮点数序列。
+
+与使用 [`JSON`](/data-type-json.md) 类型相比,使用向量数据类型具有以下优势:
+
+- 支持向量索引:你可以构建 [向量搜索索引](/ai/reference/vector-search-index.md) 来加速向量搜索。
+- 维度约束:你可以指定维度,禁止插入不同维度的向量。
+- 优化的存储格式:向量数据类型针对向量数据进行了优化,空间效率和性能优于 `JSON` 类型。
+
+## 语法
+
+你可以使用如下语法的字符串来表示一个向量值:
+
+```sql
+'[
, , ...]'
+```
+
+示例:
+
+```sql
+CREATE TABLE vector_table (
+ id INT PRIMARY KEY,
+ embedding VECTOR(3)
+);
+
+INSERT INTO vector_table VALUES (1, '[0.3, 0.5, -0.1]');
+
+INSERT INTO vector_table VALUES (2, NULL);
+```
+
+插入语法不合法的向量值会报错:
+
+```sql
+[tidb]> INSERT INTO vector_table VALUES (3, '[5, ]');
+ERROR 1105 (HY000): Invalid vector text: [5, ]
+```
+
+在下例中,由于在建表时为 `embedding` 列指定了维度 `3`,插入不同维度的向量会报错:
+
+```sql
+[tidb]> INSERT INTO vector_table VALUES (4, '[0.3, 0.5]');
+ERROR 1105 (HY000): vector has 2 dimensions, does not fit VECTOR(3)
+```
+
+关于向量数据类型可用的函数和运算符,参见 [向量函数与运算符](/ai/reference/vector-search-functions-and-operators.md)。
+
+关于如何构建和使用向量搜索索引,参见 [向量搜索索引](/ai/reference/vector-search-index.md)。
+
+## 存储不同维度的向量
+
+你可以通过在 `VECTOR` 类型中省略维度参数,在同一列中存储不同维度的向量:
+
+```sql
+CREATE TABLE vector_table (
+ id INT PRIMARY KEY,
+ embedding VECTOR
+);
+
+INSERT INTO vector_table VALUES (1, '[0.3, 0.5, -0.1]'); -- 3 维向量,OK
+INSERT INTO vector_table VALUES (2, '[0.3, 0.5]'); -- 2 维向量,OK
+```
+
+但需要注意的是,你无法为该列构建 [向量搜索索引](/ai/reference/vector-search-index.md),因为只有相同维度的向量之间才能计算向量距离。
+
+## 比较 {#comparison}
+
+你可以使用 [比较运算符](/functions-and-operators/operators.md)(如 `=`, `!=`, `<`, `>`, `<=`, `>=`)对向量数据类型进行比较。关于向量数据类型的完整比较运算符和函数列表,参见 [向量函数与运算符](/ai/reference/vector-search-functions-and-operators.md)。
+
+向量数据类型按元素逐一进行数值比较。例如:
+
+- `[1] < [12]`
+- `[1,2,3] < [1,2,5]`
+- `[1,2,3] = [1,2,3]`
+- `[2,2,3] > [1,2,3]`
+
+对于不同维度的两个向量,采用字典序比较,规则如下:
+
+- 两个向量从头开始逐元素比较,每个元素按数值比较。
+- 第一个不相等的元素决定哪个向量在字典序上 _更小_ 或 _更大_。
+- 如果一个向量是另一个向量的前缀,则较短的向量在字典序上 _更小_。例如,`[1,2,3] < [1,2,3,0]`。
+- 长度相同且元素完全相同的两个向量在字典序上 _相等_。
+- 空向量在字典序上 _小于_ 任何非空向量。例如,`[] < [1]`。
+- 两个空向量在字典序上 _相等_。
+
+在比较向量常量时,建议进行 [显式类型转换](#cast),将字符串转换为向量,以避免基于字符串值的比较:
+
+```sql
+-- 由于传入的是字符串,TiDB 按字符串比较:
+[tidb]> SELECT '[12.0]' < '[4.0]';
++--------------------+
+| '[12.0]' < '[4.0]' |
++--------------------+
+| 1 |
++--------------------+
+1 row in set (0.01 sec)
+
+-- 显式转换为向量后按向量比较:
+[tidb]> SELECT VEC_FROM_TEXT('[12.0]') < VEC_FROM_TEXT('[4.0]');
++--------------------------------------------------+
+| VEC_FROM_TEXT('[12.0]') < VEC_FROM_TEXT('[4.0]') |
++--------------------------------------------------+
+| 0 |
++--------------------------------------------------+
+1 row in set (0.01 sec)
+```
+
+## 算术运算 {#arithmetic}
+
+向量数据类型支持 `+`(加法)和 `-`(减法)算术运算。但不同维度的向量之间不支持算术运算,否则会报错。
+
+示例:
+
+```sql
+[tidb]> SELECT VEC_FROM_TEXT('[4]') + VEC_FROM_TEXT('[5]');
++---------------------------------------------+
+| VEC_FROM_TEXT('[4]') + VEC_FROM_TEXT('[5]') |
++---------------------------------------------+
+| [9] |
++---------------------------------------------+
+1 row in set (0.01 sec)
+
+[tidb]> SELECT VEC_FROM_TEXT('[2,3,4]') - VEC_FROM_TEXT('[1,2,3]');
++-----------------------------------------------------+
+| VEC_FROM_TEXT('[2,3,4]') - VEC_FROM_TEXT('[1,2,3]') |
++-----------------------------------------------------+
+| [1,1,1] |
++-----------------------------------------------------+
+1 row in set (0.01 sec)
+
+[tidb]> SELECT VEC_FROM_TEXT('[4]') + VEC_FROM_TEXT('[1,2,3]');
+ERROR 1105 (HY000): vectors have different dimensions: 1 and 3
+```
+
+## 类型转换 {#cast}
+
+### 向量 ⇔ 字符串 的类型转换
+
+要在向量和字符串之间进行类型转换,可以使用以下函数:
+
+- `CAST(... AS VECTOR)`:字符串 ⇒ 向量
+- `CAST(... AS CHAR)`:向量 ⇒ 字符串
+- `VEC_FROM_TEXT`:字符串 ⇒ 向量
+- `VEC_AS_TEXT`:向量 ⇒ 字符串
+
+为提升易用性,如果你调用的函数只支持向量数据类型(如向量相关性距离函数),也可以直接传入符合格式的字符串。此时 TiDB 会自动进行隐式类型转换。
+
+```sql
+-- VEC_DIMS 函数只接受 VECTOR 参数,因此可以直接传入字符串进行隐式转换。
+[tidb]> SELECT VEC_DIMS('[0.3, 0.5, -0.1]');
++------------------------------+
+| VEC_DIMS('[0.3, 0.5, -0.1]') |
++------------------------------+
+| 3 |
++------------------------------+
+1 row in set (0.01 sec)
+
+-- 你也可以先用 VEC_FROM_TEXT 显式将字符串转换为向量,再传递给 VEC_DIMS 函数。
+[tidb]> SELECT VEC_DIMS(VEC_FROM_TEXT('[0.3, 0.5, -0.1]'));
++---------------------------------------------+
+| VEC_DIMS(VEC_FROM_TEXT('[0.3, 0.5, -0.1]')) |
++---------------------------------------------+
+| 3 |
++---------------------------------------------+
+1 row in set (0.01 sec)
+
+-- 也可以用 CAST(... AS VECTOR) 显式转换:
+[tidb]> SELECT VEC_DIMS(CAST('[0.3, 0.5, -0.1]' AS VECTOR));
++----------------------------------------------+
+| VEC_DIMS(CAST('[0.3, 0.5, -0.1]' AS VECTOR)) |
++----------------------------------------------+
+| 3 |
++----------------------------------------------+
+1 row in set (0.01 sec)
+```
+
+当你使用接受多种数据类型的运算符或函数时,需要在将字符串传递给该运算符或函数前,显式将字符串类型转换为向量类型,因为此时 TiDB 不会进行隐式类型转换。例如,在进行比较运算前,需要显式将字符串转换为向量,否则 TiDB 会按字符串值进行比较,而不是按向量数值进行比较:
+
+```sql
+-- 由于传入的是字符串,TiDB 按字符串比较:
+[tidb]> SELECT '[12.0]' < '[4.0]';
++--------------------+
+| '[12.0]' < '[4.0]' |
++--------------------+
+| 1 |
++--------------------+
+1 row in set (0.01 sec)
+
+-- 显式转换为向量后按向量比较:
+[tidb]> SELECT VEC_FROM_TEXT('[12.0]') < VEC_FROM_TEXT('[4.0]');
++--------------------------------------------------+
+| VEC_FROM_TEXT('[12.0]') < VEC_FROM_TEXT('[4.0]') |
++--------------------------------------------------+
+| 0 |
++--------------------------------------------------+
+1 row in set (0.01 sec)
+```
+
+你也可以将向量显式转换为其字符串表示。例如,使用 `VEC_AS_TEXT()` 函数:
+
+```sql
+-- 字符串首先被隐式转换为向量,然后向量被显式转换为字符串,因此返回标准化格式的字符串:
+[tidb]> SELECT VEC_AS_TEXT('[0.3, 0.5, -0.1]');
++--------------------------------------+
+| VEC_AS_TEXT('[0.3, 0.5, -0.1]') |
++--------------------------------------+
+| [0.3,0.5,-0.1] |
++--------------------------------------+
+1 row in set (0.01 sec)
+```
+
+更多类型转换函数,参见 [向量函数与运算符](/ai/reference/vector-search-functions-and-operators.md)。
+
+### 向量 ⇔ 其他数据类型的类型转换
+
+目前不支持向量与其他数据类型(如 `JSON`)之间的直接类型转换。你可以在 SQL 语句中通过字符串作为中间类型进行转换来规避此限制。
+
+需要注意的是,表中存储的向量数据类型列,无法通过 `ALTER TABLE ... MODIFY COLUMN ...` 转换为其他数据类型。
+
+## 限制
+
+关于向量数据类型的限制,参见 [向量搜索限制](/ai/reference/vector-search-limitations.md) 和 [向量索引限制](/ai/reference/vector-search-index.md#restrictions)。
+
+## MySQL 兼容性
+
+向量数据类型为 TiDB 特有,MySQL 不支持。
+
+## 另请参阅
+
+- [向量函数与运算符](/ai/reference/vector-search-functions-and-operators.md)
+- [向量搜索索引](/ai/reference/vector-search-index.md)
+- [提升向量搜索性能](/ai/reference/vector-search-improve-performance.md)
diff --git a/ai/reference/vector-search-functions-and-operators.md b/ai/reference/vector-search-functions-and-operators.md
new file mode 100644
index 000000000000..f0926e51b431
--- /dev/null
+++ b/ai/reference/vector-search-functions-and-operators.md
@@ -0,0 +1,317 @@
+---
+title: 向量函数与运算符
+summary: 了解可用于向量数据类型的函数与运算符。
+aliases: ['/zh/tidb/stable/vector-search-functions-and-operators/','/zh/tidb/dev/vector-search-functions-and-operators/','/zh/tidbcloud/vector-search-functions-and-operators/']
+---
+
+# 向量函数与运算符
+
+本文档列出了可用于向量数据类型的函数与运算符。
+
+> **注意:**
+>
+> - 向量函数与运算符目前为 Beta 版本,可能会在未提前通知的情况下发生变更。如果你发现了 bug,可以在 GitHub 上提交 [issue](https://github.com/pingcap/tidb/issues)。
+> - 向量数据类型及这些向量函数适用于 [TiDB 自托管](/overview.md)、[TiDB Cloud Starter](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#starter)、[TiDB Cloud Essential](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#essential) 和 [TiDB Cloud Dedicated](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#tidb-cloud-dedicated)。对于 TiDB 自托管和 TiDB Cloud Dedicated,TiDB 版本需为 v8.4.0 或更高(推荐 v8.5.0 或更高)。
+
+## 向量函数
+
+以下函数专为 [向量数据类型](/ai/reference/vector-search-data-types.md) 设计。
+
+**向量距离函数:**
+
+| 函数名 | 描述 | [向量索引](/ai/reference/vector-search-index.md)支持 |
+| ---------------------------------------------------- | --------------------------------------------------------- |---------------------------|
+| [`VEC_L2_DISTANCE`](#vec_l2_distance) | 计算两个向量之间的 L2 距离(欧氏距离) | 是 |
+| [`VEC_COSINE_DISTANCE`](#vec_cosine_distance) | 计算两个向量之间的余弦距离 | 是 |
+| [`VEC_NEGATIVE_INNER_PRODUCT`](#vec_negative_inner_product) | 计算两个向量内积的相反数 | 否 |
+| [`VEC_L1_DISTANCE`](#vec_l1_distance) | 计算两个向量之间的 L1 距离(曼哈顿距离) | 否 |
+
+**其他向量函数:**
+
+| 函数名 | 描述 |
+| ----------------------------- | -------------------------------------------- |
+| [`VEC_DIMS`](#vec_dims) | 返回向量的维度 |
+| [`VEC_L2_NORM`](#vec_l2_norm) | 计算向量的 L2 范数(欧氏范数) |
+| [`VEC_FROM_TEXT`](#vec_from_text) | 将字符串转换为向量 |
+| [`VEC_AS_TEXT`](#vec_as_text) | 将向量转换为字符串 |
+
+## 扩展内置函数与运算符
+
+以下内置函数与运算符已扩展以支持对 [向量数据类型](/ai/reference/vector-search-data-types.md) 的操作。
+
+**算术运算符:**
+
+| 名称 | 描述 |
+| :------------------------------------------------------------------------------------- | :------------------------------- |
+| [`+`](https://dev.mysql.com/doc/refman/8.0/en/arithmetic-functions.html#operator_plus) | 向量按元素加法运算符 |
+| [`-`](https://dev.mysql.com/doc/refman/8.0/en/arithmetic-functions.html#operator_minus) | 向量按元素减法运算符 |
+
+关于向量算术运算的更多信息,参见 [向量数据类型 | 算术运算](/ai/reference/vector-search-data-types.md#arithmetic)。
+
+**聚合(GROUP BY)函数:**
+
+| 名称 | 描述 |
+| :----------------------- | :---------------------------------------- |
+| [`COUNT()`](https://dev.mysql.com/doc/refman/8.0/en/aggregate-functions.html#function_count) | 返回结果行数 |
+| [`COUNT(DISTINCT)`](https://dev.mysql.com/doc/refman/8.0/en/aggregate-functions.html#function_count-distinct) | 返回不同值的数量 |
+| [`MAX()`](https://dev.mysql.com/doc/refman/8.0/en/aggregate-functions.html#function_max) | 返回最大值 |
+| [`MIN()`](https://dev.mysql.com/doc/refman/8.0/en/aggregate-functions.html#function_min) | 返回最小值 |
+
+**比较函数与运算符:**
+
+| 名称 | 描述 |
+| ---------------------------------------- | ---------------------------------------------- |
+| [`BETWEEN ... AND ...`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#operator_between) | 检查值是否在某个范围内 |
+| [`COALESCE()`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#function_coalesce) | 返回第一个非空值参数 |
+| [`=`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#operator_equal) | 等于运算符 |
+| [`<=>`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#operator_equal-to) | NULL 安全等于运算符 |
+| [`>`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#operator_greater-than) | 大于运算符 |
+| [`>=`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#operator_greater-than-or-equal) | 大于等于运算符 |
+| [`GREATEST()`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#function_greatest) | 返回最大参数 |
+| [`IN()`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#operator_in) | 检查值是否在某个集合中 |
+| [`IS NULL`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#operator_is-null) | 测试值是否为 `NULL` |
+| [`ISNULL()`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#function_isnull) | 测试参数是否为 `NULL` |
+| [`LEAST()`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#function_least) | 返回最小参数 |
+| [`<`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#operator_less-than) | 小于运算符 |
+| [`<=`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#operator_less-than-or-equal) | 小于等于运算符 |
+| [`NOT BETWEEN ... AND ...`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#operator_not-between) | 检查值是否不在某个范围内 |
+| [`!=`, `<>`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#operator_not-equal) | 不等于运算符 |
+| [`NOT IN()`](https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html#operator_not-in) | 检查值是否不在某个集合中 |
+
+关于向量比较的更多信息,参见 [向量数据类型 | 比较](/ai/reference/vector-search-data-types.md#comparison)。
+
+**流程控制函数:**
+
+| 名称 | 描述 |
+| :------------------------------------------------------------------------------------------------ | :-------------------- |
+| [`CASE`](https://dev.mysql.com/doc/refman/8.0/en/flow-control-functions.html#operator_case) | CASE 运算符 |
+| [`IF()`](https://dev.mysql.com/doc/refman/8.0/en/flow-control-functions.html#function_if) | if/else 结构 |
+| [`IFNULL()`](https://dev.mysql.com/doc/refman/8.0/en/flow-control-functions.html#function_ifnull) | null if/else 结构 |
+| [`NULLIF()`](https://dev.mysql.com/doc/refman/8.0/en/flow-control-functions.html#function_nullif) | 如果 expr1 = expr2 则返回 `NULL` |
+
+**类型转换函数:**
+
+| 名称 | 描述 |
+| :------------------------------------------------------------------------------------------ | :-------------------------- |
+| [`CAST()`](https://dev.mysql.com/doc/refman/8.0/en/cast-functions.html#function_cast) | 将值转换为字符串或向量 |
+| [`CONVERT()`](https://dev.mysql.com/doc/refman/8.0/en/cast-functions.html#function_convert) | 将值转换为字符串 |
+
+关于如何使用 `CAST()` 的更多信息,参见 [向量数据类型 | 类型转换](/ai/reference/vector-search-data-types.md#cast)。
+
+## 完整参考
+
+### VEC_L2_DISTANCE
+
+```sql
+VEC_L2_DISTANCE(vector1, vector2)
+```
+
+使用以下公式计算两个向量之间的 [L2 距离](https://en.wikipedia.org/wiki/Euclidean_distance)(欧氏距离):
+
+$DISTANCE(p,q)=\sqrt {\sum \limits _{i=1}^{n}{(p_{i}-q_{i})^{2}}}$
+
+两个向量必须具有相同的维度,否则会返回错误。
+
+示例:
+
+```sql
+SELECT VEC_L2_DISTANCE('[0, 3]', '[4, 0]');
+```
+
+```
++-------------------------------------+
+| VEC_L2_DISTANCE('[0, 3]', '[4, 0]') |
++-------------------------------------+
+| 5 |
++-------------------------------------+
+```
+
+### VEC_COSINE_DISTANCE
+
+```sql
+VEC_COSINE_DISTANCE(vector1, vector2)
+```
+
+使用以下公式计算两个向量之间的 [余弦距离](https://en.wikipedia.org/wiki/Cosine_similarity):
+
+$DISTANCE(p,q)=1.0 - {\frac {\sum \limits _{i=1}^{n}{p_{i}q_{i}}}{{\sqrt {\sum \limits _{i=1}^{n}{p_{i}^{2}}}}\cdot {\sqrt {\sum \limits _{i=1}^{n}{q_{i}^{2}}}}}}$
+
+两个向量必须具有相同的维度,否则会返回错误。
+
+对于来自 OpenAI 的 embedding,[推荐](https://help.openai.com/en/articles/6824809-embeddings-faq)使用此函数。
+
+示例:
+
+```sql
+SELECT VEC_COSINE_DISTANCE('[1, 1]', '[-1, -1]');
+```
+
+```
++-------------------------------------------+
+| VEC_COSINE_DISTANCE('[1, 1]', '[-1, -1]') |
++-------------------------------------------+
+| 2 |
++-------------------------------------------+
+```
+
+### VEC_NEGATIVE_INNER_PRODUCT
+
+```sql
+VEC_NEGATIVE_INNER_PRODUCT(vector1, vector2)
+```
+
+使用以下公式,通过计算两个向量 [内积](https://en.wikipedia.org/wiki/Dot_product) 的相反数来计算距离:
+
+$DISTANCE(p,q)=- INNER\_PROD(p,q)=-\sum \limits _{i=1}^{n}{p_{i}q_{i}}$
+
+两个向量必须具有相同的维度,否则会返回错误。
+
+示例:
+
+```sql
+SELECT VEC_NEGATIVE_INNER_PRODUCT('[1, 2]', '[3, 4]');
+```
+
+```
++------------------------------------------------+
+| VEC_NEGATIVE_INNER_PRODUCT('[1, 2]', '[3, 4]') |
++------------------------------------------------+
+| -11 |
++------------------------------------------------+
+```
+
+### VEC_L1_DISTANCE
+
+```sql
+VEC_L1_DISTANCE(vector1, vector2)
+```
+
+使用以下公式计算两个向量之间的 [L1 距离](https://en.wikipedia.org/wiki/Taxicab_geometry)(曼哈顿距离):
+
+$DISTANCE(p,q)=\sum \limits _{i=1}^{n}{|p_{i}-q_{i}|}$
+
+两个向量必须具有相同的维度,否则会返回错误。
+
+示例:
+
+```sql
+SELECT VEC_L1_DISTANCE('[0, 0]', '[3, 4]');
+```
+
+```
++-------------------------------------+
+| VEC_L1_DISTANCE('[0, 0]', '[3, 4]') |
++-------------------------------------+
+| 7 |
++-------------------------------------+
+```
+
+### VEC_DIMS
+
+```sql
+VEC_DIMS(vector)
+```
+
+返回向量的维度。
+
+示例:
+
+```sql
+SELECT VEC_DIMS('[1, 2, 3]');
+```
+
+```
++-----------------------+
+| VEC_DIMS('[1, 2, 3]') |
++-----------------------+
+| 3 |
++-----------------------+
+```
+
+```sql
+SELECT VEC_DIMS('[]');
+```
+
+```
++----------------+
+| VEC_DIMS('[]') |
++----------------+
+| 0 |
++----------------+
+```
+
+### VEC_L2_NORM
+
+```sql
+VEC_L2_NORM(vector)
+```
+
+使用以下公式计算向量的 [L2 范数](https://en.wikipedia.org/wiki/Norm_(mathematics))(欧氏范数):
+
+$NORM(p)=\sqrt {\sum \limits _{i=1}^{n}{p_{i}^{2}}}$
+
+示例:
+
+```sql
+SELECT VEC_L2_NORM('[3, 4]');
+```
+
+```
++-----------------------+
+| VEC_L2_NORM('[3, 4]') |
++-----------------------+
+| 5 |
++-----------------------+
+```
+
+### VEC_FROM_TEXT
+
+```sql
+VEC_FROM_TEXT(string)
+```
+
+将字符串转换为向量。在许多场景下,此转换会被隐式执行,例如向 `VECTOR` 数据类型的列插入数据时。然而,在某些不支持隐式转换的表达式中(如向量的算术运算),你需要显式调用此函数。
+
+示例:
+
+```sql
+SELECT VEC_FROM_TEXT('[1, 2]') + VEC_FROM_TEXT('[3, 4]');
+```
+
+```
++-------------------------------------------------+
+| VEC_FROM_TEXT('[1,2]') + VEC_FROM_TEXT('[3,4]') |
++-------------------------------------------------+
+| [4,6] |
++-------------------------------------------------+
+```
+
+### VEC_AS_TEXT
+
+```sql
+VEC_AS_TEXT(vector)
+```
+
+将向量转换为字符串。
+
+示例:
+
+```sql
+SELECT VEC_AS_TEXT('[1.000, 2.5]');
+```
+
+```
++-----------------------------+
+| VEC_AS_TEXT('[1.000, 2.5]') |
++-----------------------------+
+| [1,2.5] |
++-----------------------------+
+```
+
+## MySQL 兼容性
+
+向量函数以及内置函数和运算符在向量数据类型上的扩展用法为 TiDB 特有,MySQL 不支持。
+
+## 另请参阅
+
+- [向量数据类型](/ai/reference/vector-search-data-types.md)
diff --git a/ai/reference/vector-search-improve-performance.md b/ai/reference/vector-search-improve-performance.md
new file mode 100644
index 000000000000..06b110736d6c
--- /dev/null
+++ b/ai/reference/vector-search-improve-performance.md
@@ -0,0 +1,42 @@
+---
+title: 提升向量搜索性能
+summary: 学习提升 TiDB 向量搜索性能的最佳实践。
+aliases: ['/zh/tidb/stable/vector-search-improve-performance/','/zh/tidb/dev/vector-search-improve-performance/','/zh/tidbcloud/vector-search-improve-performance/']
+---
+
+# 提升向量搜索性能
+
+TiDB 向量搜索支持执行近似最近邻(ANN)查询,用于查找与某个镜像、文档或其他输入相似的结果。要提升查询性能,请参考以下最佳实践。
+
+> **注意:**
+>
+> - 向量搜索功能目前为 beta 版本,可能会在未提前通知的情况下发生变更。如果你发现了 bug,可以在 GitHub 上提交 [issue](https://github.com/pingcap/tidb/issues)。
+> - 向量搜索功能适用于 [TiDB 自托管](/overview.md)、[TiDB Cloud Starter](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#starter)、[TiDB Cloud Essential](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#essential) 和 [TiDB Cloud Dedicated](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#tidb-cloud-dedicated)。对于 TiDB 自托管和 TiDB Cloud Dedicated,TiDB 版本需为 v8.4.0 或更高(推荐 v8.5.0 或更高)。
+
+## 为向量列添加向量搜索索引
+
+[向量搜索索引](/ai/reference/vector-search-index.md) 能显著提升向量搜索查询的性能,通常可提升 10 倍或以上,仅以极小的召回率下降为代价。
+
+## 确保向量索引已完全构建
+
+在你插入大量向量数据后,部分数据可能仍处于 Delta 层,等待持久化。TiDB 会在数据持久化后为这些数据构建向量索引。在所有向量数据都被索引之前,向量搜索性能会处于次优状态。要查看索引构建进度,请参见 [查看索引构建进度](/ai/reference/vector-search-index.md#view-index-build-progress)。
+
+## 降低向量维度或缩短 embedding
+
+随着向量维度的增加,向量搜索索引和查询的计算复杂度会显著提升,需要进行更多的浮点数比较。
+
+为优化性能,建议在可行的情况下降低向量维度。这通常需要切换到其他 embedding 模型。切换模型时,你需要评估模型变更对向量查询准确性的影响。
+
+某些 embedding 模型(如 OpenAI 的 `text-embedding-3-large`)支持[缩短 embedding](https://openai.com/index/new-embedding-models-and-api-updates/),即在不丢失 embedding 概念表达能力的前提下,从向量序列末尾移除部分数值。你也可以使用此类 embedding 模型来降低向量维度。
+
+## 从结果中排除向量列
+
+向量 embedding 数据通常较大,仅在搜索过程中使用。通过在查询结果中排除向量列,可以大幅减少 TiDB 服务器与 SQL 客户端之间传输的数据量,从而提升查询性能。
+
+要排除向量列,请在 `SELECT` 子句中显式列出你需要获取的列,而不是使用 `SELECT *` 获取所有列。
+
+## 预热索引
+
+当访问从未被使用过或长时间未被访问(冷访问)的索引时,TiDB 需要从云存储或磁盘(而非内存)加载整个索引。此过程需要一定时间,通常会导致更高的查询延时。此外,如果长时间(如数小时)没有 SQL 查询,计算资源会被回收,导致后续访问变为冷访问。
+
+为避免此类查询延时,在实际负载前,可以通过执行命中向量索引的类似向量搜索查询来预热索引。
\ No newline at end of file
diff --git a/ai/reference/vector-search-index.md b/ai/reference/vector-search-index.md
new file mode 100644
index 000000000000..4773e633a097
--- /dev/null
+++ b/ai/reference/vector-search-index.md
@@ -0,0 +1,259 @@
+---
+title: 向量搜索索引
+summary: 了解如何在 TiDB 中构建和使用向量搜索索引,以加速 K-最近邻(KNN)查询。
+aliases: ['/zh/tidb/stable/vector-search-index/','/zh/tidb/dev/vector-search-index/','/zh/tidbcloud/vector-search-index/']
+---
+
+# 向量搜索索引
+
+如 [向量搜索](/ai/concepts/vector-search-overview.md) 文档所述,向量搜索通过计算给定向量与数据库中所有向量之间的距离,找出 Top K-最近邻(KNN)。这种方式能够提供准确的结果,但当表中包含大量向量时,查询速度较慢,因为需要进行全表扫描。[^1]
+
+为了提升搜索效率,你可以在 TiDB 中为近似 KNN(ANN)搜索创建向量搜索索引。使用向量索引进行向量搜索时,TiDB 可以大幅提升查询性能,准确性仅有轻微下降,通常搜索召回率可保持在 90% 以上。
+
+> **注意:**
+>
+> - 向量搜索功能目前为 beta 版本,可能会在未提前通知的情况下发生变更。如果你发现 bug,可以在 GitHub 上提交 [issue](https://github.com/pingcap/tidb/issues)。
+> - 向量搜索功能适用于 [TiDB 自托管](/overview.md)、[TiDB Cloud Starter](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#starter)、[TiDB Cloud Essential](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#essential) 和 [TiDB Cloud Dedicated](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#tidb-cloud-dedicated)。对于 TiDB 自托管和 TiDB Cloud Dedicated,TiDB 版本需为 v8.4.0 及以上(推荐 v8.5.0 及以上)。
+
+目前,TiDB 支持 [HNSW(Hierarchical Navigable Small World)](https://en.wikipedia.org/wiki/Hierarchical_navigable_small_world) 向量搜索索引算法。
+
+## 限制 {#restrictions}
+
+- 你的集群中必须提前部署 TiFlash 节点。
+- 向量搜索索引不能作为主键或唯一索引使用。
+- 向量搜索索引只能创建在单个向量列上,不能与其他列(如整数型或字符串)组合为组合索引。
+- 创建和使用向量搜索索引时,必须指定距离函数。目前仅支持余弦距离 `VEC_COSINE_DISTANCE()` 和 L2 距离 `VEC_L2_DISTANCE()` 函数。
+- 对于同一列,不支持使用相同距离函数创建多个向量搜索索引。
+- 不支持直接删除带有向量搜索索引的列。你可以先删除该列上的向量搜索索引,再删除该列。
+- 不支持修改带有向量索引的列的类型。
+- 不支持将向量搜索索引设置为 [不可见](/sql-statements/sql-statement-alter-index.md)。
+- 不支持在启用 [静态加密](/encryption-at-rest.md) 的 TiFlash 节点上构建向量搜索索引。
+
+## 创建 HNSW 向量索引
+
+[HNSW](https://en.wikipedia.org/wiki/Hierarchical_navigable_small_world) 是最流行的向量索引算法之一。HNSW 索引在保持较高准确性的同时,能够提供良好的性能,在特定场景下准确率可达 98%。
+
+在 TiDB 中,你可以通过以下任一方式为具有 [向量数据类型](/ai/reference/vector-search-data-types.md) 的列创建 HNSW 索引:
+
+- 创建表时,使用如下语法为向量列指定 HNSW 索引:
+
+ ```sql
+ CREATE TABLE foo (
+ id INT PRIMARY KEY,
+ embedding VECTOR(5),
+ VECTOR INDEX idx_embedding ((VEC_COSINE_DISTANCE(embedding)))
+ );
+ ```
+
+- 对于已存在且包含向量列的表,使用如下语法为该向量列创建 HNSW 索引:
+
+ ```sql
+ CREATE VECTOR INDEX idx_embedding ON foo ((VEC_COSINE_DISTANCE(embedding)));
+ ALTER TABLE foo ADD VECTOR INDEX idx_embedding ((VEC_COSINE_DISTANCE(embedding)));
+
+ -- 你也可以显式指定 "USING HNSW" 来构建向量搜索索引。
+ CREATE VECTOR INDEX idx_embedding ON foo ((VEC_COSINE_DISTANCE(embedding))) USING HNSW;
+ ALTER TABLE foo ADD VECTOR INDEX idx_embedding ((VEC_COSINE_DISTANCE(embedding))) USING HNSW;
+ ```
+
+> **注意:**
+>
+> 向量搜索索引功能依赖于表的 TiFlash 副本。
+>
+> - 如果在创建表时定义了向量搜索索引,TiDB 会自动为该表创建 TiFlash 副本。
+> - 如果在创建表时未定义向量搜索索引,且当前表没有 TiFlash 副本,则需要在为表添加向量搜索索引前,手动创建 TiFlash 副本。例如:`ALTER TABLE 'table_name' SET TIFLASH REPLICA 1;`。
+
+创建 HNSW 向量索引时,你需要为向量指定距离函数:
+
+- 余弦距离:`((VEC_COSINE_DISTANCE(embedding)))`
+- L2 距离:`((VEC_L2_DISTANCE(embedding)))`
+
+向量索引只能创建在定长向量列上,例如定义为 `VECTOR(3)` 的列。不能为非定长向量列(如定义为 `VECTOR` 的列)创建索引,因为只有维度相同的向量之间才能计算距离。
+
+关于向量搜索索引的限制,详见 [限制](#restrictions)。
+
+## 使用向量索引
+
+在 K-最近邻搜索查询中,可以通过如下 `ORDER BY ... LIMIT` 语句使用向量搜索索引:
+
+```sql
+SELECT *
+FROM foo
+ORDER BY VEC_COSINE_DISTANCE(embedding, '[1, 2, 3, 4, 5]')
+LIMIT 10
+```
+
+要在向量搜索中使用索引,确保 `ORDER BY ... LIMIT` 子句使用的距离函数与创建向量索引时指定的距离函数一致。
+
+## 向量索引与过滤条件联合使用
+
+包含预过滤(使用 `WHERE` 子句)的查询无法利用向量索引,因为根据 SQL 语义,这类查询并非在全表范围内查找 K-最近邻。例如:
+
+```sql
+-- 对于以下查询,`WHERE` 过滤在 KNN 之前执行,因此无法使用向量索引:
+
+SELECT * FROM vec_table
+WHERE category = "document"
+ORDER BY VEC_COSINE_DISTANCE(embedding, '[1, 2, 3]')
+LIMIT 5;
+```
+
+要在带有过滤条件的场景下使用向量索引,应先通过向量搜索查询 K-最近邻,再对结果进行过滤:
+
+```sql
+-- 对于以下查询,`WHERE` 过滤在 KNN 之后执行,因此可以使用向量索引:
+
+SELECT * FROM
+(
+ SELECT * FROM vec_table
+ ORDER BY VEC_COSINE_DISTANCE(embedding, '[1, 2, 3]')
+ LIMIT 5
+) t
+WHERE category = "document";
+
+-- 注意,如果部分结果被过滤,最终返回的结果可能少于 5 条。
+```
+
+## 查看索引构建进度 {#view-index-build-progress}
+
+在你插入大量数据后,部分数据可能不会立即持久化到 TiFlash。对于已持久化的向量数据,向量搜索索引会同步构建;对于尚未持久化的数据,索引会在数据持久化后再构建。此过程不会影响数据的准确性和一致性,你可以随时进行向量搜索并获得完整结果。但在向量索引完全构建前,性能会低于最佳状态。
+
+你可以通过查询 `INFORMATION_SCHEMA.TIFLASH_INDEXES` 表来查看索引构建进度:
+
+```sql
+SELECT * FROM INFORMATION_SCHEMA.TIFLASH_INDEXES;
++---------------+------------+----------+-------------+---------------+-----------+----------+------------+---------------------+-------------------------+--------------------+------------------------+---------------+------------------+
+| TIDB_DATABASE | TIDB_TABLE | TABLE_ID | COLUMN_NAME | INDEX_NAME | COLUMN_ID | INDEX_ID | INDEX_KIND | ROWS_STABLE_INDEXED | ROWS_STABLE_NOT_INDEXED | ROWS_DELTA_INDEXED | ROWS_DELTA_NOT_INDEXED | ERROR_MESSAGE | TIFLASH_INSTANCE |
++---------------+------------+----------+-------------+---------------+-----------+----------+------------+---------------------+-------------------------+--------------------+------------------------+---------------+------------------+
+| test | tcff1d827 | 219 | col1fff | 0a452311 | 7 | 1 | HNSW | 29646 | 0 | 0 | 0 | | 127.0.0.1:3930 |
+| test | foo | 717 | embedding | idx_embedding | 2 | 1 | HNSW | 0 | 0 | 0 | 3 | | 127.0.0.1:3930 |
++---------------+------------+----------+-------------+---------------+-----------+----------+------------+---------------------+-------------------------+--------------------+------------------------+---------------+------------------+
+```
+
+- 你可以通过 `ROWS_STABLE_INDEXED` 和 `ROWS_STABLE_NOT_INDEXED` 列查看索引构建进度。当 `ROWS_STABLE_NOT_INDEXED` 为 0 时,索引构建完成。
+
+ 作为参考,对 500 MiB、768 维的向量数据集进行索引,可能需要长达 20 分钟。索引器可并行为多个表构建索引。目前不支持调整索引器优先级或速度。
+
+- 你可以通过 `ROWS_DELTA_NOT_INDEXED` 列查看 Delta 层中的行数。TiFlash 存储层的数据分为 Delta 层和 Stable 层。Delta 层存储最近插入或更新的行,并会根据写入负载定期合并到 Stable 层。该合并过程称为 Compaction。
+
+ Delta 层始终不会被索引。为获得最佳性能,你可以强制将 Delta 层合并到 Stable 层,使所有数据都能被索引:
+
+ ```sql
+ ALTER TABLE COMPACT;
+ ```
+
+ 详细信息参见 [`ALTER TABLE ... COMPACT`](/sql-statements/sql-statement-alter-table-compact.md)。
+
+此外,你还可以通过执行 `ADMIN SHOW DDL JOBS;` 并查看 `row count`,监控 DDL 任务的执行进度。但该方法并不完全准确,因为 `row count` 的值来自 `TIFLASH_INDEXES` 中的 `rows_stable_indexed` 字段。你可以将此方法作为索引进度的参考。
+
+## 检查是否使用了向量索引
+
+使用 [`EXPLAIN`](/sql-statements/sql-statement-explain.md) 或 [`EXPLAIN ANALYZE`](/sql-statements/sql-statement-explain-analyze.md) 语句,可以检查查询是否使用了向量索引。当 `TableFullScan` 执行器的 `operator info` 列中出现 `annIndex:` 时,表示该表扫描正在利用向量索引。
+
+**示例:已使用向量索引**
+
+```sql
+[tidb]> EXPLAIN SELECT * FROM vector_table_with_index
+ORDER BY VEC_COSINE_DISTANCE(embedding, '[1, 2, 3]')
+LIMIT 10;
++-----+-------------------------------------------------------------------------------------+
+| ... | operator info |
++-----+-------------------------------------------------------------------------------------+
+| ... | ... |
+| ... | Column#5, offset:0, count:10 |
+| ... | ..., vec_cosine_distance(test.vector_table_with_index.embedding, [1,2,3])->Column#5 |
+| ... | MppVersion: 1, data:ExchangeSender_16 |
+| ... | ExchangeType: PassThrough |
+| ... | ... |
+| ... | Column#4, offset:0, count:10 |
+| ... | ..., vec_cosine_distance(test.vector_table_with_index.embedding, [1,2,3])->Column#4 |
+| ... | annIndex:COSINE(test.vector_table_with_index.embedding..[1,2,3], limit:10), ... |
++-----+-------------------------------------------------------------------------------------+
+9 rows in set (0.01 sec)
+```
+
+**示例:未指定 Top K,未使用向量索引**
+
+```sql
+[tidb]> EXPLAIN SELECT * FROM vector_table_with_index
+ -> ORDER BY VEC_COSINE_DISTANCE(embedding, '[1, 2, 3]');
++--------------------------------+-----+--------------------------------------------------+
+| id | ... | operator info |
++--------------------------------+-----+--------------------------------------------------+
+| Projection_15 | ... | ... |
+| └─Sort_4 | ... | Column#4 |
+| └─Projection_16 | ... | ..., vec_cosine_distance(..., [1,2,3])->Column#4 |
+| └─TableReader_14 | ... | MppVersion: 1, data:ExchangeSender_13 |
+| └─ExchangeSender_13 | ... | ExchangeType: PassThrough |
+| └─TableFullScan_12 | ... | keep order:false, stats:pseudo |
++--------------------------------+-----+--------------------------------------------------+
+6 rows in set, 1 warning (0.01 sec)
+```
+
+当无法使用向量索引时,部分场景下会出现 warning,帮助你了解原因:
+
+```sql
+-- 使用了错误的距离函数:
+[tidb]> EXPLAIN SELECT * FROM vector_table_with_index
+ORDER BY VEC_L2_DISTANCE(embedding, '[1, 2, 3]')
+LIMIT 10;
+
+[tidb]> SHOW WARNINGS;
+ANN index not used: not ordering by COSINE distance
+
+-- 使用了错误的排序方式:
+[tidb]> EXPLAIN SELECT * FROM vector_table_with_index
+ORDER BY VEC_COSINE_DISTANCE(embedding, '[1, 2, 3]') DESC
+LIMIT 10;
+
+[tidb]> SHOW WARNINGS;
+ANN index not used: index can be used only when ordering by vec_cosine_distance() in ASC order
+```
+
+## 分析向量搜索性能
+
+要了解向量索引的详细使用信息,可以执行 [`EXPLAIN ANALYZE`](/sql-statements/sql-statement-explain-analyze.md) 语句,并查看输出中的 `execution info` 列:
+
+```sql
+[tidb]> EXPLAIN ANALYZE SELECT * FROM vector_table_with_index
+ORDER BY VEC_COSINE_DISTANCE(embedding, '[1, 2, 3]')
+LIMIT 10;
++-----+--------------------------------------------------------+-----+
+| | execution info | |
++-----+--------------------------------------------------------+-----+
+| ... | time:339.1ms, loops:2, RU:0.000000, Concurrency:OFF | ... |
+| ... | time:339ms, loops:2 | ... |
+| ... | time:339ms, loops:3, Concurrency:OFF | ... |
+| ... | time:339ms, loops:3, cop_task: {...} | ... |
+| ... | tiflash_task:{time:327.5ms, loops:1, threads:4} | ... |
+| ... | tiflash_task:{time:327.5ms, loops:1, threads:4} | ... |
+| ... | tiflash_task:{time:327.5ms, loops:1, threads:4} | ... |
+| ... | tiflash_task:{time:327.5ms, loops:1, threads:4} | ... |
+| ... | tiflash_task:{...}, vector_idx:{ | ... |
+| | load:{total:68ms,from_s3:1,from_disk:0,from_cache:0},| |
+| | search:{total:0ms,visited_nodes:2,discarded_nodes:0},| |
+| | read:{vec_total:0ms,others_total:0ms}},...} | |
++-----+--------------------------------------------------------+-----+
+```
+
+> **注意:**
+>
+> 执行信息为内部信息,字段及格式可能随时变更,恕不另行通知。请勿依赖这些信息。
+
+部分重要字段说明:
+
+- `vector_index.load.total`:索引加载总耗时。该值可能大于实际查询时间,因为可能有多个向量索引并行加载。
+- `vector_index.load.from_s3`:从 S3 加载的索引数量。
+- `vector_index.load.from_disk`:从磁盘加载的索引数量。该索引此前已从 S3 下载到本地磁盘。
+- `vector_index.load.from_cache`:从缓存加载的索引数量。该索引此前已从 S3 下载到缓存。
+- `vector_index.search.total`:在索引中搜索的总耗时。较大的延时通常意味着索引为冷数据(从未访问或长时间未访问),导致搜索时有大量 I/O 操作。该值可能大于实际查询时间,因为可能有多个向量索引并行搜索。
+- `vector_index.search.discarded_nodes`:搜索过程中访问但被丢弃的向量行数。这些被丢弃的向量不会计入搜索结果。该值较大通常说明存在大量因 `UPDATE` 或 `DELETE` 语句产生的陈旧行。
+
+关于输出的解读,参见 [`EXPLAIN`](/sql-statements/sql-statement-explain.md)、[`EXPLAIN ANALYZE`](/sql-statements/sql-statement-explain-analyze.md) 及 [EXPLAIN 使用指南](/explain-walkthrough.md)。
+
+## 另请参阅
+
+- [提升向量搜索性能](/ai/reference/vector-search-improve-performance.md)
+- [向量数据类型](/ai/reference/vector-search-data-types.md)
+
+[^1]: KNN 搜索的解释改编自 ClickHouse 文档中 [Approximate Nearest Neighbor Search Indexes](https://github.com/ClickHouse/ClickHouse/pull/50661/files#diff-7ebd9e71df96e74230c9a7e604fa7cb443be69ba5e23bf733fcecd4cc51b7576) 一文,作者为 [rschu1ze](https://github.com/rschu1ze),遵循 Apache License 2.0 许可协议。
\ No newline at end of file
diff --git a/ai/reference/vector-search-limitations.md b/ai/reference/vector-search-limitations.md
new file mode 100644
index 000000000000..b820ba8a375b
--- /dev/null
+++ b/ai/reference/vector-search-limitations.md
@@ -0,0 +1,50 @@
+---
+title: 向量搜索限制
+summary: 了解 TiDB 向量搜索的限制。
+aliases: ['/zh/tidb/stable/vector-search-limitations/','/zh/tidb/dev/vector-search-limitations/','/zh/tidbcloud/vector-search-limitations/']
+---
+
+# 向量搜索限制
+
+本文档描述了 TiDB 向量搜索已知的限制。
+
+> **注意:**
+>
+> - 向量搜索功能目前为 beta 版本,可能会在没有提前通知的情况下发生变更。如果你发现了 bug,可以在 GitHub 上提交 [issue](https://github.com/pingcap/tidb/issues)。
+> - 向量搜索功能适用于 [TiDB 自托管](/overview.md)、[TiDB Cloud Starter](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#starter)、[TiDB Cloud Essential](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#essential) 和 [TiDB Cloud Dedicated](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#tidb-cloud-dedicated)。对于 TiDB 自托管和 TiDB Cloud Dedicated,TiDB 版本必须为 v8.4.0 或以上版本(推荐使用 v8.5.0 或以上版本)。
+
+## 向量数据类型限制
+
+- 每个 [vector](/ai/reference/vector-search-data-types.md) 最多支持 16383 维。
+- 向量数据类型无法存储 `NaN`、`Infinity` 或 `-Infinity` 值。
+- 向量数据类型无法存储双精度浮点数。如果你在向量列中插入或存储双精度浮点数,TiDB 会将其转换为单精度浮点数。
+- 向量列不能作为主键或主键的一部分。
+- 向量列不能作为唯一索引或唯一索引的一部分。
+- 向量列不能作为分区键或分区键的一部分。
+- 目前,TiDB 不支持将向量列修改为其他数据类型(如 `JSON` 和 `VARCHAR`)。
+
+## 向量索引限制
+
+参见 [向量搜索限制](/ai/reference/vector-search-index.md#restrictions)。
+
+## 与 TiDB 工具的兼容性
+
+在使用向量搜索时,请注意以下兼容性问题:
+
+- TiDB Cloud 功能:
+
+ - [TiDB Cloud 控制台的数据迁移功能](https://docs.pingcap.com/zh/tidbcloud/migrate-from-mysql-using-data-migration/) 不支持将 MySQL 向量数据类型迁移或同步到 TiDB Cloud。
+
+- TiDB 工具:
+
+ - 请确保你使用的是 v8.4.0 或以上版本的 [BR](/br/backup-and-restore-overview.md) 进行数据备份和恢复。不支持将包含向量数据类型的表恢复到低于 v8.4.0 的 TiDB 集群。
+ - [TiDB Data Migration (DM)](/dm/dm-overview.md) 不支持将 MySQL 向量数据类型迁移或同步到 TiDB。
+ - 当 [TiCDC](/ticdc/ticdc-overview.md) 将向量数据同步到不支持向量数据类型的下游时,会将向量数据类型转换为其他类型。更多信息,参见 [与向量数据类型的兼容性](/ticdc/ticdc-compatibility.md#compatibility-with-vector-data-types)。
+
+## 反馈
+
+我们非常重视你的反馈,并随时为你提供帮助:
+
+- 在 [Discord](https://discord.gg/DQZ2dy3cuc?utm_source=doc) 或 [Slack](https://slack.tidb.io/invite?team=tidb-community&channel=everyone&ref=pingcap-docs) 社区提问
+- [提交 TiDB Cloud 工单](https://tidb.support.pingcap.com/servicedesk/customer/portals)
+- [提交 TiDB 工单](/support.md)
diff --git a/ai/vector-search-get-started-using-python.md b/ai/vector-search-get-started-using-python.md
new file mode 100644
index 000000000000..b74adad37f4c
--- /dev/null
+++ b/ai/vector-search-get-started-using-python.md
@@ -0,0 +1,233 @@
+---
+title: 使用 Python 快速入门 TiDB + AI
+summary: 学习如何使用 Python 和 TiDB 向量搜索快速开发一个实现语义搜索的 AI 应用。
+aliases: ['/zh/tidb/stable/vector-search-get-started-using-python/','/zh/tidb/dev/vector-search-get-started-using-python/','/zh/tidbcloud/vector-search-get-started-using-python/']
+---
+
+# 使用 Python 快速入门 TiDB + AI
+
+本教程演示如何开发一个简单的 AI 应用,提供 **语义搜索** 功能。与传统的关键字搜索不同,语义搜索能够智能理解你的查询背后的含义,并返回最相关的结果。例如,如果你有标题为 "dog"、"fish" 和 "tree" 的文档,当你搜索 "a swimming animal" 时,应用会识别出 "fish" 是最相关的结果。
+
+在本教程中,你将使用 [TiDB 向量搜索](/ai/concepts/vector-search-overview.md)、Python、[TiDB Vector SDK for Python](https://github.com/pingcap/tidb-vector-python) 以及 AI 模型来开发该 AI 应用。
+
+> **注意:**
+>
+> - 向量搜索功能目前为 beta 版本,可能会在不提前通知的情况下发生变更。如果你发现了 bug,可以在 GitHub 上提交 [issue](https://github.com/pingcap/tidb/issues)。
+> - 向量搜索功能适用于 [TiDB 自托管](/overview.md)、[TiDB Cloud Starter](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#starter)、[TiDB Cloud Essential](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#essential) 和 [TiDB Cloud Dedicated](https://docs.pingcap.com/zh/tidbcloud/select-cluster-tier/#tidb-cloud-dedicated)。对于 TiDB 自托管和 TiDB Cloud Dedicated,TiDB 版本需为 v8.4.0 或更高(推荐 v8.5.0 或更高)。
+
+## 前置条件
+
+完成本教程,你需要:
+
+- 已安装 [Python 3.8 或更高版本](https://www.python.org/downloads/)。
+- 已安装 [Git](https://git-scm.com/downloads)。
+- 一个 TiDB 集群。
+
+**如果你还没有 TiDB 集群,可以按如下方式创建:**
+
+- (推荐)参考 [创建 TiDB Cloud Starter 集群](/develop/dev-guide-build-cluster-in-cloud.md) 创建属于你自己的 TiDB Cloud 集群。
+- 参考 [部署本地测试 TiDB 集群](/quick-start-with-tidb.md#deploy-a-local-test-cluster) 或 [部署生产环境 TiDB 集群](/production-deployment-using-tiup.md) 创建本地集群。
+
+## 快速开始
+
+以下步骤展示了如何从零开发该应用。如果你想直接运行示例,可以在 [pingcap/tidb-vector-python](https://github.com/pingcap/tidb-vector-python/blob/main/examples/python-client-quickstart) 仓库中查看示例代码。
+
+### 步骤 1. 创建新的 Python 项目
+
+在你喜欢的目录下,创建一个新的 Python 项目,并新建名为 `example.py` 的文件:
+
+```shell
+mkdir python-client-quickstart
+cd python-client-quickstart
+touch example.py
+```
+
+### 步骤 2. 安装所需依赖
+
+在你的项目目录下,运行以下命令安装所需的依赖包:
+
+```shell
+pip install sqlalchemy pymysql sentence-transformers tidb-vector python-dotenv
+```
+
+- `tidb-vector`:用于与 TiDB 向量搜索交互的 Python 客户端。
+- [`sentence-transformers`](https://sbert.net):一个 Python 库,提供用于从文本生成 [向量嵌入](/ai/concepts/vector-search-overview.md#vector-embedding) 的预训练模型。
+
+### 步骤 3. 配置 TiDB 集群连接字符串
+
+根据你选择的 TiDB 部署方式,配置集群连接字符串。
+
+
+
+
+对于 TiDB Cloud Starter 集群,按以下步骤获取集群连接字符串并配置环境变量:
+
+1. 进入 [**Clusters**](https://tidbcloud.com/console/clusters) 页面,点击目标集群名称进入集群概览页。
+
+2. 点击右上角的 **Connect**,弹出连接对话框。
+
+3. 确认连接对话框中的配置与你的运行环境一致。
+
+ - **Connection Type** 设置为 `Public`。
+ - **Branch** 设置为 `main`。
+ - **Connect With** 设置为 `SQLAlchemy`。
+ - **Operating System** 与你的环境一致。
+
+ > **提示:**
+ >
+ > 如果你的程序运行在 Windows Subsystem for Linux (WSL) 中,请切换到对应的 Linux 发行版。
+
+4. 点击 **PyMySQL** 标签页,复制连接字符串。
+
+ > **提示:**
+ >
+ > 如果你还未设置密码,可点击 **Generate Password** 生成随机密码。
+
+5. 在你的 Python 项目根目录下,创建 `.env` 文件,并将连接字符串粘贴进去。
+
+ 以下为 macOS 示例:
+
+ ```dotenv
+ TIDB_DATABASE_URL="mysql+pymysql://
.root:@gateway01..prod.aws.tidbcloud.com:4000/test?ssl_ca=/etc/ssl/cert.pem&ssl_verify_cert=true&ssl_verify_identity=true"
+ ```
+
+
+
+
+对于 TiDB 自建集群,在你的 Python 项目根目录下创建 `.env` 文件。将以下内容复制到 `.env` 文件中,并根据你的 TiDB 集群连接参数修改环境变量的值:
+
+```dotenv
+TIDB_DATABASE_URL="mysql+pymysql://
:@:/"
+# 例如:TIDB_DATABASE_URL="mysql+pymysql://root@127.0.0.1:4000/test"
+```
+
+如果你在本地机器上运行 TiDB,`` 默认为 `127.0.0.1`。初始 `` 为空,因此如果是首次启动集群,可以省略该字段。
+
+各参数说明如下:
+
+- ``:连接 TiDB 集群的用户名。
+- ``:连接 TiDB 集群的密码。
+- ``:TiDB 集群的主机。
+- ``:TiDB 集群的端口。
+- ``:你要连接的数据库名称。
+
+
+
+
+
+### 步骤 4. 初始化嵌入模型
+
+[嵌入模型](/ai/concepts/vector-search-overview.md#embedding-model) 用于将数据转换为 [向量嵌入](/ai/concepts/vector-search-overview.md#vector-embedding)。本示例使用预训练模型 [**msmarco-MiniLM-L12-cos-v5**](https://huggingface.co/sentence-transformers/msmarco-MiniLM-L12-cos-v5) 进行文本嵌入。该轻量级模型由 `sentence-transformers` 库提供,可将文本数据转换为 384 维的向量嵌入。
+
+要设置模型,将以下代码复制到 `example.py` 文件中。该代码初始化了一个 `SentenceTransformer` 实例,并定义了后续使用的 `text_to_embedding()` 函数。
+
+```python
+from sentence_transformers import SentenceTransformer
+
+print("Downloading and loading the embedding model...")
+embed_model = SentenceTransformer("sentence-transformers/msmarco-MiniLM-L12-cos-v5", trust_remote_code=True)
+embed_model_dims = embed_model.get_sentence_embedding_dimension()
+
+def text_to_embedding(text):
+ """Generates vector embeddings for the given text."""
+ embedding = embed_model.encode(text)
+ return embedding.tolist()
+```
+
+### 步骤 5. 连接 TiDB 集群
+
+使用 `TiDBVectorClient` 类连接 TiDB 集群,并创建包含向量列的 `embedded_documents` 表。
+
+> **注意**
+>
+> 请确保表中向量列的维度与嵌入模型生成的向量维度一致。例如,**msmarco-MiniLM-L12-cos-v5** 模型生成的向量为 384 维,因此 `embedded_documents` 表中向量列的维度也应为 384。
+
+```python
+import os
+from tidb_vector.integrations import TiDBVectorClient
+from dotenv import load_dotenv
+
+# Load the connection string from the .env file
+load_dotenv()
+
+vector_store = TiDBVectorClient(
+ # The 'embedded_documents' table will store the vector data.
+ table_name='embedded_documents',
+ # The connection string to the TiDB cluster.
+ connection_string=os.environ.get('TIDB_DATABASE_URL'),
+ # The dimension of the vector generated by the embedding model.
+ vector_dimension=embed_model_dims,
+ # Recreate the table if it already exists.
+ drop_existing_table=True,
+)
+```
+
+### 步骤 6. 嵌入文本数据并存储向量
+
+本步骤将准备包含单词的示例文档,如 "dog"、"fish" 和 "tree"。以下代码使用 `text_to_embedding()` 函数将这些文本文档转换为向量嵌入,并插入到向量存储中。
+
+```python
+documents = [
+ {
+ "id": "f8e7dee2-63b6-42f1-8b60-2d46710c1971",
+ "text": "dog",
+ "embedding": text_to_embedding("dog"),
+ "metadata": {"category": "animal"},
+ },
+ {
+ "id": "8dde1fbc-2522-4ca2-aedf-5dcb2966d1c6",
+ "text": "fish",
+ "embedding": text_to_embedding("fish"),
+ "metadata": {"category": "animal"},
+ },
+ {
+ "id": "e4991349-d00b-485c-a481-f61695f2b5ae",
+ "text": "tree",
+ "embedding": text_to_embedding("tree"),
+ "metadata": {"category": "plant"},
+ },
+]
+
+vector_store.insert(
+ ids=[doc["id"] for doc in documents],
+ texts=[doc["text"] for doc in documents],
+ embeddings=[doc["embedding"] for doc in documents],
+ metadatas=[doc["metadata"] for doc in documents],
+)
+```
+
+### 步骤 7. 执行语义搜索
+
+本步骤将搜索 "a swimming animal",该查询与现有文档中的单词并不直接匹配。
+
+以下代码再次使用 `text_to_embedding()` 函数将查询文本转换为向量嵌入,并用该嵌入向量查询,找出距离最近的前三个结果。
+
+```python
+def print_result(query, result):
+ print(f"Search result (\"{query}\"):")
+ for r in result:
+ print(f"- text: \"{r.document}\", distance: {r.distance}")
+
+query = "a swimming animal"
+query_embedding = text_to_embedding(query)
+search_result = vector_store.query(query_embedding, k=3)
+print_result(query, search_result)
+```
+
+运行 `example.py` 文件,输出如下:
+
+```plain
+Search result ("a swimming animal"):
+- text: "fish", distance: 0.4562914811223072
+- text: "dog", distance: 0.6469335836410557
+- text: "tree", distance: 0.798545178640937
+```
+
+搜索结果中的三个词根据与查询向量的距离进行排序:距离越小,`document` 越相关。
+
+因此,根据输出,最有可能的游泳动物是 fish,或者是一只擅长游泳的 dog。
+
+## 另请参阅
+
+- [向量数据类型](/ai/reference/vector-search-data-types.md)
+- [向量搜索索引](/ai/reference/vector-search-index.md)
diff --git a/alert-rules.md b/alert-rules.md
index 49dfcd753e14..d8460951b761 100644
--- a/alert-rules.md
+++ b/alert-rules.md
@@ -1,7 +1,6 @@
---
title: TiDB 集群报警规则
summary: TiDB 集群中各组件的报警规则详解。
-aliases: ['/docs-cn/dev/alert-rules/','/docs-cn/dev/reference/alert-rules/']
---
# TiDB 集群报警规则
@@ -554,7 +553,7 @@ aliases: ['/docs-cn/dev/alert-rules/','/docs-cn/dev/reference/alert-rules/']
1. 从 TiDB 日志中查看慢查询日志,看查询是否用到了索引或全表扫,或者看是否需要做 analyze。
2. 排查是否有热点。
- 3. 查看 Coprocessor 监控,看 `coporcessor table/index scan` 里 `total` 和 `process` 是否匹配。如果相差太大,表明做了太多的无效查询。看是否有 `over seek bound`,如果有,表明版本太多,GC 工作不及时,需要增大并行 GC 的线程数。
+ 3. 查看 Coprocessor 监控,看 `coprocessor table/index scan` 里 `total` 和 `process` 是否匹配。如果相差太大,表明做了太多的无效查询。看是否有 `over seek bound`,如果有,表明版本太多,GC 工作不及时,需要增大并行 GC 的线程数。
#### `TiKV_raftstore_thread_cpu_seconds_total`
@@ -604,8 +603,8 @@ aliases: ['/docs-cn/dev/alert-rules/','/docs-cn/dev/reference/alert-rules/']
* 处理方法:
- 1. 查看 Scheduler-All 监控中的 scheduler command duration,看哪一个命令耗时最大。
- 2. 查看 Scheduler-All 监控中的 scheduler scan details,看 `total` 和 `process` 是否匹配。如果相差太大,表明有很多无效的扫描,另外观察是否有 `over seek bound`,如果太多,表明 GC 不及时。
+ 1. 查看 `Scheduler` 和 `Scheduler-${cmd}`(`${cmd}` 为指定待查询的写命令)监控中的 scheduler command duration,看哪一个命令耗时最大。
+ 2. 查看 `Scheduler` 和 `Scheduler-${cmd}` 监控中的 scheduler scan details,检查 `total` 和 `process` 是否匹配。如果相差太大,表明有很多无效的扫描。同时观察是否有 `over seek bound`,如果太多,表明 GC 不及时。
3. 查看 Storage 监控中的 storage async snapshot/write duration,看是否 Raft 操作不及时。
#### `TiKV_thread_apply_worker_cpu_seconds`
diff --git a/analyze-slow-queries.md b/analyze-slow-queries.md
index 17dcbc6d70a2..8005c593560e 100644
--- a/analyze-slow-queries.md
+++ b/analyze-slow-queries.md
@@ -96,9 +96,9 @@ summary: 学习如何定位和分析慢查询。
如上图,发给 `10.6.131.78` 的一个 `cop-task` 等待了 110ms 才被执行,可以判断是当时该实例忙,此时可以打开当时的 CPU 监控辅助判断。
-#### 过期 key 多
+#### 过期 MVCC 版本和 key 过多
-如果 TiKV 上过期的数据比较多,在扫描的时候则需要处理这些不必要的数据,影响处理速度。
+如果 TiKV 上过期 MVCC 版本过多,或 GC 历史版本数据的保留时间长,导致累积了过多 MVCC。处理这些不必要的 MVCC 版本会影响扫描速度。
这可以通过 `Total_keys` 和 `Processed_keys` 判断,如果两者相差较大,则说明旧版本的 key 太多:
@@ -108,6 +108,8 @@ summary: 学习如何定位和分析慢查询。
...
```
+TiDB v8.5.0 引入了内存引擎功能,可以加速这类慢查询。详见 [TiKV MVCC 内存引擎](/tikv-in-memory-engine.md)。
+
### 其他关键阶段慢
#### 取 TS 慢
diff --git a/api/_index.md b/api/_index.md
new file mode 100644
index 000000000000..f88d6575d1a1
--- /dev/null
+++ b/api/_index.md
@@ -0,0 +1,29 @@
+---
+title: TiDB API 概览
+summary: 了解 TiDB Cloud 和 TiDB 可用的 API。
+---
+
+# TiDB API 概览
+
+TiDB 提供了多种 API,可用于查询和运维集群、管理数据同步、监控系统状态等场景。本文介绍 [TiDB Cloud](https://docs.pingcap.com/zh/tidbcloud/) 和 [TiDB](https://docs.pingcap.com/zh/tidb/stable/) 的可用 API。
+
+## TiDB Cloud API (beta)
+
+[TiDB Cloud API](/api/tidb-cloud-api-overview.md) 是一个 [REST 接口](https://zh.wikipedia.org/wiki/表现层状态转换)。通过该 API,你可以以编程方式访问和操作 TiDB Cloud 中的各类管理资源,例如项目、集群、备份、恢复、导入、账单以及 Data Service。
+
+| API | 描述 |
+| --- | --- |
+| [v1beta1](/api/tidb-cloud-api-v1beta1.md) | 管理 TiDB Cloud Starter、Essential 与 Dedicated 集群,以及账单、Data Service 与 IAM 资源。 |
+| [v1beta](/api/tidb-cloud-api-v1beta.md) | 管理 TiDB Cloud 的项目、集群、备份、导入与恢复。 |
+
+## TiDB API
+
+TiDB 为相关 TiDB 工具提供了多种 API。通过这些 API,你可以管理集群组件、监控系统状态,并控制数据同步工作流。
+
+| API | 描述 |
+| --- | --- |
+| [TiProxy API](/tiproxy/tiproxy-api.md) | 获取 TiProxy 配置、健康状况以及监控数据。 |
+| [Data Migration API](/dm/dm-open-api.md) | 管理 DM-master 与 DM-worker 节点、数据源以及数据同步任务。 |
+| [监控 API](/tidb-monitoring-api.md) | 获取 TiDB Server 运行状态、数据表的存储信息以及 TiKV 集群的详细信息。 |
+| [TiCDC API](/ticdc/ticdc-open-api-v2.md) | 查询 TiCDC 节点状态并管理数据同步任务,包括任务的创建、暂停、恢复与更新等操作。 |
+| [TiDB Operator API](https://github.com/pingcap/tidb-operator/blob/{{{.tidb-operator-version}}}/docs/api-references/docs.md) | 管理 Kubernetes 上的 TiDB 集群,包括集群部署、升级、扩缩容、备份与故障转移等操作。 |
diff --git a/api/dm-api-overview.md b/api/dm-api-overview.md
new file mode 100644
index 000000000000..ac50f1600d8d
--- /dev/null
+++ b/api/dm-api-overview.md
@@ -0,0 +1,18 @@
+---
+title: Data Migration API 概览
+summary: 了解 Data Migration (DM) 的 API。
+---
+
+# Data Migration API 概览
+
+[TiDB Data Migration](/dm/dm-overview.md) (DM) 是一款便捷的数据迁移工具,支持从与 MySQL 协议兼容的数据库(例如 MySQL、MariaDB、Aurora MySQL)到 TiDB 的全量数据迁移和增量数据同步。
+
+DM 提供了用于查询与操作 DM 集群的 OpenAPI,其功能范围与 [dmctl 工具](/dm/dmctl-introduction.md)相当。
+
+你可以使用 DM API 对 DM 集群执行以下运维操作:
+
+- [集群管理](/dm/dm-open-api.md#集群相关-api):获取 DM-master 与 DM-worker 节点信息,或下线相应节点。
+- [数据源管理](/dm/dm-open-api.md#数据源相关-api):创建、更新、删除、启用或停用数据源,管理 relay-log 功能,更新数据源与 DM-worker 的绑定关系。
+- [同步任务管理](/dm/dm-open-api.md#同步任务相关-api):创建、更新、删除、开始或停止同步任务;管理 schema 与迁移规则。
+
+关于各个 API 的请求参数、响应示例与使用说明,请参阅[使用 OpenAPI 运维 TiDB Data Migration 集群](/dm/dm-open-api.md)。
diff --git a/api/monitoring-api-overview.md b/api/monitoring-api-overview.md
new file mode 100644
index 000000000000..146e1f592644
--- /dev/null
+++ b/api/monitoring-api-overview.md
@@ -0,0 +1,15 @@
+---
+title: TiDB 监控 API 概览
+summary: 了解 TiDB 监控服务的 API。
+---
+
+# TiDB 监控 API 概览
+
+TiDB 的监控框架基于 [Prometheus](https://prometheus.io) 和 [Grafana](https://grafana.com/grafana) 这两个开源项目。TiDB 使用 Prometheus 存储监控和性能指标,使用 Grafana 可视化展示这些指标,并提供内置的 [TiDB Dashboard](/dashboard/dashboard-intro.md) 图形化界面,用于监控及诊断 TiDB 集群。
+
+你可以使用以下 API 监控 TiDB 集群状态:
+
+- [状态接口](/tidb-monitoring-api.md#使用状态接口):监控当前 TiDB Server 的[运行状态](/tidb-monitoring-api.md#运行状态),以及某张表的[存储信息](/tidb-monitoring-api.md#存储信息)。
+- [Metrics 接口](/tidb-monitoring-api.md#使用-metrics-接口):获取各组件中不同操作的详细指标信息,可通过 Grafana 查看这些指标。
+
+关于各个 API 的请求参数、响应示例与使用说明,请参阅 [TiDB 监控 API](/tidb-monitoring-api.md)。
diff --git a/api/ticdc-api-overview.md b/api/ticdc-api-overview.md
new file mode 100644
index 000000000000..53925e686bd8
--- /dev/null
+++ b/api/ticdc-api-overview.md
@@ -0,0 +1,19 @@
+---
+title: TiCDC API 概览
+summary: 了解 TiCDC 的 API。
+---
+
+# TiCDC API 概览
+
+[TiCDC](/ticdc/ticdc-overview.md) 是一款 TiDB 增量数据同步工具,通过拉取上游 TiKV 的数据变更日志,TiCDC 可以将数据解析为有序的行级变更数据输出到下游。
+
+TiCDC 提供以下两个版本的 API,用于查询与运维 TiCDC 集群:
+
+- [TiCDC OpenAPI v1](/ticdc/ticdc-open-api.md)
+- [TiCDC OpenAPI v2](/ticdc/ticdc-open-api-v2.md)
+
+> **注意:**
+>
+> TiCDC OpenAPI v1 将在未来版本中被删除。推荐使用 TiCDC OpenAPI v2。
+
+关于各个 API 的请求参数、响应示例与使用说明,请参阅 [TiCDC OpenAPI v1](/ticdc/ticdc-open-api.md) 与 [TiCDC OpenAPI v2](/ticdc/ticdc-open-api-v2.md)。
diff --git a/api/tidb-cloud-api-overview.md b/api/tidb-cloud-api-overview.md
new file mode 100644
index 000000000000..43e13161030c
--- /dev/null
+++ b/api/tidb-cloud-api-overview.md
@@ -0,0 +1,24 @@
+---
+title: TiDB Cloud API 概览
+summary: 了解 TiDB Cloud API 的定义、特性,以及如何使用该 API 管理 TiDB Cloud 集群。
+aliases: ['/zh/tidbcloud/api-overview/']
+---
+
+# TiDB Cloud API 概览
+
+> **注意:**
+>
+> TiDB Cloud API 目前处于 beta 阶段。
+
+TiDB Cloud API 是一个 [REST 接口](https://zh.wikipedia.org/wiki/表现层状态转换),提供了以编程方式访问和操作 TiDB Cloud 中的各类管理资源的能力。通过该 API,你可以自动且高效地管理项目、集群、备份、恢复、导入、账单,以及 [Data Service](https://docs.pingcap.com/tidbcloud/data-service-overview) 中的相关资源。
+
+该 API 具有以下特性:
+
+- **JSON 实体 (JSON entities)**:API 中的所有资源和数据均使用 JSON 格式。
+- **仅支持 HTTPS**:仅支持通过 HTTPS 访问该 API,从而确保所有通过网络传输的数据均经过 TLS 加密。
+- **基于密钥的访问与摘要认证**:在访问 TiDB Cloud API 之前,你需要先生成一个 API key。具体步骤请参阅 [API Key Management](https://docs.pingcap.com/tidbcloud/api/v1beta#section/Authentication/API-key-management)。所有请求都会通过 [HTTP 摘要认证](https://zh.wikipedia.org/wiki/HTTPP摘要认证)进行身份验证,从而确保 API key 不会以明文形式在网络中传输。
+
+TiDB Cloud API 提供以下两个版本:
+
+- [v1beta1](/api/tidb-cloud-api-v1beta1.md):管理 TiDB Cloud Starter、Essential 与 Dedicated 集群,以及账单、Data Service 与 IAM 资源。
+- [v1beta](/api/tidb-cloud-api-v1beta.md):管理 TiDB Cloud 的项目、集群、备份、导入与恢复。
diff --git a/api/tidb-cloud-api-v1beta.md b/api/tidb-cloud-api-v1beta.md
new file mode 100644
index 000000000000..6b1f9969cc7a
--- /dev/null
+++ b/api/tidb-cloud-api-v1beta.md
@@ -0,0 +1,16 @@
+---
+title: TiDB Cloud API v1beta 概览
+summary: 了解 TiDB Cloud 的 v1beta API。
+---
+
+# TiDB Cloud API v1beta 概览
+
+[v1beta API](https://docs.pingcap.com/tidbcloud/api/v1beta) 是一个 RESTful API,提供了以编程方式访问和操作 TiDB Cloud 中的各类管理资源的能力。通过该 API,你可以自动且高效地管理项目、集群、备份、恢复与导入等资源。
+
+目前,你可以使用以下 v1beta API 来管理 TiDB Cloud 中的资源:
+
+- [Project](https://docs.pingcap.com/tidbcloud/api/v1beta/#tag/Project)
+- [Cluster](https://docs.pingcap.com/tidbcloud/api/v1beta/#tag/Cluster)
+- [Backup](https://docs.pingcap.com/tidbcloud/api/v1beta/#tag/Backup)
+- [Import(已弃用)](https://docs.pingcap.com/tidbcloud/api/v1beta/#tag/Import)
+- [Restore](https://docs.pingcap.com/tidbcloud/api/v1beta/#tag/Restore)
\ No newline at end of file
diff --git a/api/tidb-cloud-api-v1beta1.md b/api/tidb-cloud-api-v1beta1.md
new file mode 100644
index 000000000000..2986c2ce0814
--- /dev/null
+++ b/api/tidb-cloud-api-v1beta1.md
@@ -0,0 +1,19 @@
+---
+title: TiDB Cloud API v1beta1 概览
+summary: 了解 TiDB Cloud 的 v1beta1 API。
+---
+
+# TiDB Cloud API v1beta1 概览
+
+TiDB Cloud API v1beta1 是一个 RESTful API,提供了以编程方式访问和操作 TiDB Cloud 中的各类管理资源的能力。通过该 API,你可以自动且高效地管理集群级的资源(如集群与分支),以及组织或项目级的资源(如计费、Data Service 与 IAM)。
+
+目前,你可以使用以下 v1beta1 API 来管理 TiDB Cloud 中的资源:
+
+- 集群级资源:
+ - [TiDB Cloud Starter 或 Essential 集群](https://docs.pingcap.com/tidbcloud/api/v1beta1/serverless):管理 TiDB Cloud Starter 或 Essential 的集群、分支、数据导出任务与数据导入任务。
+ - [TiDB Cloud Dedicated 集群](https://docs.pingcap.com/tidbcloud/api/v1beta1/dedicated):管理 TiDB Cloud Dedicated 的集群、区域 (region)、Private Endpoint 连接以及数据导入任务。
+- 组织或项目级资源:
+ - [Billing](https://docs.pingcap.com/tidbcloud/api/v1beta1/billing):管理 TiDB Cloud 集群的账单。
+ - [Data Service](https://docs.pingcap.com/tidbcloud/api/v1beta1/dataservice):管理 TiDB Cloud 集群 Data Service 中的资源。
+ - [IAM](https://docs.pingcap.com/tidbcloud/api/v1beta1/iam):管理 TiDB Cloud 集群的 API key。
+ - [MSP(已弃用)](https://docs.pingcap.com/tidbcloud/api/v1beta1/msp)
\ No newline at end of file
diff --git a/api/tidb-operator-api-overview.md b/api/tidb-operator-api-overview.md
new file mode 100644
index 000000000000..fddff41c4ec6
--- /dev/null
+++ b/api/tidb-operator-api-overview.md
@@ -0,0 +1,20 @@
+---
+title: TiDB Operator API 概览
+summary: 了解 TiDB Operator 的 API 接口。
+---
+
+# TiDB Operator API 概览
+
+[TiDB Operator](https://docs.pingcap.com/zh/tidb-in-kubernetes/stable/) 是 Kubernetes 上的 TiDB 集群自动运维系统,提供包括部署、升级、扩缩容、备份恢复、配置变更的 TiDB 全生命周期管理。借助 TiDB Operator,TiDB 可以无缝运行在公有云或自托管的 Kubernetes 集群上。
+
+要在 Kubernetes 上管理 TiDB 集群,你可以使用以下 TiDB Operator API:
+
+- [Backup](https://github.com/pingcap/tidb-operator/blob/{{{.tidb-operator-version}}}/docs/api-references/docs.md#backup)
+- [BackupSchedule](https://github.com/pingcap/tidb-operator/blob/{{{.tidb-operator-version}}}/docs/api-references/docs.md#backupschedule)
+- [DMCluster](https://github.com/pingcap/tidb-operator/blob/{{{.tidb-operator-version}}}/docs/api-references/docs.md#dmcluster)
+- [Restore](https://github.com/pingcap/tidb-operator/blob/{{{.tidb-operator-version}}}/docs/api-references/docs.md#restore)
+- [TidbCluster](https://github.com/pingcap/tidb-operator/blob/{{{.tidb-operator-version}}}/docs/api-references/docs.md#tidbcluster)
+- [TidbInitializer](https://github.com/pingcap/tidb-operator/blob/{{{.tidb-operator-version}}}/docs/api-references/docs.md#tidbinitializer)
+- [TidbMonitor](https://github.com/pingcap/tidb-operator/blob/{{{.tidb-operator-version}}}/docs/api-references/docs.md#tidbmonitor)
+
+更多信息,请参阅 [TiDB Operator API 文档](https://github.com/pingcap/tidb-operator/blob/{{{.tidb-operator-version}}}/docs/api-references/docs.md)。
diff --git a/api/tiproxy-api-overview.md b/api/tiproxy-api-overview.md
new file mode 100644
index 000000000000..362fdf9fa904
--- /dev/null
+++ b/api/tiproxy-api-overview.md
@@ -0,0 +1,19 @@
+---
+title: TiProxy API 概览
+summary: 了解 TiProxy 的 API。
+---
+
+# TiProxy API 概览
+
+[TiProxy](/tiproxy/tiproxy-overview.md) 是 PingCAP 的官方代理组件,它放置在客户端和 TiDB server 之间,为 TiDB 提供负载均衡、连接保持、服务发现等功能。
+
+TiProxy 是可选组件,你也可以使用第三方的代理组件,或者直接连接到 TiDB server。
+
+通过 TiProxy API,你可以对 TiProxy 集群执行以下操作:
+
+- [获取 TiProxy 配置](/tiproxy/tiproxy-api.md#获取-tiproxy-的配置)
+- [设置 TiProxy 配置](/tiproxy/tiproxy-api.md#设置-tiproxy-的配置)
+- [获取 TiProxy 健康状况](/tiproxy/tiproxy-api.md#获取-tiproxy-的健康状况)
+- [获取 TiProxy 监控数据](/tiproxy/tiproxy-api.md#获取-tiproxy-的监控数据)
+
+关于各个 API 的请求参数、响应示例与使用说明,请参阅 [TiProxy API](/tiproxy/tiproxy-api.md)。
\ No newline at end of file
diff --git a/auto-increment.md b/auto-increment.md
index c5250a9dc6af..00a54783fd47 100644
--- a/auto-increment.md
+++ b/auto-increment.md
@@ -1,7 +1,6 @@
---
title: AUTO_INCREMENT
summary: 介绍 TiDB 的 `AUTO_INCREMENT` 列属性。
-aliases: ['/docs-cn/dev/auto-increment/']
---
# AUTO_INCREMENT
@@ -22,7 +21,7 @@ aliases: ['/docs-cn/dev/auto-increment/']
> **注意:**
>
-> 如果要求自增编号在所有 TiDB 实例上具有单调性,并且你的 TiDB 版本在 v6.5.0 及以上,推荐使用 [MySQL 兼容模式](#mysql-兼容模式)。
+> 如果要求自增编号在所有 TiDB 实例上具有单调性,并且你的 TiDB 版本在 v6.5.0 及以上,推荐使用[兼容 MySQL 的自增列模式](#兼容-mysql-的自增列模式)。
{{< copyable "sql" >}}
@@ -334,6 +333,7 @@ SELECT * FROM t;
在一些场景中,你可能需要清除自增 ID 缓存,以保证数据一致性。例如:
- 使用 [Data Migration (DM)](/dm/dm-overview.md) 进行增量同步,当同步结束后,下游 TiDB 的数据写入方式将从 DM 切换回正常的业务数据写入,此时自增列 ID 的写入模式通常由显式写入转换成隐式分配。
+- TiDB Lightning 完成数据导入后会自动清除自增 ID 缓存,但 TiCDC 在增量同步后不会自动清除。因此,在停止 TiCDC 并进行主备切换之前,需要手动清除下游集群的自增 ID 缓存。
- 当业务同时使用了显式写入和隐式分配时,需要清除自增 ID 缓存,以防止后续隐式分配的自增 ID 与已显式写入的 ID 发生冲突,导致主键冲突错误。具体场景参考[唯一性保证](/auto-increment.md#唯一性保证)。
你可以执行 `ALTER TABLE` 语句设置 `AUTO_INCREMENT = 0` 来清除集群中所有 TiDB 节点的自增 ID 缓存。例如:
@@ -388,27 +388,51 @@ SELECT * FROM t;
从 v3.0.9 和 v4.0.rc-1 开始,和 MySQL 的行为类似,自增列隐式分配的值遵循 session 变量 `@@auto_increment_increment` 和 `@@auto_increment_offset` 的控制,其中自增列隐式分配的值 (ID) 将满足式子 `(ID - auto_increment_offset) % auto_increment_increment == 0`。
-## MySQL 兼容模式
+## 兼容 MySQL 的自增列模式
-从 v6.4.0 开始,TiDB 实现了中心化分配自增 ID 的服务,可以支持 TiDB 实例不缓存数据,而是每次请求都访问中心化服务获取 ID。
+TiDB 提供了一种兼容 MySQL 的自增列模式,该模式能确保 ID 严格递增且间隙最小。要启用此模式,需在建表时将 `AUTO_ID_CACHE` 设置为 `1`:
-当前中心化分配服务内置在 TiDB 进程,类似于 DDL Owner 的工作模式。有一个 TiDB 实例将充当“主”的角色提供 ID 分配服务,而其它的 TiDB 实例将充当“备”角色。当“主”节点发生故障时,会自动进行“主备切换”,从而保证中心化服务的高可用。
+```sql
+CREATE TABLE t(a int AUTO_INCREMENT key) AUTO_ID_CACHE 1;
+```
+
+当 `AUTO_ID_CACHE` 设置为 `1` 时,所有 TiDB 实例生成的 ID 严格全局递增,每个 ID 保证全局唯一,相较于默认缓存模式(`AUTO_ID_CACHE 0` 具有 30000 个缓存值),ID 间隙显著缩小。
-MySQL 兼容模式的使用方式是,建表时将 `AUTO_ID_CACHE` 设置为 `1`:
+例如,启用 `AUTO_ID_CACHE 1` 后可以生成如下序列:
```sql
-CREATE TABLE t(a int AUTO_INCREMENT key) AUTO_ID_CACHE 1;
+INSERT INTO t VALUES (); -- Returns ID 1
+INSERT INTO t VALUES (); -- Returns ID 2
+INSERT INTO t VALUES (); -- Returns ID 3
+-- After failover
+INSERT INTO t VALUES (); -- Might return ID 5
+```
+
+相比之下,使用默认缓存(`AUTO_ID_CACHE 0`)时可能出现较大间隙:
+
+```sql
+INSERT INTO t VALUES (); -- Returns ID 1
+INSERT INTO t VALUES (); -- Returns ID 2
+-- New TiDB instance allocates next batch
+INSERT INTO t VALUES (); -- Returns ID 30001
```
+尽管 `AUTO_ID_CACHE 1` 能保证 ID 严格递增且不会出现类似 `AUTO_ID_CACHE 0` 的大幅间隙,但在以下场景中仍可能出现微小间隙。这些间隙是维持 ID 全局唯一性和严格递增特性的必要代价:
+
+- 主实例退出或崩溃的故障恢复期间
+
+ 使用兼容 MySQL 的自增列模式后,能保证 ID **唯一**、**单调递增**,行为几乎跟 MySQL 完全一致。即使跨 TiDB 实例访问,ID 也不会出现回退。只有在中心化分配自增 ID 服务的“主” TiDB 实例进程退出(如该 TiDB 节点重启)或者异常崩溃时,才有可能造成部分 ID 不连续。这是因为主备切换时,“备” 节点需要丢弃一部分之前的“主” 节点已经分配的 ID,以保证 ID 不出现重复。
+
+- TiDB 节点滚动升级期间
+- 正常并发事务场景(与 MySQL 类似)
+
> **注意:**
>
-> 在 TiDB 各个版本中,`AUTO_ID_CACHE` 设置为 `1` 都表明 TiDB 不再缓存 ID,但是不同版本的实现方式不一样:
+> `AUTO_ID_CACHE 1` 的行为和性能在不同 TiDB 版本中的演进如下:
>
-> - 对于 TiDB v6.4.0 之前的版本,由于每次分配 ID 都需要通过一个 TiKV 事务完成 `AUTO_INCREMENT` 值的持久化修改,因此设置 `AUTO_ID_CACHE` 为 `1` 会出现性能下降。
-> - 对于 v6.4.0 及以上版本,由于引入了中心化的分配服务,`AUTO_INCREMENT` 值的修改只是在 TiDB 服务进程中的一个内存操作,相较于之前版本更快。
-> - 将 `AUTO_ID_CACHE` 设置为 `0` 表示 TiDB 使用默认的缓存大小 `30000`。
-
-使用 MySQL 兼容模式后,能保证 ID **唯一**、**单调递增**,行为几乎跟 MySQL 完全一致。即使跨 TiDB 实例访问,ID 也不会出现回退。只有在中心化分配自增 ID 服务的“主” TiDB 实例进程退出(如该 TiDB 节点重启)或者异常崩溃时,才有可能造成部分 ID 不连续。这是因为主备切换时,“备” 节点需要丢弃一部分之前的“主” 节点已经分配的 ID,以保证 ID 不出现重复。
+> - v6.4.0 之前:每次 ID 分配需通过一个 TiKV 事务完成,会影响性能。
+> - v6.4.0 起:引入集中式分配服务,ID 分配转为内存操作,性能显著提升。
+> - v8.1.0 起:移除主节点退出时的自动 `forceRebase` 操作以实现快速重启。虽然故障恢复时可能产生额外非连续 ID,但可避免大量表使用 `AUTO_ID_CACHE 1` 时可能出现的写入阻塞。
## 使用限制
diff --git a/auto-random.md b/auto-random.md
index 14995980c9fa..f067f1a5e7dc 100644
--- a/auto-random.md
+++ b/auto-random.md
@@ -1,7 +1,6 @@
---
title: AUTO_RANDOM
summary: 本文介绍了 TiDB 的 `AUTO_RANDOM` 列属性。
-aliases: ['/docs-cn/dev/auto-random/','/docs-cn/dev/reference/sql/attributes/auto-random/']
---
# AUTO_RANDOM 从 v3.1.0 版本开始引入
@@ -159,6 +158,42 @@ SHOW WARNINGS;
`AUTO_RANDOM` 列隐式分配的值和自增列类似,也遵循 session 变量 [`auto_increment_increment`](/system-variables.md#auto_increment_increment) 和 [`auto_increment_offset`](/system-variables.md#auto_increment_offset) 的控制,其中隐式分配值的自增位 (ID) 满足等式 `(ID - auto_increment_offset) % auto_increment_increment == 0`。
+## 清除自增 ID 缓存
+
+在部署了多个 TiDB 实例的集群中,向 `AUTO_RANDOM` 列插入显式值时,可能会发生 ID 冲突,与 `AUTO_INCREMENT` 列类似。如果显式插入的 ID 值与 TiDB 用于自动生成的内部计数器冲突,可能会导致错误。
+
+冲突发生的原因如下:每个 `AUTO_RANDOM` ID 由随机位 (Random Bits) 和自增部分组成。TiDB 使用内部计数器来生成自增部分。如果显式插入的 ID 的自增部分恰好等于计数器的下一个值,则此后当 TiDB 尝试自动生成该相同 ID 时,可能会发生重复键错误。更多详细信息,请参阅 [`AUTO_INCREMENT` 唯一性保证](/auto-increment.md#唯一性保证)。
+
+在单个 TiDB 实例中,该问题不会发生,因为节点在处理显式插入时会自动调整其内部计数器,从而防止冲突。相比之下,在有多个 TiDB 节点的环境中,每个节点维护自己的 ID 缓存,所以你需要清除这些缓存以防止显式插入后发生冲突。要清除这些未分配的缓存 ID 并避免潜在的冲突,有以下两种方法:
+
+### 方法 1:自动重置基值(推荐方式)
+
+```sql
+ALTER TABLE t AUTO_RANDOM_BASE=0;
+```
+
+该语句会自动确定一个合适的基值。尽管执行后会返回类似于 `Can't reset AUTO_INCREMENT to 0 without FORCE option, using XXX instead` 的警告信息,但基值确实会被更新,因此你可以忽略此警告。
+
+> **注意:**
+>
+> 不能使用 `FORCE` 关键字将 `AUTO_RANDOM_BASE` 设置为 `0`,否则会导致错误。
+
+### 方法 2:手动设置特定的基值
+
+如果需要设置一个特定的基值(例如 `1000`),可以使用 `FORCE` 关键字:
+
+```sql
+ALTER TABLE t FORCE AUTO_RANDOM_BASE = 1000;
+```
+
+但是这种方法并不方便,因为你需要自行确定合适的基值。
+
+> **注意:**
+>
+> 使用 `FORCE` 时,必须指定一个非零的正整数。
+
+以上两个方法中的语句均会修改所有 TiDB 节点上生成 `AUTO_RANDOM` 值时使用的自增位起始值,但不会影响已经分配的 ID。
+
## 使用限制
目前在 TiDB 中使用 `AUTO_RANDOM` 有以下限制:
diff --git a/basic-features.md b/basic-features.md
index 291b9d1fed82..0ad6e4319678 100644
--- a/basic-features.md
+++ b/basic-features.md
@@ -1,7 +1,6 @@
---
title: TiDB 功能概览
summary: 了解 TiDB 的功能概览。
-aliases: ['/docs-cn/dev/basic-features/','/docs-cn/dev/experimental-features-4.0/','/zh/tidb/dev/experimental-features-4.0/','/zh/tidb/dev/experimental-features']
---
# TiDB 功能概览
@@ -20,253 +19,255 @@ aliases: ['/docs-cn/dev/basic-features/','/docs-cn/dev/experimental-features-4.0
## 数据类型,函数和操作符
-| 数据类型,函数,操作符 | 8.4 | 8.3 | 8.2 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 | 5.3 | 5.2 | 5.1 |
-|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| [数值类型](/data-type-numeric.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [日期和时间类型](/data-type-date-and-time.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [字符串类型](/data-type-string.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [JSON 类型](/data-type-json.md) | Y | Y | Y | Y | Y | Y | Y | E | E | E | E | E |
-| [向量数据类型](/vector-search-data-types.md) | E | N | N | N | N | N | N | N | N | N | N | N |
-| [控制流程函数](/functions-and-operators/control-flow-functions.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [字符串函数](/functions-and-operators/string-functions.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [数值函数与操作符](/functions-and-operators/numeric-functions-and-operators.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [日期和时间函数](/functions-and-operators/date-and-time-functions.md)| Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [位函数和操作符](/functions-and-operators/bit-functions-and-operators.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Cast 函数和操作符](/functions-and-operators/cast-functions-and-operators.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [加密和压缩函数](/functions-and-operators/encryption-and-compression-functions.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [向量函数和操作符](/vector-search-functions-and-operators.md) | E | N | N | N | N | N | N | N | N | N | N | N |
-| [信息函数](/functions-and-operators/information-functions.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [JSON 函数](/functions-and-operators/json-functions.md) | Y | Y | Y | Y | Y | Y | Y | E | E | E | E | E |
-| [聚合函数](/functions-and-operators/aggregate-group-by-functions.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [窗口函数](/functions-and-operators/window-functions.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [其他函数](/functions-and-operators/miscellaneous-functions.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [操作符](/functions-and-operators/operators.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [字符集和排序规则](/character-set-and-collation.md) [^1] | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [用户级别锁](/functions-and-operators/locking-functions.md) | Y | Y | Y | Y | Y | Y | Y | Y | N | N | N | N |
+| 数据类型,函数,操作符 | 8.5 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| [数值类型](/data-type-numeric.md) | Y | Y | Y | Y | Y | Y | Y |
+| [日期和时间类型](/data-type-date-and-time.md) | Y | Y | Y | Y | Y | Y | Y |
+| [字符串类型](/data-type-string.md) | Y | Y | Y | Y | Y | Y | Y |
+| [JSON 类型](/data-type-json.md) | Y | Y | Y | Y | Y | E | E |
+| [向量数据类型](/ai/reference/vector-search-data-types.md) | E | N | N | N | N | N | N |
+| [控制流程函数](/functions-and-operators/control-flow-functions.md) | Y | Y | Y | Y | Y | Y | Y |
+| [字符串函数](/functions-and-operators/string-functions.md) | Y | Y | Y | Y | Y | Y | Y |
+| [数值函数与操作符](/functions-and-operators/numeric-functions-and-operators.md) | Y | Y | Y | Y | Y | Y | Y |
+| [日期和时间函数](/functions-and-operators/date-and-time-functions.md)| Y | Y | Y | Y | Y | Y | Y |
+| [位函数和操作符](/functions-and-operators/bit-functions-and-operators.md) | Y | Y | Y | Y | Y | Y | Y |
+| [Cast 函数和操作符](/functions-and-operators/cast-functions-and-operators.md) | Y | Y | Y | Y | Y | Y | Y |
+| [加密和压缩函数](/functions-and-operators/encryption-and-compression-functions.md) | Y | Y | Y | Y | Y | Y | Y |
+| [向量函数和操作符](/ai/reference/vector-search-functions-and-operators.md) | E | N | N | N | N | N | N |
+| [信息函数](/functions-and-operators/information-functions.md) | Y | Y | Y | Y | Y | Y | Y |
+| [JSON 函数](/functions-and-operators/json-functions.md) | Y | Y | Y | Y | Y | E | E |
+| [聚合函数](/functions-and-operators/aggregate-group-by-functions.md) | Y | Y | Y | Y | Y | Y | Y |
+| [窗口函数](/functions-and-operators/window-functions.md) | Y | Y | Y | Y | Y | Y | Y |
+| [其他函数](/functions-and-operators/miscellaneous-functions.md) | Y | Y | Y | Y | Y | Y | Y |
+| [操作符](/functions-and-operators/operators.md) | Y | Y | Y | Y | Y | Y | Y |
+| [字符集和排序规则](/character-set-and-collation.md) [^1] | Y | Y | Y | Y | Y | Y | Y |
+| [用户级别锁](/functions-and-operators/locking-functions.md) | Y | Y | Y | Y | Y | Y | N |
## 索引和约束
-| 索引和约束 | 8.4 | 8.3 | 8.2 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 | 5.3 | 5.2 | 5.1 |
-|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| [表达式索引](/sql-statements/sql-statement-create-index.md#表达式索引) [^2] | Y | Y | Y | Y | Y | Y | Y | E | E | E | E | E |
-| [列式存储 (TiFlash)](/tiflash/tiflash-overview.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [使用 FastScan 加速 OLAP 场景下的查询](/tiflash/use-fastscan.md) | Y | Y | Y | Y | Y | Y | E | N | N | N | N | N |
-| [RocksDB 引擎](/storage-engine/rocksdb-overview.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Titan 插件](/storage-engine/titan-overview.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Titan Level Merge](/storage-engine/titan-configuration.md#level-merge实验功能) | E | E | E | E | E | E | E | E | E | E | E | E |
-| [使用 bucket 提高数据扫描并发度](/tune-region-performance.md#使用-bucket-增加并发) | E | E | E | E | E | E | E | E | N | N | N | N |
-| [不可见索引](/sql-statements/sql-statement-create-index.md#不可见索引) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [复合主键](/constraints.md#主键约束) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [`CHECK` 约束](/constraints.md#check-约束) | Y | Y | Y | Y | Y | N | N | N | N | N | N | N |
-| [唯一约束](/constraints.md#唯一约束) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [整型主键上的聚簇索引](/clustered-indexes.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [复合或非整型主键上的聚簇索引](/clustered-indexes.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [多值索引](/sql-statements/sql-statement-create-index.md#多值索引) | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N |
-| [外键约束](/constraints.md#外键约束) | E | E | E | E | E | E | N | N | N | N | N | N |
-| [TiFlash 延迟物化](/tiflash/tiflash-late-materialization.md) | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N |
-| [全局索引 (Global Index)](/partitioned-table.md#全局索引) | Y | E | N | N | N | N | N | N | N | N | N | N |
-| [向量索引](/vector-search-index.md) | E | N | N | N | N | N | N | N | N | N | N | N |
+| 索引和约束 | 8.5 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| [表达式索引](/sql-statements/sql-statement-create-index.md#表达式索引) [^2] | Y | Y | Y | Y | Y | E | E |
+| [列式存储 (TiFlash)](/tiflash/tiflash-overview.md) | Y | Y | Y | Y | Y | Y | Y |
+| [使用 FastScan 加速 OLAP 场景下的查询](/tiflash/use-fastscan.md) | Y | Y | Y | Y | E | N | N |
+| [RocksDB 引擎](/storage-engine/rocksdb-overview.md) | Y | Y | Y | Y | Y | Y | Y |
+| [Titan 插件](/storage-engine/titan-overview.md) | Y | Y | Y | Y | Y | Y | Y |
+| [Titan Level Merge](/storage-engine/titan-configuration.md#level-merge实验功能) | E | E | E | E | E | E | E |
+| [使用 bucket 提高数据扫描并发度](/tune-region-performance.md#使用-bucket-增加并发) | E | E | E | E | E | E | N |
+| [不可见索引](/sql-statements/sql-statement-create-index.md#不可见索引) | Y | Y | Y | Y | Y | Y | Y |
+| [复合主键](/constraints.md#主键约束) | Y | Y | Y | Y | Y | Y | Y |
+| [`CHECK` 约束](/constraints.md#check-约束) | Y | Y | Y | N | N | N | N |
+| [唯一约束](/constraints.md#唯一约束) | Y | Y | Y | Y | Y | Y | Y |
+| [整型主键上的聚簇索引](/clustered-indexes.md) | Y | Y | Y | Y | Y | Y | Y |
+| [复合或非整型主键上的聚簇索引](/clustered-indexes.md) | Y | Y | Y | Y | Y | Y | Y |
+| [多值索引](/sql-statements/sql-statement-create-index.md#多值索引) | Y | Y | Y | Y | N | N | N |
+| [外键约束](/foreign-key.md) | Y | E | E | E | N | N | N |
+| [TiFlash 延迟物化](/tiflash/tiflash-late-materialization.md) | Y | Y | Y | Y | N | N | N |
+| [全局索引 (Global Index)](/global-indexes.md) | Y | N | N | N | N | N | N |
+| [向量索引](/ai/reference/vector-search-index.md) | E | N | N | N | N | N | N |
## SQL 语句
-| SQL 语句 [^3] | 8.4 | 8.3 | 8.2 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 | 5.3 | 5.2 | 5.1 |
-|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| `SELECT`,`INSERT`,`UPDATE`,`DELETE`,`REPLACE` | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| `INSERT ON DUPLICATE KEY UPDATE` | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| `LOAD DATA INFILE` | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| `SELECT INTO OUTFILE` | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| `INNER JOIN`, LEFT\|RIGHT [OUTER] JOIN | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| `UNION`,`UNION ALL` | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [`EXCEPT` 和 `INTERSECT` 运算符](/functions-and-operators/set-operators.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| `GROUP BY`,`ORDER BY` | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [`GROUP BY` 修饰符](/functions-and-operators/group-by-modifier.md) | Y | Y | Y | Y | Y | N | N | N | N | N | N | N |
-| [窗口函数](/functions-and-operators/window-functions.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [公共表表达式 (CTE)](/sql-statements/sql-statement-with.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| `START TRANSACTION`,`COMMIT`,`ROLLBACK` | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [`EXPLAIN`](/sql-statements/sql-statement-explain.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [`EXPLAIN ANALYZE`](/sql-statements/sql-statement-explain-analyze.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [用户自定义变量](/user-defined-variables.md) | E | E | E | E | E | E | E | E | E | E | E | E |
-| [`BATCH [ON COLUMN] LIMIT INTEGER DELETE`](/sql-statements/sql-statement-batch.md) | Y | Y | Y | Y | Y | Y | Y | Y | N | N | N | N |
-| [`BATCH [ON COLUMN] LIMIT INTEGER INSERT/UPDATE/REPLACE`](/sql-statements/sql-statement-batch.md) | Y | Y | Y | Y | Y | Y | Y | N | N | N | N | N |
-| [`ALTER TABLE ... COMPACT`](/sql-statements/sql-statement-alter-table-compact.md) | Y | Y | Y | Y | Y | Y | Y | E | N | N | N | N |
-| [表级锁 (Table Lock)](/sql-statements/sql-statement-lock-tables-and-unlock-tables.md) | E | E | E | E | E | E | E | E | E | E | E | E |
-| [物化列式存储的查询结果](/tiflash/tiflash-results-materialization.md) | Y | Y | Y | Y | Y | Y | E | N | N | N | N | N |
+| SQL 语句 [^3] | 8.5 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| `SELECT`,`INSERT`,`UPDATE`,`DELETE`,`REPLACE` | Y | Y | Y | Y | Y | Y | Y |
+| `INSERT ON DUPLICATE KEY UPDATE` | Y | Y | Y | Y | Y | Y | Y |
+| `LOAD DATA INFILE` | Y | Y | Y | Y | Y | Y | Y |
+| `SELECT INTO OUTFILE` | Y | Y | Y | Y | Y | Y | Y |
+| `INNER JOIN`, LEFT\|RIGHT [OUTER] JOIN | Y | Y | Y | Y | Y | Y | Y |
+| `UNION`,`UNION ALL` | Y | Y | Y | Y | Y | Y | Y |
+| [`EXCEPT` 和 `INTERSECT` 运算符](/functions-and-operators/set-operators.md) | Y | Y | Y | Y | Y | Y | Y |
+| `GROUP BY`,`ORDER BY` | Y | Y | Y | Y | Y | Y | Y |
+| [`GROUP BY` 修饰符](/functions-and-operators/group-by-modifier.md) | Y | Y | Y | N | N | N | N |
+| [窗口函数](/functions-and-operators/window-functions.md) | Y | Y | Y | Y | Y | Y | Y |
+| [公共表表达式 (CTE)](/sql-statements/sql-statement-with.md) | Y | Y | Y | Y | Y | Y | Y |
+| `START TRANSACTION`,`COMMIT`,`ROLLBACK` | Y | Y | Y | Y | Y | Y | Y |
+| [`EXPLAIN`](/sql-statements/sql-statement-explain.md) | Y | Y | Y | Y | Y | Y | Y |
+| [`EXPLAIN ANALYZE`](/sql-statements/sql-statement-explain-analyze.md) | Y | Y | Y | Y | Y | Y | Y |
+| [用户自定义变量](/user-defined-variables.md) | E | E | E | E | E | E | E |
+| [`BATCH [ON COLUMN] LIMIT INTEGER DELETE`](/sql-statements/sql-statement-batch.md) | Y | Y | Y | Y | Y | Y | N |
+| [`BATCH [ON COLUMN] LIMIT INTEGER INSERT/UPDATE/REPLACE`](/sql-statements/sql-statement-batch.md) | Y | Y | Y | Y | Y | N | N |
+| [`ALTER TABLE ... COMPACT`](/sql-statements/sql-statement-alter-table-compact.md) | Y | Y | Y | Y | Y | E | N |
+| [表级锁 (Table Lock)](/sql-statements/sql-statement-lock-tables-and-unlock-tables.md) | E | E | E | E | E | E | E |
+| [物化列式存储的查询结果](/tiflash/tiflash-results-materialization.md) | Y | Y | Y | Y | E | N | N |
## 高级 SQL 功能
-| 高级 SQL 功能 | 8.4 | 8.3 | 8.2 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 | 5.3 | 5.2 | 5.1 |
-|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| [向量搜索](/vector-search-overview.md) | E | N | N | N | N | N | N | N | N | N | N | N |
-| [Prepare 语句执行计划缓存](/sql-prepared-plan-cache.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | E | E |
-| [非 Prepare 语句执行计划缓存](/sql-non-prepared-plan-cache.md) | Y | Y | Y | Y | Y | E | N | N | N | N | N | N |
-| [实例级执行计划缓存](/system-variables.md#tidb_enable_instance_plan_cache-从-v840-版本开始引入) | E | N | N | N | N | N | N | N | N | N | N | N |
-| [执行计划绑定 (SQL Binding)](/sql-plan-management.md#执行计划绑定-sql-binding) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [跨数据库执行计划绑定 (Cross-DB Binding)](/sql-plan-management.md#跨数据库绑定执行计划-cross-db-binding) | Y | Y | Y | Y | N | N | N | N | N | N | N | N |
-| [根据历史执行计划创建绑定](/sql-plan-management.md#根据历史执行计划创建绑定) | Y | Y | Y | Y | Y | Y | E | N | N | N | N | N |
-| [下推计算结果缓存 (Coprocessor Cache)](/coprocessor-cache.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Stale Read](/stale-read.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Follower Read](/follower-read.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [通过系统变量 `tidb_snapshot` 读取历史数据](/read-historical-data.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Optimizer hints](/optimizer-hints.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [MPP 执行引擎](/explain-mpp.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [MPP 执行引擎 - compression exchange](/explain-mpp.md#mpp-version-和-exchange-数据压缩) | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N |
-| [TiFlash Pipeline 执行模型](/tiflash/tiflash-pipeline-model.md) | Y | Y | Y | Y | Y | N | N | N | N | N | N | N |
-| [TiFlash 副本选择策略](/system-variables.md#tiflash_replica_read-从-v730-版本开始引入) | Y | Y | Y | Y | Y | N | N | N | N | N | N | N |
-| [索引合并](/explain-index-merge.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | E | E | E |
-| [基于 SQL 的数据放置规则](/placement-rules-in-sql.md) | Y | Y | Y | Y | Y | Y | Y | Y | E | E | N | N |
-| [Cascades Planner](/system-variables.md#tidb_enable_cascades_planner) | E | E | E | E | E | E | E | E | E | E | E | E |
-| [Runtime Filter](/runtime-filter.md) | Y | Y | Y | Y | Y | N | N | N | N | N | N | N |
+| 高级 SQL 功能 | 8.5 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| [向量搜索](/develop/dev-guide-vector-search.md) | E | N | N | N | N | N | N |
+| [Prepare 语句执行计划缓存](/sql-prepared-plan-cache.md) | Y | Y | Y | Y | Y | Y | Y |
+| [非 Prepare 语句执行计划缓存](/sql-non-prepared-plan-cache.md) | Y | Y | Y | E | N | N | N |
+| [实例级执行计划缓存](/system-variables.md#tidb_enable_instance_plan_cache-从-v840-版本开始引入) | E | N | N | N | N | N | N |
+| [执行计划绑定 (SQL Binding)](/sql-plan-management.md#执行计划绑定-sql-binding) | Y | Y | Y | Y | Y | Y | Y |
+| [跨数据库执行计划绑定 (Cross-DB Binding)](/sql-plan-management.md#跨数据库绑定执行计划-cross-db-binding) | Y | Y | N | N | N | N | N |
+| [根据历史执行计划创建绑定](/sql-plan-management.md#根据历史执行计划创建绑定) | Y | Y | Y | Y | E | N | N |
+| [下推计算结果缓存 (Coprocessor Cache)](/coprocessor-cache.md) | Y | Y | Y | Y | Y | Y | Y |
+| [Stale Read](/stale-read.md) | Y | Y | Y | Y | Y | Y | Y |
+| [Follower Read](/follower-read.md) | Y | Y | Y | Y | Y | Y | Y |
+| [通过系统变量 `tidb_snapshot` 读取历史数据](/read-historical-data.md) | Y | Y | Y | Y | Y | Y | Y |
+| [Optimizer hints](/optimizer-hints.md) | Y | Y | Y | Y | Y | Y | Y |
+| [MPP 执行引擎](/explain-mpp.md) | Y | Y | Y | Y | Y | Y | Y |
+| [MPP 执行引擎 - compression exchange](/explain-mpp.md#mpp-version-和-exchange-数据压缩) | Y | Y | Y | Y | N | N | N |
+| [TiFlash Pipeline 执行模型](/tiflash/tiflash-pipeline-model.md) | Y | Y | Y | N | N | N | N |
+| [TiFlash 副本选择策略](/system-variables.md#tiflash_replica_read-从-v730-版本开始引入) | Y | Y | Y | N | N | N | N |
+| [索引合并](/explain-index-merge.md) | Y | Y | Y | Y | Y | Y | Y |
+| [基于 SQL 的数据放置规则](/placement-rules-in-sql.md) | Y | Y | Y | Y | Y | Y | E |
+| [Cascades Planner](/system-variables.md#tidb_enable_cascades_planner) | E | E | E | E | E | E | E |
+| [Runtime Filter](/runtime-filter.md) | Y | Y | Y | N | N | N | N |
## 数据定义语言 (DDL)
-| 数据定义语言 (DDL) | 8.4 | 8.3 | 8.2 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 | 5.3 | 5.2 | 5.1 |
-|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| `CREATE`,`DROP`,`ALTER`,`RENAME`,`TRUNCATE` | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [生成列](/generated-columns.md) | Y | Y | Y | Y | Y | Y | E | E | E | E | E | E |
-| [视图](/views.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [序列](/sql-statements/sql-statement-create-sequence.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [`AUTO_INCREMENT` 列](/auto-increment.md) | Y | Y | Y | Y | Y | Y | Y[^4] | Y | Y | Y | Y | Y |
-| [`AUTO_RANDOM` 列](/auto-random.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [TTL (Time to Live)](/time-to-live.md) | Y | Y | Y | Y | Y | Y | E | N | N | N | N | N |
-| [DDL 算法断言](/sql-statements/sql-statement-alter-table.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| 在单条语句中添加多列 | Y | Y | Y | Y | Y | Y | Y | E | E | E | E | E |
-| [更改列类型](/sql-statements/sql-statement-modify-column.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [临时表](/temporary-tables.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | N | N |
-| 并行 DDL | Y | Y | Y | Y | Y | Y | Y | N | N | N | N | N |
-| [添加索引加速](/system-variables.md#tidb_ddl_enable_fast_reorg-从-v630-版本开始引入) | Y | Y | Y | Y | Y | Y | Y | N | N | N | N | N |
-| [元数据锁](/metadata-lock.md) | Y | Y | Y | Y | Y | Y | N | N | N | N | N |
-| [`FLASHBACK CLUSTER`](/sql-statements/sql-statement-flashback-cluster.md) | Y | Y | Y | Y | Y | Y | Y | N | N | N | N | N |
-| [暂停](/sql-statements/sql-statement-admin-pause-ddl.md)/[恢复](/sql-statements/sql-statement-admin-resume-ddl.md) DDL | Y | Y | Y | Y | Y | N | N | N | N | N | N | N |
-| [TiDB 加速建表](/accelerated-table-creation.md) | E | E | E | E | N | N | N | N | N | N | N | N |
-| [设置 BDR Role 用于 TiCDC 双向同步时同步 DDL](/sql-statements/sql-statement-admin-bdr-role.md#admin-setshowunset-bdr-role) | Y | Y | E | E | N | N | N | N | N | N | N | N |
+| 数据定义语言 (DDL) | 8.5 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| `CREATE`,`DROP`,`ALTER`,`RENAME`,`TRUNCATE` | Y | Y | Y | Y | Y | Y | Y |
+| [生成列](/generated-columns.md) | Y | Y | Y | Y | E | E | E |
+| [视图](/views.md) | Y | Y | Y | Y | Y | Y | Y |
+| [序列](/sql-statements/sql-statement-create-sequence.md) | Y | Y | Y | Y | Y | Y | Y |
+| [`AUTO_INCREMENT` 列](/auto-increment.md) | Y | Y | Y | Y | Y[^4] | Y | Y |
+| [`AUTO_RANDOM` 列](/auto-random.md) | Y | Y | Y | Y | Y | Y | Y |
+| [TTL (Time to Live)](/time-to-live.md) | Y | Y | Y | Y | E | N | N |
+| [DDL 算法断言](/sql-statements/sql-statement-alter-table.md) | Y | Y | Y | Y | Y | Y | Y |
+| 在单条语句中添加多列 | Y | Y | Y | Y | Y | E | E |
+| [更改列类型](/sql-statements/sql-statement-modify-column.md) | Y | Y | Y | Y | Y | Y | Y |
+| [临时表](/temporary-tables.md) | Y | Y | Y | Y | Y | Y | Y |
+| 并行 DDL | Y | Y | Y | Y | Y | N | N |
+| [添加索引加速](/system-variables.md#tidb_ddl_enable_fast_reorg-从-v630-版本开始引入) | Y | Y | Y | Y | Y | N | N |
+| [元数据锁](/metadata-lock.md) | Y | Y | Y | Y | Y | N | N |
+| [`FLASHBACK CLUSTER`](/sql-statements/sql-statement-flashback-cluster.md) | Y | Y | Y | Y | Y | N | N |
+| [暂停](/sql-statements/sql-statement-admin-pause-ddl.md)/[恢复](/sql-statements/sql-statement-admin-resume-ddl.md) DDL | Y | Y | Y | N | N | N | N |
+| [TiDB 加速建表](/accelerated-table-creation.md) | Y | E | N | N | N | N | N |
+| [设置 BDR Role 用于 TiCDC 双向同步时同步 DDL](/sql-statements/sql-statement-admin-bdr-role.md#admin-setshowunset-bdr-role) | Y | E | N | N | N | N | N |
## 事务
-| 事务 | 8.4 | 8.3 | 8.2 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 | 5.3 | 5.2 | 5.1 |
-|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| [Async commit](/system-variables.md#tidb_enable_async_commit-从-v50-版本开始引入) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [1PC](/system-variables.md#tidb_enable_1pc-从-v50-版本开始引入) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [大事务 (1 TiB)](/transaction-overview.md#事务限制) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [悲观事务](/pessimistic-transaction.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [乐观事务](/optimistic-transaction.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [可重复读隔离(快照隔离)](/transaction-isolation-levels.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [读已提交隔离](/transaction-isolation-levels.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [自动终止长时间未提交的空闲事务](/system-variables.md#tidb_idle_transaction_timeout-从-v760-版本开始引入) | Y | Y | Y | Y | N | N | N | N | N | N | N | N |
-| [批量 DML 语句的执行方式 (`tidb_dml_type = "bulk"`)](/system-variables.md#tidb_dml_type-从-v800-版本开始引入) | E | E | E | N | N | N | N | N | N | N | N |
+| 事务 | 8.5 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| [Async commit](/system-variables.md#tidb_enable_async_commit-从-v50-版本开始引入) | Y | Y | Y | Y | Y | Y | Y |
+| [1PC](/system-variables.md#tidb_enable_1pc-从-v50-版本开始引入) | Y | Y | Y | Y | Y | Y | Y |
+| [大事务 (1 TiB)](/transaction-overview.md#事务限制) | Y | Y | Y | Y | Y | Y | Y |
+| [悲观事务](/pessimistic-transaction.md) | Y | Y | Y | Y | Y | Y | Y |
+| [乐观事务](/optimistic-transaction.md) | Y | Y | Y | Y | Y | Y | Y |
+| [可重复读隔离(快照隔离)](/transaction-isolation-levels.md) | Y | Y | Y | Y | Y | Y | Y |
+| [读已提交隔离](/transaction-isolation-levels.md) | Y | Y | Y | Y | Y | Y | Y |
+| [自动终止长时间未提交的空闲事务](/system-variables.md#tidb_idle_transaction_timeout-从-v760-版本开始引入) | Y | Y | N | N | N | N | N |
+| [批量 DML 语句的执行方式 (`tidb_dml_type = "bulk"`)](/system-variables.md#tidb_dml_type-从-v800-版本开始引入) | E | E | N | N | N | N | N |
## 分区
-| 分区 | 8.4 | 8.3 | 8.2 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 | 5.3 | 5.2 | 5.1 |
-|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| [Range 分区](/partitioned-table.md#range-分区) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Hash 分区](/partitioned-table.md#hash-分区) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Key 分区](/partitioned-table.md#key-分区) | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N |
-| [List 分区](/partitioned-table.md#list-分区) | Y | Y | Y | Y | Y | Y | Y | Y | E | E | E | E |
-| [List COLUMNS 分区](/partitioned-table.md#list-columns-分区) | Y | Y | Y | Y | Y | Y | Y | Y | E | E | E | E |
-| [List 和 List COLUMNS 分区表的默认分区](/partitioned-table.md#默认的-list-分区) | Y | Y | Y | Y | Y | N | N | N | N | N | N | N |
-| [`EXCHANGE PARTITION`](/partitioned-table.md) | Y | Y | Y | Y | Y | Y | Y | E | E | E | E | E |
-| [`REORGANIZE PARTITION`](/partitioned-table.md#重组分区) | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N |
-| [`COALESCE PARTITION`](/partitioned-table.md#减少分区数量) | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N |
-| [动态裁剪](/partitioned-table.md#动态裁剪模式) | Y | Y | Y | Y | Y | Y | Y | Y | E | E | E | E |
-| [Range COLUMNS 分区](/partitioned-table.md#range-columns-分区) | Y | Y | Y | Y | Y | Y | Y | N | N | N | N | N |
-| [Range INTERVAL 分区](/partitioned-table.md#range-interval-分区) | Y | Y | Y | Y | Y | Y | E | N | N | N | N | N |
-| [分区表转换为非分区表](/partitioned-table.md#将分区表转换为非分区表) | Y | Y | Y | Y | Y | N | N | N | N | N | N | N |
-| [对现有表进行分区](/partitioned-table.md#对现有表进行分区) | Y | Y | Y | Y | Y | N | N | N | N | N | N | N |
+| 分区 | 8.5 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| [Range 分区](/partitioned-table.md#range-分区) | Y | Y | Y | Y | Y | Y | Y |
+| [Hash 分区](/partitioned-table.md#hash-分区) | Y | Y | Y | Y | Y | Y | Y |
+| [Key 分区](/partitioned-table.md#key-分区) | Y | Y | Y | Y | N | N | N |
+| [List 分区](/partitioned-table.md#list-分区) | Y | Y | Y | Y | Y | Y | E |
+| [List COLUMNS 分区](/partitioned-table.md#list-columns-分区) | Y | Y | Y | Y | Y | Y | E |
+| [List 和 List COLUMNS 分区表的默认分区](/partitioned-table.md#默认的-list-分区) | Y | Y | Y | N | N | N | N |
+| [`EXCHANGE PARTITION`](/partitioned-table.md) | Y | Y | Y | Y | Y | E | E |
+| [`REORGANIZE PARTITION`](/partitioned-table.md#重组分区) | Y | Y | Y | Y | N | N | N |
+| [`COALESCE PARTITION`](/partitioned-table.md#减少分区数量) | Y | Y | Y | Y | N | N | N |
+| [动态裁剪](/partitioned-table.md#动态裁剪模式) | Y | Y | Y | Y | Y | Y | E |
+| [Range COLUMNS 分区](/partitioned-table.md#range-columns-分区) | Y | Y | Y | Y | Y | N | N |
+| [Range INTERVAL 分区](/partitioned-table.md#range-interval-分区) | Y | Y | Y | Y | E | N | N |
+| [分区表转换为非分区表](/partitioned-table.md#将分区表转换为非分区表) | Y | Y | Y | N | N | N | N |
+| [对现有表进行分区](/partitioned-table.md#对现有表进行分区) | Y | Y | Y | N | N | N | N |
+| [全局索引 (Global Index)](/global-indexes.md) | Y | N | N | N | N | N | N |
## 统计信息
-| 统计信息 | 8.4 | 8.3 | 8.2 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 | 5.3 | 5.2 | 5.1 |
-|---|:----:|:----:|:----:|:----:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| [CM-Sketch](/statistics.md) | 默认关闭| 默认关闭| 默认关闭| 默认关闭| 默认关闭 | 默认关闭 | 默认关闭 | 默认关闭 | 默认关闭 | 默认关闭 | Y | Y |
-| [直方图](/statistics.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [扩展统计信息](/extended-statistics.md) | E | E | E | E | E | E | E | E | E | E | E | E |
-| 统计反馈 | N | N | N | N | N | N | N | 已废弃 | 已废弃 | E | E | E |
-| [统计信息自动更新](/statistics.md#自动更新) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [动态裁剪](/partitioned-table.md#动态裁剪模式) | Y | Y | Y | Y | Y | Y | Y | Y | E | E | E | E |
-| [收集部分列的统计信息](/statistics.md#收集部分列的统计信息) | Y | Y | E | E | E | E | E | E | E | N | N | N |
-| [限制统计信息的内存使用量](/statistics.md#统计信息收集的内存限制) | E | E | E | E | E | E | E | E | N | N | N | N |
-| [随机采样约 10000 行数据来快速构建统计信息](/system-variables.md#tidb_enable_fast_analyze) | 已废弃 | 已废弃 | 已废弃 | 已废弃 | 已废弃 | E | E | E | E | E | E | E |
-| [锁定统计信息](/statistics.md#锁定统计信息) | Y | Y | Y | Y | Y | E | E | N | N | N | N | N |
-| [轻量级统计信息初始化](/statistics.md#加载统计信息) | Y | Y | Y | Y | Y | E | N | N | N | N | N | N |
-| [显示统计信息收集的进度](/sql-statements/sql-statement-show-analyze-status.md) | Y | Y | Y | Y | Y | N | N | N | N | N | N | N |
+| 统计信息 | 8.5 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 |
+|---|:----:|:----:|:---:|:---:|:---:|:---:|:---:|
+| [CM-Sketch](/statistics.md) | 默认关闭| 默认关闭| 默认关闭 | 默认关闭 | 默认关闭 | 默认关闭 | 默认关闭 |
+| [直方图](/statistics.md) | Y | Y | Y | Y | Y | Y | Y |
+| [扩展统计信息](/extended-statistics.md) | E | E | E | E | E | E | E |
+| 统计反馈 | N | N | N | N | N | 已废弃 | 已废弃 |
+| [统计信息自动更新](/statistics.md#自动更新) | Y | Y | Y | Y | Y | Y | Y |
+| [动态裁剪](/partitioned-table.md#动态裁剪模式) | Y | Y | Y | Y | Y | Y | E |
+| [收集部分列的统计信息](/statistics.md#收集部分列的统计信息) | Y | E | E | E | E | E | E |
+| [限制统计信息的内存使用量](/statistics.md#统计信息收集的内存限制) | E | E | E | E | E | E | N |
+| [随机采样约 10000 行数据来快速构建统计信息](/system-variables.md#tidb_enable_fast_analyze) | 已废弃 | 已废弃 | 已废弃 | E | E | E | E |
+| [锁定统计信息](/statistics.md#锁定统计信息) | Y | Y | Y | E | E | N | N |
+| [轻量级统计信息初始化](/statistics.md#加载统计信息) | Y | Y | Y | E | N | N | N |
+| [显示统计信息收集的进度](/sql-statements/sql-statement-show-analyze-status.md) | Y | Y | Y | N | N | N | N |
## 安全
-| 安全 | 8.4 | 8.3 | 8.2 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 | 5.3 | 5.2 | 5.1 |
-|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| [传输层加密 (TLS)](/enable-tls-between-clients-and-servers.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [静态加密 (TDE)](/encryption-at-rest.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [基于角色的访问控制 (RBAC)](/role-based-access-control.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [证书鉴权](/certificate-authentication.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [`caching_sha2_password` 认证](/system-variables.md#default_authentication_plugin) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | N |
-| [`tidb_sm3_password` 认证](/system-variables.md#default_authentication_plugin) | Y | Y | Y | Y | Y | Y | Y | N | N | N | N | N |
-| [`tidb_auth_token` 认证](/security-compatibility-with-mysql.md#tidb_auth_token) | Y | Y | Y | Y | Y | Y | Y | N | N | N | N | N |
-| [`authentication_ldap_sasl` 认证](/system-variables.md#default_authentication_plugin) | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N |
-| [`authentication_ldap_simple` 认证](/system-variables.md#default_authentication_plugin) | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N |
-| [密码管理](/password-management.md) | Y | Y | Y | Y | Y | Y | Y | N | N | N | N | N |
-| [与 MySQL 兼容的 `GRANT` 权限管理](/privilege-management.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [动态权限](/privilege-management.md#动态权限) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [安全增强模式](/system-variables.md#tidb_enable_enhanced_security) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [日志脱敏](/log-redaction.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
+| 安全 | 8.5 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| [传输层加密 (TLS)](/enable-tls-between-clients-and-servers.md) | Y | Y | Y | Y | Y | Y | Y |
+| [静态加密 (TDE)](/encryption-at-rest.md) | Y | Y | Y | Y | Y | Y | Y |
+| [基于角色的访问控制 (RBAC)](/role-based-access-control.md) | Y | Y | Y | Y | Y | Y | Y |
+| [证书鉴权](/certificate-authentication.md) | Y | Y | Y | Y | Y | Y | Y |
+| [`caching_sha2_password` 认证](/system-variables.md#default_authentication_plugin) | Y | Y | Y | Y | Y | Y | Y |
+| [`tidb_sm3_password` 认证](/system-variables.md#default_authentication_plugin) | Y | Y | Y | Y | Y | N | N |
+| [`tidb_auth_token` 认证](/security-compatibility-with-mysql.md#tidb_auth_token) | Y | Y | Y | Y | Y | N | N |
+| [`authentication_ldap_sasl` 认证](/system-variables.md#default_authentication_plugin) | Y | Y | Y | Y | N | N | N |
+| [`authentication_ldap_simple` 认证](/system-variables.md#default_authentication_plugin) | Y | Y | Y | Y | N | N | N |
+| [密码管理](/password-management.md) | Y | Y | Y | Y | Y | N | N |
+| [与 MySQL 兼容的 `GRANT` 权限管理](/privilege-management.md) | Y | Y | Y | Y | Y | Y | Y |
+| [动态权限](/privilege-management.md#动态权限) | Y | Y | Y | Y | Y | Y | Y |
+| [安全增强模式](/system-variables.md#tidb_enable_enhanced_security) | Y | Y | Y | Y | Y | Y | Y |
+| [日志脱敏](/log-redaction.md) | Y | Y | Y | Y | Y | Y | Y |
## 数据导入和导出
-| 数据导入和导出 | 8.4 | 8.3 | 8.2 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 | 5.3 | 5.2 | 5.1 |
-|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| [快速导入 (TiDB Lightning)](/tidb-lightning/tidb-lightning-overview.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [快速导入 (`IMPORT INTO`)](/sql-statements/sql-statement-import-into.md) | Y | Y | Y | Y | Y | N | N | N | N | N | N | N |
-| mydumper 逻辑导出 | 已废弃 | 已废弃 | 已废弃 | 已废弃 | 已废弃 | 已废弃 | 已废弃 | 已废弃 | 已废弃 | 已废弃 | 已废弃 | 已废弃 |
-| [Dumpling 逻辑导出](/dumpling-overview.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [事务 `LOAD DATA`](/sql-statements/sql-statement-load-data.md) [^5] | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [数据迁移工具](/migration-overview.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [TiDB Binlog](https://docs.pingcap.com/zh/tidb/v8.3/tidb-binlog-overview) [^6] | 已移除 | 已废弃 | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Change data capture (CDC)](/ticdc/ticdc-overview.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [TiCDC 支持保存数据到存储服务 (Amazon S3/GCS/Azure Blob Storage/NFS)](/ticdc/ticdc-sink-to-cloud-storage.md) | Y | Y | Y | Y | Y | Y | E | N | N | N | N | N |
-| [TiCDC 支持在两个 TiDB 集群之间进行双向复制](/ticdc/ticdc-bidirectional-replication.md) | Y | Y | Y | Y | Y | Y | Y | N | N | N | N | N |
-| [TiCDC OpenAPI v2](/ticdc/ticdc-open-api-v2.md) | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N |
-| [DM](/dm/dm-overview.md) 支持迁移 MySQL 8.0 | Y | Y | Y | Y | E | E | E | E | N | N | N | N |
+| 数据导入和导出 | 8.5 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| [快速导入 (TiDB Lightning)](/tidb-lightning/tidb-lightning-overview.md) | Y | Y | Y | Y | Y | Y | Y |
+| [快速导入 (`IMPORT INTO`)](/sql-statements/sql-statement-import-into.md) | Y | Y | Y | N | N | N | N |
+| mydumper 逻辑导出 | 已废弃 | 已废弃 | 已废弃 | 已废弃 | 已废弃 | 已废弃 | 已废弃 |
+| [Dumpling 逻辑导出](/dumpling-overview.md) | Y | Y | Y | Y | Y | Y | Y |
+| [事务 `LOAD DATA`](/sql-statements/sql-statement-load-data.md) [^5] | Y | Y | Y | Y | Y | Y | Y |
+| [数据迁移工具](/migration-overview.md) | Y | Y | Y | Y | Y | Y | Y |
+| [TiDB Binlog](https://docs.pingcap.com/zh/tidb/v8.3/tidb-binlog-overview) [^6] | 已移除 | Y | Y | Y | Y | Y | Y |
+| [Change data capture (CDC)](/ticdc/ticdc-overview.md) | Y | Y | Y | Y | Y | Y | Y |
+| [TiCDC 支持保存数据到存储服务 (Amazon S3/GCS/Azure Blob Storage/NFS)](/ticdc/ticdc-sink-to-cloud-storage.md) | Y | Y | Y | Y | E | N | N |
+| [TiCDC 支持在两个 TiDB 集群之间进行双向复制](/ticdc/ticdc-bidirectional-replication.md) | Y | Y | Y | Y | Y | N | N |
+| [TiCDC OpenAPI v2](/ticdc/ticdc-open-api-v2.md) | Y | Y | Y | Y | N | N | N |
+| [DM](/dm/dm-overview.md) 支持迁移 MySQL 8.0 | Y | Y | E | E | E | E | N |
## 管理,可视化和工具
-| 管理,可视化和工具 | 8.4 | 8.3 | 8.2 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 | 5.3 | 5.2 | 5.1 |
-|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| [TiDB Dashboard 图形化展示](/dashboard/dashboard-intro.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [TiDB Dashboard 持续性能分析功能](/dashboard/continuous-profiling.md) | Y | Y | Y | Y | Y | Y | Y | Y | E | E | N | N |
-| [TiDB Dashboard Top SQL 功能](/dashboard/top-sql.md) | Y | Y | Y | Y | Y | Y | Y | Y | E | N | N | N |
-| [TiDB Dashboard SQL 诊断功能](/information-schema/information-schema-sql-diagnostics.md) | Y | Y | Y | Y | Y | Y | Y | E | E | E | E | E |
-| [TiDB Dashboard 集群诊断功能](/dashboard/dashboard-diagnostics-access.md) | Y | Y | Y | Y | Y | Y | Y | E | E | E | E | E |
-| [Grafana 中的 TiKV-FastTune 面板](/grafana-tikv-dashboard.md#tikv-fasttune-面板) | E | E | E | E | E | E | E | E | E | E | E | E |
-| [Information schema](/information-schema/information-schema.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Metrics schema](/metrics-schema.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Statements summary tables](/statement-summary-tables.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Statements summary tables - 持久化 statements summary](/statement-summary-tables.md#持久化-statements-summary) | E | E | E | E | E | E | N | N | N | N | N | N |
-| [慢查询日志](/identify-slow-queries.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [TiUP 部署](/tiup/tiup-overview.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Kubernetes operator](https://docs.pingcap.com/tidb-in-kubernetes/stable) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [内置物理备份](/br/backup-and-restore-use-cases.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [Global Kill](/sql-statements/sql-statement-kill.md) | Y | Y | Y | Y | Y | Y | Y | Y | E | E | E | E |
-| [Lock View](/information-schema/information-schema-data-lock-waits.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | E |
-| [`SHOW CONFIG`](/sql-statements/sql-statement-show-config.md) | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y |
-| [`SET CONFIG`](/dynamic-config.md) | Y | Y | Y | Y | Y | Y | Y | Y | E | E | E | E |
-| [DM WebUI](/dm/dm-webui-guide.md) | E | E | E | E | E | E | E | E | N | N | N | N |
-| [前台限流](/tikv-configuration-file.md#前台限流) | Y | Y | Y | Y | Y | Y | Y | E | N | N | N | N |
-| [后台限流](/tikv-configuration-file.md#后台限流) | E | E | E | E | E | E | E | N | N | N | N | N |
-| [基于 EBS 的备份和恢复](https://docs.pingcap.com/zh/tidb-in-kubernetes/v1.4/volume-snapshot-backup-restore) | Y | Y | Y | Y | Y | Y | Y | N | N | N | N | N |
-| [PITR](/br/br-pitr-guide.md) | Y | Y | Y | Y | Y | Y | Y | N | N | N | N | N |
-| [全局内存控制](/configure-memory-usage.md#如何配置-tidb-server-实例使用内存的阈值) | Y | Y | Y | Y | Y | Y | Y | N | N | N | N | N |
-| [RawKV 跨集群复制](/tikv-configuration-file.md#api-version-从-v610-版本开始引入) | E | E | E | E | E| E | E | N | N | N | N | N |
-| [Green GC](/system-variables.md#tidb_gc_scan_lock_mode-从-v50-版本开始引入) | E | E | E | E | E | E | E | E | E | E | E | E |
-| [资源管控 (Resource Control)](/tidb-resource-control.md) | Y | Y | Y | Y | Y | Y | N | N | N | N | N | N |
-| [Runaway Queries 自动管理](/tidb-resource-control.md#管理资源消耗超出预期的查询-runaway-queries) | Y | Y | Y | Y | E | N | N | N | N | N | N | N |
-| [后台任务资源管控](/tidb-resource-control.md#管理后台任务) | E | E | E | E | E | N | N | N | N | N | N | N |
-| [TiFlash 存算分离架构与 S3 支持](/tiflash/tiflash-disaggregated-and-s3.md) | Y | Y | Y | Y | Y | E | N | N | N | N | N | N |
-| [选择执行分布式执行框架任务的 TiDB 节点](/system-variables.md#tidb_service_scope-从-v740-版本开始引入) | Y | Y | Y | Y | Y | N | N | N | N | N | N | N |
-| 通过系统变量 [`tidb_enable_tso_follower_proxy`](/system-variables.md#tidb_enable_tso_follower_proxy-从-v530-版本开始引入) 控制 PD Follower Proxy 功能 | Y | Y | Y | Y | Y | Y | Y | Y | Y | Y | N | N |
-| 通过系统变量 [`pd_enable_follower_handle_region`](/system-variables.md#pd_enable_follower_handle_region-从-v760-版本开始引入) 控制 [Active PD Follower](/tune-region-performance.md#通过-active-pd-follower-提升-pd-region-信息查询服务的扩展能力) 功能 | E | E | E | E | N | N | N | N | N | N | N | N |
-| [PD 微服务](/pd-microservices.md) | E | E | E | E | N | N | N | N | N | N | N | N |
-| [TiDB 分布式执行框架](/tidb-distributed-execution-framework.md) | Y | Y | Y | Y | Y | E | N | N | N | N | N | N |
-| [全局排序](/tidb-global-sort.md) | Y | Y | Y | Y | E | N | N | N | N | N | N | N |
-| [TiProxy](/tiproxy/tiproxy-overview.md) | Y | Y | Y | Y | N | N | N | N | N | N | N | N |
+| 管理,可视化和工具 | 8.5 | 8.1 | 7.5 | 7.1 | 6.5 | 6.1 | 5.4 |
+|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| [TiDB Dashboard 图形化展示](/dashboard/dashboard-intro.md) | Y | Y | Y | Y | Y | Y | Y |
+| [TiDB Dashboard 持续性能分析功能](/dashboard/continuous-profiling.md) | Y | Y | Y | Y | Y | Y | E |
+| [TiDB Dashboard Top SQL 功能](/dashboard/top-sql.md) | Y | Y | Y | Y | Y | Y | E |
+| [TiDB Dashboard SQL 诊断功能](/information-schema/information-schema-sql-diagnostics.md) | Y | Y | Y | Y | Y | E | E |
+| [TiDB Dashboard 集群诊断功能](/dashboard/dashboard-diagnostics-access.md) | Y | Y | Y | Y | Y | E | E |
+| [Grafana 中的 TiKV-FastTune 面板](/grafana-tikv-dashboard.md#tikv-fasttune-面板) | E | E | E | E | E | E | E |
+| [Information schema](/information-schema/information-schema.md) | Y | Y | Y | Y | Y | Y | Y |
+| [Metrics schema](/metrics-schema.md) | Y | Y | Y | Y | Y | Y | Y |
+| [Statements summary tables](/statement-summary-tables.md) | Y | Y | Y | Y | Y | Y | Y |
+| [Statements summary tables - 持久化 statements summary](/statement-summary-tables.md#持久化-statements-summary) | E | E | E | E | N | N | N |
+| [慢查询日志](/identify-slow-queries.md) | Y | Y | Y | Y | Y | Y | Y |
+| [TiUP 部署](/tiup/tiup-overview.md) | Y | Y | Y | Y | Y | Y | Y |
+| [Kubernetes operator](https://docs.pingcap.com/tidb-in-kubernetes/stable) | Y | Y | Y | Y | Y | Y | Y |
+| [内置物理备份](/br/backup-and-restore-use-cases.md) | Y | Y | Y | Y | Y | Y | Y |
+| [Global Kill](/sql-statements/sql-statement-kill.md) | Y | Y | Y | Y | Y | Y | E |
+| [Lock View](/information-schema/information-schema-data-lock-waits.md) | Y | Y | Y | Y | Y | Y | Y |
+| [`SHOW CONFIG`](/sql-statements/sql-statement-show-config.md) | Y | Y | Y | Y | Y | Y | Y |
+| [`SET CONFIG`](/dynamic-config.md) | Y | Y | Y | Y | Y | Y | E |
+| [DM WebUI](/dm/dm-webui-guide.md) | E | E | E | E | E | E | N |
+| [前台限流](/tikv-configuration-file.md#前台限流) | Y | Y | Y | Y | Y | E | N |
+| [后台限流](/tikv-configuration-file.md#后台限流) | E | E | E | E | E | N | N |
+| [基于 EBS 的备份和恢复](https://docs.pingcap.com/zh/tidb-in-kubernetes/v1.4/volume-snapshot-backup-restore) | Y | Y | Y | Y | Y | N | N |
+| [PITR](/br/br-pitr-guide.md) | Y | Y | Y | Y | Y | N | N |
+| [全局内存控制](/configure-memory-usage.md#如何配置-tidb-server-实例使用内存的阈值) | Y | Y | Y | Y | Y | N | N |
+| [RawKV 跨集群复制](/tikv-configuration-file.md#api-version-从-v610-版本开始引入) | E | E | E| E | E | N | N |
+| [Green GC](/system-variables.md#tidb_gc_scan_lock_mode-从-v50-版本开始引入) | E | E | E | E | E | E | E |
+| [资源管控 (Resource Control)](/tidb-resource-control-ru-groups.md) | Y | Y | Y | Y | N | N | N |
+| [Runaway Queries 自动管理](/tidb-resource-control-runaway-queries.md) | Y | Y | E | N | N | N | N |
+| [后台任务资源管控](/tidb-resource-control-background-tasks.md) | E | E | E | N | N | N | N |
+| [TiFlash 存算分离架构与 S3 支持](/tiflash/tiflash-disaggregated-and-s3.md) | Y | Y | Y | E | N | N | N |
+| [选择执行分布式执行框架任务的 TiDB 节点](/system-variables.md#tidb_service_scope-从-v740-版本开始引入) | Y | Y | Y | N | N | N | N |
+| 通过系统变量 [`tidb_enable_tso_follower_proxy`](/system-variables.md#tidb_enable_tso_follower_proxy-从-v530-版本开始引入) 控制 PD Follower Proxy 功能 | Y | Y | Y | Y | Y | Y | Y |
+| 通过系统变量 [`pd_enable_follower_handle_region`](/system-variables.md#pd_enable_follower_handle_region-从-v760-版本开始引入) 控制 [Active PD Follower](/tune-region-performance.md#通过-active-pd-follower-提升-pd-region-信息查询服务的扩展能力) 功能 | Y | E | N | N | N | N | N |
+| [PD 微服务](/pd-microservices.md) | E | E | N | N | N | N | N |
+| [TiDB 分布式执行框架](/tidb-distributed-execution-framework.md) | Y | Y | Y | E | N | N | N |
+| [全局排序](/tidb-global-sort.md) | Y | Y | E | N | N | N | N |
+| [TiProxy](/tiproxy/tiproxy-overview.md) | Y | Y | N | N | N | N | N |
+| [Schema 缓存](/schema-cache.md) | Y | N | N | N | N | N | N |
[^1]: TiDB 误将 latin1 处理为 utf8 的子集。见 [TiDB #18955](https://github.com/pingcap/tidb/issues/18955)。
@@ -274,7 +275,7 @@ aliases: ['/docs-cn/dev/basic-features/','/docs-cn/dev/experimental-features-4.0
[^3]: TiDB 支持的完整 SQL 列表,见[语句参考](/sql-statements/sql-statement-select.md)。
-[^4]: 从 [TiDB v6.4.0](/releases/release-6.4.0.md) 开始,支持[高性能、全局单调递增的 `AUTO_INCREMENT` 列](/auto-increment.md#mysql-兼容模式)。
+[^4]: 从 [TiDB v6.4.0](/releases/release-6.4.0.md) 开始,支持[高性能、全局单调递增的 `AUTO_INCREMENT` 列](/auto-increment.md#兼容-mysql-的自增列模式)。
[^5]: 从 [TiDB v7.0.0](/releases/release-7.0.0.md) 开始新增的参数 `FIELDS DEFINED NULL BY` 以及新增支持从 S3 和 GCS 导入数据,均为实验特性。从 [TiDB v7.6.0](/releases/release-7.6.0.md) 开始 `LOAD DATA` 的事务行为与 MySQL 的事务行为一致,包括事务内的 `LOAD DATA` 语句本身不再自动提交当前事务,也不会开启新事务,并且事务内的 `LOAD DATA` 语句可以被显式提交或者回滚。此外,`LOAD DATA` 语句会受 TiDB 事务模式设置(乐观/悲观)影响。
diff --git a/basic-sql-operations.md b/basic-sql-operations.md
index aa2ec72dbf04..ca2a0ea4c098 100644
--- a/basic-sql-operations.md
+++ b/basic-sql-operations.md
@@ -1,6 +1,5 @@
---
title: SQL 基本操作
-aliases: ['/docs-cn/dev/basic-sql-operations/','/docs-cn/dev/how-to/get-started/explore-sql/']
summary: TiDB 是一个兼容 MySQL 的数据库,可以执行 DDL、DML、DQL 和 DCL 操作。可以使用 SHOW DATABASES 查看数据库列表,使用 CREATE DATABASE 创建数据库,使用 DROP DATABASE 删除数据库。使用 CREATE TABLE 创建表,使用 SHOW CREATE TABLE 查看建表语句,使用 DROP TABLE 删除表。使用 CREATE INDEX 创建索引,使用 SHOW INDEX 查看表内所有索引,使用 DROP INDEX 删除索引。使用 INSERT 向表内插入记录,使用 UPDATE 修改记录,使用 DELETE 删除记录。使用 SELECT 检索表内数据,使用 WHERE 子句进行筛选。使用 CREATE USER 创建用户,使用 GRANT 授权用户,使用 DROP USER 删除用户。
---
diff --git a/batch-processing.md b/batch-processing.md
new file mode 100644
index 000000000000..96623010cbdb
--- /dev/null
+++ b/batch-processing.md
@@ -0,0 +1,97 @@
+---
+title: 数据批量处理
+summary: 介绍了 TiDB 为数据批量处理场景提供的功能,包括 Pipelined DML、非事务性 DML、IMPORT INTO 语句以及已被废弃的 batch-dml。
+---
+
+# 数据批量处理
+
+批量数据处理是实际业务中常见且重要的操作,它涉及到对大量数据进行高效操作,如数据迁移、批量导入、归档操作或大规模更新等。
+
+为了提升批量处理性能,TiDB 随着版本的演进提供了多种数据批量处理功能:
+
+- 数据导入
+ - `IMPORT INTO` 语句(从 TiDB v7.2.0 开始引入,在 v7.5.0 成为正式功能)
+- 数据增删改
+ - Pipelined DML(从 TiDB v8.0.0 开始引入,实验特性)
+ - 非事务性 DML(从 TiDB v6.1.0 开始引入)
+ - 已废弃的 batch-dml 功能
+
+本文分别介绍这些功能的主要优势、限制和使用场景,帮助你根据实际需求选择合适的方案,从而更高效地完成批量数据处理任务。
+
+## 数据导入
+
+`IMPORT INTO` 语句专为数据导入设计,使你无需单独部署 [TiDB Lightning](/tidb-lightning/tidb-lightning-overview.md),即可将 CSV、SQL 或 PARQUET 等格式的数据快速导入到 TiDB 的一张空表中。
+
+主要优势:
+
+- 导入速度非常快。
+- 比 TiDB Lightning 更易用。
+
+主要限制:
+
+- 不满足事务 [ACID](/glossary.md#acid) 性质。
+- 使用限制较多。
+
+适用场景:
+
+- 数据导入场景,例如数据迁移、数据恢复等。建议在合适的场景下,使用 IMPORT INTO 代替 TiDB Lightning。
+
+更多信息,请参考 [`IMPORT INTO`](/sql-statements/sql-statement-import-into.md)。
+
+## 数据增删改
+
+### Pipelined DML
+
+Pipelined DML 是从 TiDB v8.0.0 开始引入的实验特性。在 v8.5.0 中,TiDB 对该功能进行了完善,其性能得到大幅提升。
+
+主要优势:
+
+- 在事务执行过程中,通过将数据持续写入存储层,而不是全部缓存在内存中,使得事务大小不再受到 TiDB 内存限制,支持处理超大规模数据。
+- 性能比标准 DML 更好。
+- 通过系统变量启用,无需修改 SQL 语句。
+
+主要限制:
+
+- 只适用于[自动提交](/transaction-overview.md#自动提交)的 `INSERT`、`REPLACE`、`UPDATE`、`DELETE` 语句。
+
+适用场景:
+
+- 通用的批量数据处理场景,例如大量数据的插入、更新、删除等。
+
+更多信息,请参考 [Pipelined DML](/pipelined-dml.md)。
+
+### 非事务 DML 语句
+
+非事务 DML 语句是从 TiDB v6.1.0 开始引入的功能。在 v6.1.0 中,该功能仅支持 `DELETE` 语句。从 v6.5.0 起,该功能新增支持 `INSERT`、`REPLACE`、`UPDATE` 语句。
+
+主要优势:
+
+- 通过将一条 SQL 语句拆为多条语句执行,使得每个语句的事务更小,绕开内存限制。
+- 处理速度比标准 DML 稍快或相当。
+
+主要限制:
+
+- 只适用于[自动提交](/transaction-overview.md#自动提交)的语句。
+- 需要修改 SQL 语句。
+- 对 SQL 语句本身限制较多,不符合条件的语句可能需要改写。
+- 因为 SQL 语句被拆分执行,不具有完整的事务 ACID 性质,在失败时语句可能部分完成。
+
+适用场景:
+
+- 大量数据的插入、更新、删除等场景。由于限制较多,建议在 Pipelined DML 不适用的场景下考虑使用。
+
+更多信息,请参考[非事务 DML 语句](/non-transactional-dml.md)。
+
+### 已被废弃的 batch-dml
+
+TiDB 在 v4.0 之前提供了 batch-dml 功能,用于批量数据处理。该功能已被废弃,不再推荐使用。batch-dml 功能由以下这些系统变量控制:
+
+- `tidb_batch_insert`
+- `tidb_batch_delete`
+- `tidb_batch_commit`
+- `tidb_enable_batch_dml`
+- `tidb_dml_batch_size`
+
+因为该功能可能引起数据索引不一致,导致数据损坏或丢失,以上变量已被废弃,并计划将在未来的版本中逐渐移除。
+
+不建议在任何场景下使用已被废弃的 batch-dml 功能。建议选择上面描述的其它方案。
\ No newline at end of file
diff --git a/benchmark/benchmark-sysbench-v2.md b/benchmark/benchmark-sysbench-v2.md
index 5e8a1b86018b..ef5ce303a384 100644
--- a/benchmark/benchmark-sysbench-v2.md
+++ b/benchmark/benchmark-sysbench-v2.md
@@ -1,6 +1,5 @@
---
title: TiDB Sysbench 性能对比测试报告 - v2.0.0 对比 v1.0.0
-aliases: ['/docs-cn/dev/benchmark/benchmark-sysbench-v2/','/docs-cn/dev/benchmark/sysbench-v2/']
summary: TiDB 2.0 版本和 1.0 版本在 OLTP 场景下进行性能对比测试。测试结果显示,GA 2.0 在 Select 查询性能上提升了约 10%,在 OLTP 性能上基本一致,而在 Insert 性能上略有提升。
---
diff --git a/benchmark/benchmark-sysbench-v3.md b/benchmark/benchmark-sysbench-v3.md
index f320cd97e7df..30c8f7050118 100644
--- a/benchmark/benchmark-sysbench-v3.md
+++ b/benchmark/benchmark-sysbench-v3.md
@@ -1,6 +1,5 @@
---
title: TiDB Sysbench 性能对比测试报告 - v2.1 对比 v2.0
-aliases: ['/docs-cn/dev/benchmark/benchmark-sysbench-v3/','/docs-cn/dev/benchmark/sysbench-v3/']
summary: TiDB 2.1 版本在 Point Select 查询性能上提升了 50%,而在 Update Non-Index 和 Update Index 写入性能上与 2.0 版本基本一致。
---
diff --git a/benchmark/benchmark-sysbench-v4-vs-v3.md b/benchmark/benchmark-sysbench-v4-vs-v3.md
index 4fc8c49771b4..c97c849a18c0 100644
--- a/benchmark/benchmark-sysbench-v4-vs-v3.md
+++ b/benchmark/benchmark-sysbench-v4-vs-v3.md
@@ -1,6 +1,5 @@
---
title: TiDB Sysbench 性能对比测试报告 - v4.0 对比 v3.0
-aliases: ['/docs-cn/dev/benchmark/benchmark-sysbench-v4-vs-v3/']
summary: TiDB v4.0 在 OLTP 场景下的性能优于 v3.0。Point Select、Update Non-index、Update Index 和 Read Write 性能分别提升了 14%、15%、17% 和 31%。
---
diff --git a/benchmark/benchmark-sysbench-v5-vs-v4.md b/benchmark/benchmark-sysbench-v5-vs-v4.md
deleted file mode 100644
index 12cae52e7780..000000000000
--- a/benchmark/benchmark-sysbench-v5-vs-v4.md
+++ /dev/null
@@ -1,223 +0,0 @@
----
-title: TiDB Sysbench 性能对比测试报告 - v5.0 对比 v4.0
-summary: TiDB v5.0 在 OLTP 场景下的性能测试结果显示,Point Select 性能提升了 2.7%,Update Non-index 性能提升了 81%,Update Index 性能提升了 28%,Read Write 性能提升了 9%。这表明在 AWS EC2 环境下,TiDB v5.0 相对于 v4.0 在各项性能指标上都有所提升。
----
-
-# TiDB Sysbench 性能对比测试报告 - v5.0 对比 v4.0
-
-## 测试目的
-
-测试对比 TiDB v5.0 和 v4.0 在 OLTP 场景下的性能。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| Sysbench | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | 4.0、5.0 |
-| TiDB | 4.0、5.0 |
-| TiKV | 4.0、5.0 |
-| Sysbench | 1.0.20 |
-
-### 参数配置
-
-#### TiDB v4.0 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-performance.max-procs: 20
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV v4.0 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-storage.scheduler-worker-pool-size: 5
-raftstore.store-pool-size: 3
-raftstore.apply-pool-size: 3
-rocksdb.max-background-jobs: 3
-raftdb.max-background-jobs: 3
-raftdb.allow-concurrent-memtable-write: true
-server.grpc-concurrency: 6
-readpool.unified.min-thread-count: 5
-readpool.unified.max-thread-count: 20
-readpool.storage.normal-concurrency: 10
-pessimistic-txn.pipelined: true
-```
-
-#### TiDB v5.0 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-performance.max-procs: 20
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV v5.0 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-storage.scheduler-worker-pool-size: 5
-raftstore.store-pool-size: 3
-raftstore.apply-pool-size: 3
-rocksdb.max-background-jobs: 8
-raftdb.max-background-jobs: 4
-raftdb.allow-concurrent-memtable-write: true
-server.grpc-concurrency: 6
-readpool.unified.min-thread-count: 5
-readpool.unified.max-thread-count: 20
-readpool.storage.normal-concurrency: 10
-pessimistic-txn.pipelined: true
-server.enable-request-batch: false
-```
-
-#### TiDB v4.0 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-```
-
-#### TiDB v5.0 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v5.0 和 v4.0。
-2. 通过 Sysbench 导入 16 张表,每张表有 1000 万行数据。
-3. 分别对每个表执行 `analyze table` 命令。
-4. 备份数据,用于不同并发测试前进行数据恢复,以保证每次数据一致。
-5. 启动 Sysbench 客户端,进行 `point_select`、`read_write`、`update_index` 和 `update_non_index` 测试。通过 AWS NLB 向 TiDB 加压,单轮预热 1 分钟,测试 5 分钟。
-6. 每轮完成后停止集群,使用之前的备份的数据覆盖,再启动集群。
-
-### 准备测试数据
-
-执行以下命令来准备测试数据:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench oltp_common \
- --threads=16 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- --mysql-user=root \
- --mysql-password=password \
- prepare --tables=16 --table-size=10000000
-```
-
-### 执行测试命令
-
-执行以下命令来执行测试:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench $testname \
- --threads=$threads \
- --time=300 \
- --report-interval=1 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- run --tables=16 --table-size=10000000
-```
-
-## 测试结果
-
-### Point Select 性能
-
-| Threads | v4.0 QPS | v4.0 95% latency (ms) | v5.0 QPS | v5.0 95% latency (ms) | QPS 提升 |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-| 150 | 159451.19 | 1.32 | 177876.25 | 1.23 | 11.56% |
-| 300 | 244790.38 | 1.96 | 252675.03 | 1.82 | 3.22% |
-| 600 | 322929.05 | 3.75 | 331956.84 | 3.36 | 2.80% |
-| 900 | 364840.05 | 5.67 | 365655.04 | 5.09 | 0.22% |
-| 1200 | 376529.18 | 7.98 | 366507.47 | 7.04 | -2.66% |
-| 1500 | 368390.52 | 10.84 | 372476.35 | 8.90 | 1.11% |
-
-v5.0 对比 v4.0,Point Select 性能提升了 2.7%。
-
-
-
-### Update Non-index 性能
-
-| Threads | v4.0 QPS | v4.0 95% latency (ms) | v5.0 QPS | v5.0 95% latency (ms) | QPS 提升 |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-| 150 | 17243.78 | 11.04 | 30866.23 | 6.91 | 79.00% |
-| 300 | 25397.06 | 15.83 | 45915.39 | 9.73 | 80.79% |
-| 600 | 33388.08 | 25.28 | 60098.52 | 16.41 | 80.00% |
-| 900 | 38291.75 | 36.89 | 70317.41 | 21.89 | 83.64% |
-| 1200 | 41003.46 | 55.82 | 76376.22 | 28.67 | 86.27% |
-| 1500 | 44702.84 | 62.19 | 80234.58 | 34.95 | 79.48% |
-
-v5.0 对比 v4.0,Update Non-index 性能提升了 81%。
-
-
-
-### Update Index 性能
-
-| Threads | v4.0 QPS | v4.0 95% latency (ms) | v5.0 QPS | v5.0 95% latency (ms) | QPS 提升 |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-| 150 | 11736.21 | 17.01 | 15631.34 | 17.01 | 33.19% |
-| 300 | 15435.95 | 28.67 | 19957.06 | 22.69 | 29.29% |
-| 600 | 18983.21 | 49.21 | 23218.14 | 41.85 | 22.31% |
-| 900 | 20855.29 | 74.46 | 26226.76 | 53.85 | 25.76% |
-| 1200 | 21887.64 | 102.97 | 28505.41 | 69.29 | 30.24% |
-| 1500 | 23621.15 | 110.66 | 30341.06 | 82.96 | 28.45% |
-
-v5.0 对比 v4.0,Update Index 性能提升了 28%。
-
-
-
-### Read Write 性能
-
-| Threads | v4.0 QPS | v4.0 95% latency (ms) | v5.0 QPS | v5.0 95% latency (ms) | QPS 提升 |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-| 150 | 59979.91 | 61.08 | 66098.57 | 55.82 | 10.20% |
-| 300 | 77118.32 | 102.97 | 84639.48 | 90.78 | 9.75% |
-| 600 | 90619.52 | 183.21 | 101477.46 | 167.44 | 11.98% |
-| 900 | 97085.57 | 267.41 | 109463.46 | 240.02 | 12.75% |
-| 1200 | 106521.61 | 331.91 | 115416.05 | 320.17 | 8.35% |
-| 1500 | 116278.96 | 363.18 | 118807.5 | 411.96 | 2.17% |
-
-v5.0 对比 v4.0,Read Write 性能提升了 9%。
-
-
diff --git a/benchmark/benchmark-sysbench-v5.1.0-vs-v5.0.2.md b/benchmark/benchmark-sysbench-v5.1.0-vs-v5.0.2.md
deleted file mode 100644
index a45240256eb9..000000000000
--- a/benchmark/benchmark-sysbench-v5.1.0-vs-v5.0.2.md
+++ /dev/null
@@ -1,187 +0,0 @@
----
-title: TiDB Sysbench 性能对比测试报告 - v5.1.0 对比 v5.0.2
-summary: TiDB v5.1.0 在 OLTP 场景下的 Sysbench 性能表现对比 v5.0.2。Point Select 性能提升了 19.4%,Read Write 和 Update Index 性能略有下降。测试环境为 AWS EC2,硬件配置包括 PD、TiKV、TiDB 和 Sysbench。软件版本为 v5.0.2、v5.1.0。参数配置相同。测试方案包括部署、数据准备和执行测试。测试结果显示各场景性能对比情况。
----
-
-# TiDB Sysbench 性能对比测试报告 - v5.1.0 对比 v5.0.2
-
-## 测试概况
-
-本次测试对比了 TiDB v5.1.0 和 v5.0.2 在 OLTP 场景下的 Sysbench 性能表现。结果显示,v5.1.0 相比于 v5.0.2,Point Select 场景性能提升了 19.4%,Read Write 和 Update Index 场景性能略有下降。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| Sysbench | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | v5.0.2、v5.1.0 |
-| TiDB | v5.0.2、v5.1.0 |
-| TiKV | v5.0.2、v5.1.0 |
-| Sysbench | 1.0.20 |
-
-### 参数配置
-
-两个版本使用相同的配置
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-performance.max-procs: 20
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-storage.scheduler-worker-pool-size: 5
-raftstore.store-pool-size: 3
-raftstore.apply-pool-size: 3
-rocksdb.max-background-jobs: 8
-raftdb.max-background-jobs: 4
-raftdb.allow-concurrent-memtable-write: true
-server.grpc-concurrency: 6
-readpool.unified.min-thread-count: 5
-readpool.unified.max-thread-count: 20
-readpool.storage.normal-concurrency: 10
-pessimistic-txn.pipelined: true
-server.enable-request-batch: false
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v5.1.0 和 v5.0.2。
-2. 通过 Sysbench 导入 16 张表,每张表有 1000 万行数据。
-3. 分别对每个表执行 `analyze table` 命令。
-4. 备份数据,用于不同并发测试前进行数据恢复,以保证每次数据一致。
-5. 启动 Sysbench 客户端,进行 `point_select`、`read_write`、`update_index` 和 `update_non_index` 测试。通过 HAProxy 向 TiDB 加压,测试 5 分钟。
-6. 每轮完成后停止集群,使用之前的备份的数据覆盖,再启动集群。
-
-### 准备测试数据
-
-执行以下命令来准备测试数据:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench oltp_common \
- --threads=16 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- --mysql-user=root \
- --mysql-password=password \
- prepare --tables=16 --table-size=10000000
-```
-
-### 执行测试命令
-
-执行以下命令来执行测试:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench $testname \
- --threads=$threads \
- --time=300 \
- --report-interval=1 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- run --tables=16 --table-size=10000000
-```
-
-## 测试结果
-
-### Point Select 性能
-
-| Threads | v5.0.2 QPS | v5.0.2 95% latency (ms) | v5.1.0 QPS | v5.1.0 95% latency (ms) | QPS 提升 |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|150|137732.27|1.86|158861.67|2|15.34%|
-|300|201420.58|2.91|238038.44|2.71|18.18%|
-|600|303631.52|3.49|428573.21|2.07|41.15%|
-|900|383628.13|3.55|464863.22|3.89|21.18%|
-|1200|391451.54|5.28|413656.74|13.46|5.67%|
-|1500|410276.93|7.43|471418.78|10.65|14.90%|
-
-v5.1.0 对比 v5.0.2,Point Select 性能提升了 19.4%。
-
-
-
-### Update Non-index 性能
-
-| Threads | v5.0.2 QPS | v5.0.2 95% latency (ms) | v5.1.0 QPS | v5.1.0 95% latency (ms) | QPS 提升 |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|150|29248.2|7.17|29362.7|8.13|0.39%|
-|300|40316.09|12.52|39651.52|13.7|-1.65%|
-|600|51011.11|22.28|47047.9|27.66|-7.77%|
-|900|58814.16|27.66|59331.84|28.67|0.88%|
-|1200|65286.52|32.53|67745.39|31.37|3.77%|
-|1500|68300.86|39.65|67899.17|44.17|-0.59%|
-
-v5.1.0 对比 v5.0.2,Update Non-index 性能下降了 0.8%。
-
-
-
-### Update Index 性能
-
-| Threads | v5.0.2 QPS | v5.0.2 95% latency (ms) | v5.1.0 QPS | v5.1.0 95% latency (ms) | QPS 提升 |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|150|15066.54|14.73|14829.31|14.73|-1.57%|
-|300|18535.92|24.83|17401.01|29.72|-6.12%|
-|600|22862.73|41.1|21923.78|44.98|-4.11%|
-|900|25286.74|57.87|24916.76|58.92|-1.46%|
-|1200|27566.18|70.55|27800.62|69.29|0.85%|
-|1500|28184.76|92.42|28679.72|86|1.76%|
-
-v5.1.0 对比 v5.0.2,Update Index 性能下降了 1.8%。
-
-
-
-### Read Write 性能
-
-| Threads | v5.0.2 QPS | v5.0.2 95% latency (ms) | v5.1.0 QPS | v5.1.0 95% latency (ms) | QPS 提升 |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|150|66415.33|56.84|66591.49|57.87|0.27%|
-|300|82488.39|97.55|81226.41|101.13|-1.53%|
-|600|99195.36|173.58|97357.86|179.94|-1.85%|
-|900|107382.76|253.35|101665.95|267.41|-5.32%|
-|1200|112389.23|337.94|107426.41|350.33|-4.42%|
-|1500|113548.73|450.77|109805.26|442.73|-3.30%|
-
-v5.1.0 对比 v5.0.2,Read Write 性能下降了 2.7%。
-
-
diff --git a/benchmark/benchmark-sysbench-v5.2.0-vs-v5.1.1.md b/benchmark/benchmark-sysbench-v5.2.0-vs-v5.1.1.md
deleted file mode 100644
index e7c4769ac2fe..000000000000
--- a/benchmark/benchmark-sysbench-v5.2.0-vs-v5.1.1.md
+++ /dev/null
@@ -1,187 +0,0 @@
----
-title: TiDB Sysbench 性能对比测试报告 - v5.2.0 对比 v5.1.1
-summary: TiDB v5.2.0 在 OLTP 场景下的 Sysbench 性能对比测试显示,Point Select 性能提升了 11.03%,但其余场景性能略有下降。硬件配置为 PD m5.xlarge 3 台、TiKV i3.4xlarge 3 台、TiDB c5.4xlarge 3 台、Sysbench c5.9xlarge 1 台。软件版本为 PD v5.1.1、v5.2.0、TiDB v5.1.1、v5.2.0、TiKV v5.1.1、v5.2.0、Sysbench 1.1.0-ead2689。测试方案包括数据准备、执行测试命令和测试结果。Point Select 性能提升 11.03%,Update Non-index 性能下降 1.98%,Update Index 性能下降 4.33%,Read Write 性能下降 1.24%。
----
-
-# TiDB Sysbench 性能对比测试报告 - v5.2.0 对比 v5.1.1
-
-## 测试概况
-
-本次测试对比了 TiDB v5.2.0 和 v5.1.1 在 OLTP 场景下的 Sysbench 性能表现。结果显示,v5.2.0 相比于 v5.1.1,Point Select 场景性能提升了 11.03%,其余场景性能略有下降。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| Sysbench | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | v5.1.1、v5.2.0 |
-| TiDB | v5.1.1、v5.2.0 |
-| TiKV | v5.1.1、v5.2.0 |
-| Sysbench | 1.1.0-ead2689 |
-
-### 参数配置
-
-两个版本使用相同的配置
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-performance.max-procs: 20
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-storage.scheduler-worker-pool-size: 5
-raftstore.store-pool-size: 3
-raftstore.apply-pool-size: 3
-rocksdb.max-background-jobs: 8
-raftdb.max-background-jobs: 4
-raftdb.allow-concurrent-memtable-write: true
-server.grpc-concurrency: 6
-readpool.unified.min-thread-count: 5
-readpool.unified.max-thread-count: 20
-readpool.storage.normal-concurrency: 10
-pessimistic-txn.pipelined: true
-server.enable-request-batch: false
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v5.2.0 和 v5.1.1。
-2. 通过 Sysbench 导入 16 张表,每张表有 1000 万行数据。
-3. 分别对每个表执行 `analyze table` 命令。
-4. 备份数据,用于不同并发测试前进行数据恢复,以保证每次数据一致。
-5. 启动 Sysbench 客户端,进行 `point_select`、`read_write`、`update_index` 和 `update_non_index` 测试。通过 HAProxy 向 TiDB 加压,测试 5 分钟。
-6. 每轮完成后停止集群,使用之前的备份的数据覆盖,再启动集群。
-
-### 准备测试数据
-
-执行以下命令来准备测试数据:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench oltp_common \
- --threads=16 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- --mysql-user=root \
- --mysql-password=password \
- prepare --tables=16 --table-size=10000000
-```
-
-### 执行测试命令
-
-执行以下命令来执行测试:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench $testname \
- --threads=$threads \
- --time=300 \
- --report-interval=1 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- run --tables=16 --table-size=10000000
-```
-
-## 测试结果
-
-### Point Select 性能
-
-| Threads | v5.1.1 QPS | v5.1.1 95% latency (ms) | v5.2.0 QPS | v5.2.0 95% latency (ms) | QPS 提升 |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|150|143014.13|2.35|174402.5|1.23|21.95%|
-|300|199133.06|3.68|272018|1.64|36.60%|
-|600|389391.65|2.18|393536.4|2.11|1.06%|
-|900|468338.82|2.97|447981.98|3.3|-4.35%|
-|1200|448348.52|5.18|468241.29|4.65|4.44%|
-|1500|454376.79|7.04|483888.42|6.09|6.49%|
-
-v5.2.0 对比 v5.1.1,Point Select 性能提升了 11.03%。
-
-
-
-### Update Non-index 性能
-
-| Threads | v5.1.1 QPS | v5.1.1 95% latency (ms) | v5.2.0 QPS | v5.2.0 95% latency (ms) | QPS 提升 |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|150|31198.68|6.43|30714.73|6.09|-1.55%|
-|300|43577.15|10.46|42997.92|9.73|-1.33%|
-|600|57230.18|17.32|56168.81|16.71|-1.85%|
-|900|65325.11|23.1|64098.04|22.69|-1.88%|
-|1200|71528.26|28.67|69908.15|28.67|-2.26%|
-|1500|76652.5|33.12|74371.79|33.72|-2.98%|
-
-v5.2.0 对比 v5.1.1,Update Non-index 性能下降了 1.98%。
-
-
-
-### Update Index 性能
-
-| Threads | v5.1.1 QPS | v5.1.1 95% latency (ms) | v5.2.0 QPS | v5.2.0 95% latency (ms) | QPS 提升 |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|150|15641.04|13.22|15320|13.46|-2.05%|
-|300|19787.73|21.89|19161.35|22.69|-3.17%|
-|600|24566.74|36.89|23616.07|38.94|-3.87%|
-|900|27516.57|50.11|26270.04|54.83|-4.53%|
-|1200|29421.10|63.32|28002.65|69.29|-4.82%|
-|1500|30957.84|77.19|28624.44|95.81|-7.54%|
-
-v5.2.0 对比 v5.1.1,Update Index 性能下降了 4.33%。
-
-
-
-### Read Write 性能
-
-| Threads | v5.1.1 QPS | v5.1.1 95% latency (ms) | v5.2.0 QPS | v5.2.0 95% latency (ms) | QPS 提升 |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|150|68471.02|57.87|69246|54.83|1.13%|
-|300|86573.09|97.55|85340.42|94.10|-1.42%|
-|600|101760.75|176.73|102221.31|173.58|0.45%|
-|900|111877.55|248.83|109276.45|257.95|-2.32%|
-|1200|117479.4|337.94|114231.33|344.08|-2.76%|
-|1500|119662.91|419.45|116663.28|434.83|-2.51%|
-
-v5.2.0 对比 v5.1.1,Read Write 性能下降了 1.24%。
-
-
diff --git a/benchmark/benchmark-sysbench-v5.3.0-vs-v5.2.2.md b/benchmark/benchmark-sysbench-v5.3.0-vs-v5.2.2.md
deleted file mode 100644
index 6ab0cb0d16d2..000000000000
--- a/benchmark/benchmark-sysbench-v5.3.0-vs-v5.2.2.md
+++ /dev/null
@@ -1,205 +0,0 @@
----
-title: TiDB Sysbench 性能对比测试报告 - v5.3.0 对比 v5.2.2
-summary: TiDB v5.3.0 和 v5.2.2 在 OLTP 场景下的 Sysbench 性能对比测试结果显示,v5.3.0 相比于 v5.2.2,性能基本持平。具体测试结果如下:Point Select 性能:v5.3.0 略下降了 0.81%、Update Non-index 性能:v5.3.0 略上升了 0.95%、Update Index 性能:v5.3.0 略上升了 1.83%、Read Write 性能:v5.3.0 略下降了 0.62%。
----
-
-# TiDB Sysbench 性能对比测试报告 - v5.3.0 对比 v5.2.2
-
-## 测试概况
-
-本次测试对比了 TiDB v5.3.0 和 v5.2.2 在 OLTP 场景下的 Sysbench 性能表现。结果显示,v5.3.0 相比于 v5.2.2,性能基本持平。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| Sysbench | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | v5.2.2、v5.3.0 |
-| TiDB | v5.2.2、v5.3.0 |
-| TiKV | v5.2.2、v5.3.0 |
-| Sysbench | 1.1.0-ead2689 |
-
-### 参数配置
-
-两个版本使用相同的配置
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-performance.max-procs: 20
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-storage.scheduler-worker-pool-size: 5
-raftstore.store-pool-size: 3
-raftstore.apply-pool-size: 3
-rocksdb.max-background-jobs: 8
-raftdb.max-background-jobs: 4
-raftdb.allow-concurrent-memtable-write: true
-server.grpc-concurrency: 6
-readpool.unified.min-thread-count: 5
-readpool.unified.max-thread-count: 20
-readpool.storage.normal-concurrency: 10
-pessimistic-txn.pipelined: true
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-```
-
-#### HAProxy 配置 - haproxy.cfg 文件
-
-更多有关 HAProxy 在 TiDB 上的使用,可参阅 [HAProxy 在 TiDB 中的最佳实践](/best-practices/haproxy-best-practices.md)。
-
-{{< copyable "" >}}
-
-```yaml
-global # 全局配置。
- chroot /var/lib/haproxy # 更改当前目录并为启动进程设置超级用户权限,从而提高安全性。
- pidfile /var/run/haproxy.pid # 将 HAProxy 进程的 PID 写入 pidfile。
- maxconn 4000 # 每个 HAProxy 进程所接受的最大并发连接数。
- user haproxy # 同 UID 参数。
- group haproxy # 同 GID 参数,建议使用专用用户组。
- nbproc 64 # 在后台运行时创建的进程数。在启动多个进程转发请求时,确保该值足够大,保证 HAProxy 不会成为瓶颈。
- daemon # 让 HAProxy 以守护进程的方式工作于后台,等同于命令行参数“-D”的功能。当然,也可以在命令行中用“-db”参数将其禁用。
-
-defaults # 默认配置。
- log global # 日志继承全局配置段的设置。
- retries 2 # 向上游服务器尝试连接的最大次数,超过此值便认为后端服务器不可用。
- timeout connect 2s # HAProxy 与后端服务器连接超时时间。如果在同一个局域网内,可设置成较短的时间。
- timeout client 30000s # 客户端与 HAProxy 连接后,数据传输完毕,即非活动连接的超时时间。
- timeout server 30000s # 服务器端非活动连接的超时时间。
-
-listen tidb-cluster # 配置 database 负载均衡。
- bind 0.0.0.0:3390 # 浮动 IP 和 监听端口。
- mode tcp # HAProxy 要使用第 4 层的传输层。
- balance roundrobin # 连接数最少的服务器优先接收连接。`leastconn` 建议用于长会话服务,例如 LDAP、SQL、TSE 等,而不是短会话协议,如 HTTP。该算法是动态的,对于启动慢的服务器,服务器权重会在运行中作调整。
- server tidb-1 10.9.18.229:4000 check inter 2000 rise 2 fall 3 # 检测 4000 端口,检测频率为每 2000 毫秒一次。如果 2 次检测为成功,则认为服务器可用;如果 3 次检测为失败,则认为服务器不可用。
- server tidb-2 10.9.39.208:4000 check inter 2000 rise 2 fall 3
- server tidb-3 10.9.64.166:4000 check inter 2000 rise 2 fall 3
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v5.3.0 和 v5.2.2。
-2. 通过 Sysbench 导入 16 张表,每张表有 1000 万行数据。
-3. 分别对每个表执行 `analyze table` 命令。
-4. 备份数据,用于不同并发测试前进行数据恢复,以保证每次数据一致。
-5. 启动 Sysbench 客户端,进行 `point_select`、`read_write`、`update_index` 和 `update_non_index` 测试。通过 HAProxy 向 TiDB 加压,每种负载每个并发数各测试 20 分钟。
-6. 每轮完成后停止集群,使用之前的备份的数据覆盖,再启动集群。
-
-### 准备测试数据
-
-执行以下命令来准备测试数据:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench oltp_common \
- --threads=16 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- --mysql-user=root \
- --mysql-password=password \
- prepare --tables=16 --table-size=10000000
-```
-
-### 执行测试命令
-
-执行以下命令来执行测试:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench $testname \
- --threads=$threads \
- --time=1200 \
- --report-interval=1 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- run --tables=16 --table-size=10000000
-```
-
-## 测试结果
-
-### Point Select 性能
-
-| Threads | v5.2.2 TPS | v5.3.0 TPS | v5.2.2 95% latency (ms) | v5.3.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|267673.17|267516.77|1.76|1.67|-0.06|
-|600|369820.29|361672.56|2.91|2.97|-2.20|
-|900|417143.31|416479.47|4.1|4.18|-0.16|
-
-v5.3.0 对比 v5.2.2,Point Select 性能基本持平,略下降了 0.81%。
-
-
-
-### Update Non-index 性能
-
-| Threads | v5.2.2 TPS | v5.3.0 TPS | v5.2.2 95% latency (ms) | v5.3.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|39715.31|40041.03|11.87|12.08|0.82|
-|600|50239.42|51110.04|20.74|20.37|1.73|
-|900|57073.97|57252.74|28.16|27.66|0.31|
-
-v5.3.0 对比 v5.2.2,Update Non-index 性能基本持平,略上升了 0.95%。
-
-
-
-### Update Index 性能
-
-| Threads | v5.2.2 TPS | v5.3.0 TPS | v5.2.2 95% latency (ms) | v5.3.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|17634.03|17821.1|25.74|25.74|1.06|
-|600|20998.59|21534.13|46.63|45.79|2.55|
-|900|23420.75|23859.64|64.47|62.19|1.87|
-
-v5.3.0 对比 v5.2.2,Update Index 性能基本持平,略上升了 1.83%。
-
-
-
-### Read Write 性能
-
-| Threads | v5.2.2 TPS | v5.3.0 TPS | v5.2.2 95% latency (ms) | v5.3.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|3872.01|3848.63|106.75|106.75|-0.60|
-|600|4514.17|4471.77|200.47|196.89|-0.94|
-|900|4877.05|4861.45|287.38|282.25|-0.32|
-
-v5.3.0 对比 v5.2.2,Read Write 性能基本持平,略下降了 0.62%。
-
-
diff --git a/benchmark/benchmark-sysbench-v5.4.0-vs-v5.3.0.md b/benchmark/benchmark-sysbench-v5.4.0-vs-v5.3.0.md
deleted file mode 100644
index edf021fb5224..000000000000
--- a/benchmark/benchmark-sysbench-v5.4.0-vs-v5.3.0.md
+++ /dev/null
@@ -1,205 +0,0 @@
----
-title: TiDB Sysbench 性能对比测试报告 - v5.4.0 对比 v5.3.0
-summary: TiDB v5.4.0 在 OLTP 场景下的 Sysbench 性能比 v5.3.0 有所提升,其中写负载性能提升了 2.59% ~ 4.85%。测试环境为 AWS EC2,硬件配置包括 PD、TiKV、TiDB 和 Sysbench 实例。两个版本使用相同的配置,通过 TiUP 部署。测试结果显示 Point Select 性能基本持平,Update Non-index 性能提升了 2.59%,Update Index 性能提升了 4.85%,Read Write 性能提升了 3.30%。
----
-
-# TiDB Sysbench 性能对比测试报告 - v5.4.0 对比 v5.3.0
-
-## 测试概况
-
-本次测试对比了 TiDB v5.4.0 和 v5.3.0 在 OLTP 场景下的 Sysbench 性能表现。结果显示,相比于 v5.3.0,v5.4.0 的写负载 (Write-heavy Workload) 性能有 2.59% ~ 4.85% 的提升。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| Sysbench | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | v5.3.0、v5.4.0 |
-| TiDB | v5.3.0、v5.4.0 |
-| TiKV | v5.3.0、v5.4.0 |
-| Sysbench | 1.1.0-ead2689 |
-
-### 参数配置
-
-两个版本使用相同的配置
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-performance.max-procs: 20
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-storage.scheduler-worker-pool-size: 5
-raftstore.store-pool-size: 3
-raftstore.apply-pool-size: 3
-rocksdb.max-background-jobs: 8
-raftdb.max-background-jobs: 4
-raftdb.allow-concurrent-memtable-write: true
-server.grpc-concurrency: 6
-readpool.unified.min-thread-count: 5
-readpool.unified.max-thread-count: 20
-readpool.storage.normal-concurrency: 10
-pessimistic-txn.pipelined: true
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-```
-
-#### HAProxy 配置 - haproxy.cfg 文件
-
-更多有关 HAProxy 在 TiDB 上的使用,可参阅 [HAProxy 在 TiDB 中的最佳实践](/best-practices/haproxy-best-practices.md)。
-
-{{< copyable "" >}}
-
-```yaml
-global # 全局配置。
- chroot /var/lib/haproxy # 更改当前目录并为启动进程设置超级用户权限,从而提高安全性。
- pidfile /var/run/haproxy.pid # 将 HAProxy 进程的 PID 写入 pidfile。
- maxconn 4000 # 每个 HAProxy 进程所接受的最大并发连接数。
- user haproxy # 同 UID 参数。
- group haproxy # 同 GID 参数,建议使用专用用户组。
- nbproc 64 # 在后台运行时创建的进程数。在启动多个进程转发请求时,确保该值足够大,保证 HAProxy 不会成为瓶颈。
- daemon # 让 HAProxy 以守护进程的方式工作于后台,等同于命令行参数“-D”的功能。当然,也可以在命令行中用“-db”参数将其禁用。
-
-defaults # 默认配置。
- log global # 日志继承全局配置段的设置。
- retries 2 # 向上游服务器尝试连接的最大次数,超过此值便认为后端服务器不可用。
- timeout connect 2s # HAProxy 与后端服务器连接超时时间。如果在同一个局域网内,可设置成较短的时间。
- timeout client 30000s # 客户端与 HAProxy 连接后,数据传输完毕,即非活动连接的超时时间。
- timeout server 30000s # 服务器端非活动连接的超时时间。
-
-listen tidb-cluster # 配置 database 负载均衡。
- bind 0.0.0.0:3390 # 浮动 IP 和 监听端口。
- mode tcp # HAProxy 要使用第 4 层的传输层。
- balance roundrobin # 连接数最少的服务器优先接收连接。`leastconn` 建议用于长会话服务,例如 LDAP、SQL、TSE 等,而不是短会话协议,如 HTTP。该算法是动态的,对于启动慢的服务器,服务器权重会在运行中作调整。
- server tidb-1 10.9.18.229:4000 check inter 2000 rise 2 fall 3 # 检测 4000 端口,检测频率为每 2000 毫秒一次。如果 2 次检测为成功,则认为服务器可用;如果 3 次检测为失败,则认为服务器不可用。
- server tidb-2 10.9.39.208:4000 check inter 2000 rise 2 fall 3
- server tidb-3 10.9.64.166:4000 check inter 2000 rise 2 fall 3
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v5.4.0 和 v5.3.0。
-2. 通过 Sysbench 导入 16 张表,每张表有 1000 万行数据。
-3. 分别对每个表执行 `analyze table` 命令。
-4. 备份数据,用于不同并发测试前进行数据恢复,以保证每次数据一致。
-5. 启动 Sysbench 客户端,进行 `point_select`、`read_write`、`update_index` 和 `update_non_index` 测试。通过 HAProxy 向 TiDB 加压,每种负载每个并发数各测试 20 分钟。
-6. 每轮完成后停止集群,使用之前的备份的数据覆盖,再启动集群。
-
-### 准备测试数据
-
-执行以下命令来准备测试数据:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench oltp_common \
- --threads=16 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- --mysql-user=root \
- --mysql-password=password \
- prepare --tables=16 --table-size=10000000
-```
-
-### 执行测试命令
-
-执行以下命令来执行测试:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench $testname \
- --threads=$threads \
- --time=1200 \
- --report-interval=1 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- run --tables=16 --table-size=10000000
-```
-
-## 测试结果
-
-### Point Select 性能
-
-| Threads | v5.3.0 TPS | v5.4.0 TPS | v5.3.0 95% latency (ms) | v5.4.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|266041.84|264345.73|1.96|2.07|-0.64|
-|600|351782.71|348715.98|3.43|3.49|-0.87|
-|900|386553.31|399777.11|5.09|4.74|3.42|
-
-v5.4.0 对比 v5.3.0,Point Select 性能基本持平,略提升了 0.64%。
-
-
-
-### Update Non-index 性能
-
-| Threads | v5.3.0 TPS | v5.4.0 TPS | v5.3.0 95% latency (ms) | v5.4.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|40804.31|41187.1|11.87|11.87|0.94|
-|600|51239.4|53172.03|20.74|19.65|3.77|
-|900|57897.56|59666.8|27.66|27.66|3.06|
-
-v5.4.0 对比 v5.3.0,Update Non-index 性能提升了 2.59%。
-
-
-
-### Update Index 性能
-
-| Threads | v5.3.0 TPS | v5.4.0 TPS | v5.3.0 95% latency (ms) | v5.4.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|17737.82|18716.5|26.2|24.83|5.52|
-|600|21614.39|22670.74|44.98|42.61|4.89|
-|900|23933.7|24922.05|62.19|61.08|4.13|
-
-v5.4.0 对比 v5.3.0,Update Index 性能提升了 4.85%。
-
-
-
-### Read Write 性能
-
-| Threads | v5.3.0 TPS | v5.4.0 TPS | v5.3.0 95% latency (ms) | v5.4.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|3810.78|3929.29|108.68|106.75|3.11|
-|600|4514.28|4684.64|193.38|186.54|3.77|
-|900|4842.49|4988.49|282.25|277.21|3.01|
-
-v5.4.0 对比 v5.3.0,Read Write 性能提升了 3.30%。
-
-
diff --git a/benchmark/benchmark-sysbench-v6.0.0-vs-v5.4.0.md b/benchmark/benchmark-sysbench-v6.0.0-vs-v5.4.0.md
deleted file mode 100644
index 4a9ea0df0ebc..000000000000
--- a/benchmark/benchmark-sysbench-v6.0.0-vs-v5.4.0.md
+++ /dev/null
@@ -1,201 +0,0 @@
----
-title: TiDB Sysbench 性能对比测试报告 - v6.0.0 对比 v5.4.0
-summary: TiDB v6.0.0 在 OLTP 场景下的 Sysbench 性能表现对比 v5.4.0。结果显示,Read Write 负载性能有大幅提升,提升了 16.17%,其他负载性能基本持平。测试环境为 AWS EC2,硬件配置包括 PD、TiKV、TiDB 和 Sysbench 实例。软件版本为 v5.4.0 和 v6.0.0,参数配置相同。测试方案包括部署 TiDB、导入数据、执行测试命令和备份数据。测试结果显示 Point Select 性能基本持平,Update Non-index 性能基本持平,Update Index 性能下降了 3.05%。Update Index 性能下降了 3.05%。
----
-
-# TiDB Sysbench 性能对比测试报告 - v6.0.0 对比 v5.4.0
-
-## 测试概况
-
-本次测试对比了 TiDB v6.0.0 和 v5.4.0 在 OLTP 场景下的 Sysbench 性能表现。结果显示,相比于 v5.4.0,v6.0.0 的 Read Write 负载性能有大幅提升,提升了 16.17%。其他负载性能基本与 v5.4.0 的持平。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| Sysbench | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | v5.4.0、v6.0.0 |
-| TiDB | v5.4.0、v6.0.0 |
-| TiKV | v5.4.0、v6.0.0 |
-| Sysbench | 1.1.0-df89d34 |
-
-### 参数配置
-
-两个版本使用相同的配置
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-storage.scheduler-worker-pool-size: 5
-raftstore.store-pool-size: 3
-raftstore.apply-pool-size: 3
-rocksdb.max-background-jobs: 8
-raftdb.max-background-jobs: 4
-raftdb.allow-concurrent-memtable-write: true
-server.grpc-concurrency: 6
-readpool.storage.normal-concurrency: 10
-pessimistic-txn.pipelined: true
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-```
-
-#### HAProxy 配置 - haproxy.cfg 文件
-
-更多有关 HAProxy 在 TiDB 上的使用,可参阅 [HAProxy 在 TiDB 中的最佳实践](/best-practices/haproxy-best-practices.md)。
-
-{{< copyable "" >}}
-
-```yaml
-global # 全局配置。
- pidfile /var/run/haproxy.pid # 将 HAProxy 进程的 PID 写入 pidfile。
- maxconn 4000 # 每个 HAProxy 进程所接受的最大并发连接数。
- user haproxy # 同 UID 参数。
- group haproxy # 同 GID 参数,建议使用专用用户组。
- nbproc 64 # 在后台运行时创建的进程数。在启动多个进程转发请求时,确保该值足够大,保证 HAProxy 不会成为瓶颈。
- daemon # 让 HAProxy 以守护进程的方式工作于后台,等同于命令行参数“-D”的功能。当然,也可以在命令行中用“-db”参数将其禁用。
-
-defaults # 默认配置。
- log global # 日志继承全局配置段的设置。
- retries 2 # 向上游服务器尝试连接的最大次数,超过此值便认为后端服务器不可用。
- timeout connect 2s # HAProxy 与后端服务器连接超时时间。如果在同一个局域网内,可设置成较短的时间。
- timeout client 30000s # 客户端与 HAProxy 连接后,数据传输完毕,即非活动连接的超时时间。
- timeout server 30000s # 服务器端非活动连接的超时时间。
-
-listen tidb-cluster # 配置 database 负载均衡。
- bind 0.0.0.0:3390 # 浮动 IP 和 监听端口。
- mode tcp # HAProxy 要使用第 4 层的传输层。
- balance leastconn # 连接数最少的服务器优先接收连接。`leastconn` 建议用于长会话服务,例如 LDAP、SQL、TSE 等,而不是短会话协议,如 HTTP。该算法是动态的,对于启动慢的服务器,服务器权重会在运行中作调整。
- server tidb-1 10.9.18.229:4000 check inter 2000 rise 2 fall 3 # 检测 4000 端口,检测频率为每 2000 毫秒一次。如果 2 次检测为成功,则认为服务器可用;如果 3 次检测为失败,则认为服务器不可用。
- server tidb-2 10.9.39.208:4000 check inter 2000 rise 2 fall 3
- server tidb-3 10.9.64.166:4000 check inter 2000 rise 2 fall 3
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v6.0.0 和 v5.4.0。
-2. 通过 Sysbench 导入 16 张表,每张表有 1000 万行数据。
-3. 分别对每个表执行 `analyze table` 命令。
-4. 备份数据,用于不同并发测试前进行数据恢复,以保证每次数据一致。
-5. 启动 Sysbench 客户端,进行 `point_select`、`read_write`、`update_index` 和 `update_non_index` 测试。通过 HAProxy 向 TiDB 加压,每种负载每个并发数各测试 20 分钟。
-6. 每轮完成后停止集群,使用之前的备份的数据覆盖,再启动集群。
-
-### 准备测试数据
-
-执行以下命令来准备测试数据:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench oltp_common \
- --threads=16 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- --mysql-user=root \
- --mysql-password=password \
- prepare --tables=16 --table-size=10000000
-```
-
-### 执行测试命令
-
-执行以下命令来执行测试:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench $testname \
- --threads=$threads \
- --time=1200 \
- --report-interval=1 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- run --tables=16 --table-size=10000000
-```
-
-## 测试结果
-
-### Point Select 性能
-
-| Threads | v5.4.0 TPS | v6.0.0 TPS | v5.4.0 95% latency (ms) | v6.0.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|260085.19|265207.73|1.82|1.93|1.97|
-|600|378098.48|365173.66|2.48|2.61|-3.42|
-|900|441294.61|424031.23|3.75|3.49|-3.91|
-
-v6.0.0 对比 v5.4.0,Point Select 性能基本持平,略下降了 1.79%。
-
-
-
-### Update Non-index 性能
-
-| Threads | v5.4.0 TPS | v6.0.0 TPS | v5.4.0 95% latency (ms) | v6.0.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|41528.7|40814.23|11.65|11.45|-1.72|
-|600|53220.96|51746.21|19.29|20.74|-2.77|
-|900|59977.58|59095.34|26.68|28.16|-1.47|
-
-v6.0.0 对比 v5.4.0,Update Non-index 性能基本持平,略下降了 1.98%。
-
-
-
-### Update Index 性能
-
-| Threads | v5.4.0 TPS | v6.0.0 TPS | v5.4.0 95% latency (ms) | v6.0.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|18659.11|18187.54|23.95|25.74|-2.53|
-|600|23195.83|22270.81|40.37|44.17|-3.99|
-|900|25798.31|25118.78|56.84|57.87|-2.63|
-
-v6.0.0 对比 v5.4.0,Update Index 性能下降了 3.05%。
-
-
-
-### Read Write 性能
-
-| Threads | v5.4.0 TPS | v6.0.0 TPS | v5.4.0 95% latency (ms) | v6.0.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|4141.72|4829.01|97.55|82.96|16.59|
-|600|4892.76|5693.12|173.58|153.02|16.36|
-|900|5217.94|6029.95|257.95|235.74|15.56|
-
-v6.0.0 对比 v5.4.0,Read Write 性能有大幅提升,提升了 16.17%。
-
-
diff --git a/benchmark/benchmark-sysbench-v6.1.0-vs-v6.0.0.md b/benchmark/benchmark-sysbench-v6.1.0-vs-v6.0.0.md
deleted file mode 100644
index 3b8953af1e02..000000000000
--- a/benchmark/benchmark-sysbench-v6.1.0-vs-v6.0.0.md
+++ /dev/null
@@ -1,199 +0,0 @@
----
-title: TiDB Sysbench 性能对比测试报告 - v6.1.0 对比 v6.0.0
-summary: TiDB v6.1.0 在 OLTP 场景下的 Sysbench 性能表现优于 v6.0.0。写性能有提升,Write-heavy 负载性能提升了 2.33% 到 4.61%。Point Select 性能基本持平,略下降了 2.1%。Update Non-index 性能提升了 3.88%。Update Index 性能提升了 4.61%。Read Write 性能提升了 2.23%。
----
-
-# TiDB Sysbench 性能对比测试报告 - v6.1.0 对比 v6.0.0
-
-## 测试概况
-
-本次测试对比了 TiDB v6.1.0 和 v6.0.0 在 OLTP 场景下的 Sysbench 性能表现。结果显示,相比于 v6.0.0,v6.1.0 的写性能有提升,Write-heavy 负载性能有 2.33% 到 4.61% 的提升。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| Sysbench | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | v6.0.0、v6.1.0 |
-| TiDB | v6.0.0、v6.1.0 |
-| TiKV | v6.0.0、v6.1.0 |
-| Sysbench | 1.1.0-df89d34 |
-
-### 参数配置
-
-两个版本使用相同的配置。
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-storage.scheduler-worker-pool-size: 5
-raftstore.store-pool-size: 3
-raftstore.apply-pool-size: 3
-rocksdb.max-background-jobs: 8
-server.grpc-concurrency: 6
-readpool.storage.normal-concurrency: 10
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-set global tidb_prepared_plan_cache_size=1000;
-```
-
-#### HAProxy 配置 - haproxy.cfg 文件
-
-更多有关 HAProxy 在 TiDB 上的使用,可参阅 [HAProxy 在 TiDB 中的最佳实践](/best-practices/haproxy-best-practices.md)。
-
-{{< copyable "" >}}
-
-```yaml
-global # 全局配置。
- pidfile /var/run/haproxy.pid # 将 HAProxy 进程的 PID 写入 pidfile。
- maxconn 4000 # 每个 HAProxy 进程所接受的最大并发连接数。
- user haproxy # 同 UID 参数。
- group haproxy # 同 GID 参数,建议使用专用用户组。
- nbproc 64 # 在后台运行时创建的进程数。在启动多个进程转发请求时,确保该值足够大,保证 HAProxy 不会成为瓶颈。
- daemon # 让 HAProxy 以守护进程的方式工作于后台,等同于命令行参数“-D”的功能。当然,也可以在命令行中用“-db”参数将其禁用。
-
-defaults # 默认配置。
- log global # 日志继承全局配置段的设置。
- retries 2 # 向上游服务器尝试连接的最大次数,超过此值便认为后端服务器不可用。
- timeout connect 2s # HAProxy 与后端服务器连接超时时间。如果在同一个局域网内,可设置成较短的时间。
- timeout client 30000s # 客户端与 HAProxy 连接后,数据传输完毕,即非活动连接的超时时间。
- timeout server 30000s # 服务器端非活动连接的超时时间。
-
-listen tidb-cluster # 配置 database 负载均衡。
- bind 0.0.0.0:3390 # 浮动 IP 和 监听端口。
- mode tcp # HAProxy 要使用第 4 层的传输层。
- balance leastconn # 连接数最少的服务器优先接收连接。`leastconn` 建议用于长会话服务,例如 LDAP、SQL、TSE 等,而不是短会话协议,如 HTTP。该算法是动态的,对于启动慢的服务器,服务器权重会在运行中作调整。
- server tidb-1 10.9.18.229:4000 check inter 2000 rise 2 fall 3 # 检测 4000 端口,检测频率为每 2000 毫秒一次。如果 2 次检测为成功,则认为服务器可用;如果 3 次检测为失败,则认为服务器不可用。
- server tidb-2 10.9.39.208:4000 check inter 2000 rise 2 fall 3
- server tidb-3 10.9.64.166:4000 check inter 2000 rise 2 fall 3
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v6.1.0 和 v6.0.0。
-2. 通过 Sysbench 导入 16 张表,每张表有 1000 万行数据。
-3. 分别对每个表执行 `analyze table` 命令。
-4. 备份数据,用于不同并发测试前进行数据恢复,以保证每次数据一致。
-5. 启动 Sysbench 客户端,进行 `point_select`、`read_write`、`update_index` 和 `update_non_index` 测试。通过 HAProxy 向 TiDB 加压,每种负载每个并发数各测试 20 分钟。
-6. 每轮完成后停止集群,使用之前的备份的数据覆盖,再启动集群。
-
-### 准备测试数据
-
-执行以下命令来准备测试数据:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench oltp_common \
- --threads=16 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- --mysql-user=root \
- --mysql-password=password \
- prepare --tables=16 --table-size=10000000
-```
-
-### 执行测试命令
-
-执行以下命令来执行测试:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench $testname \
- --threads=$threads \
- --time=1200 \
- --report-interval=1 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- run --tables=16 --table-size=10000000
-```
-
-## 测试结果
-
-### Point Select 性能
-
-| Threads | v6.0.0 TPS | v6.1.0 TPS | v6.0.0 95% latency (ms) | v6.1.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|268934.84|265353.15|1.89|1.96|-1.33|
-|600|365217.96|358976.94|2.57|2.66|-1.71|
-|900|420799.64|407625.11|3.68|3.82|-3.13|
-
-v6.1.0 对比 v6.0.0,Point Select 性能基本持平,略下降了 2.1%。
-
-
-
-### Update Non-index 性能
-
-| Threads | v6.0.0 TPS | v6.1.0 TPS | v6.0.0 95% latency (ms) | v6.1.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|41778.95|42991.9|11.24|11.45|2.90 |
-|600|52045.39|54099.58|20.74|20.37|3.95|
-|900|59243.35|62084.65|27.66|26.68|4.80|
-
-v6.1.0 对比 v6.0.0,Update Non-index 性能提升了 3.88%。
-
-
-
-### Update Index 性能
-
-| Threads | v6.0.0 TPS | v6.1.0 TPS | v6.0.0 95% latency (ms) | v6.1.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|18085.79|19198.89|25.28|23.95|6.15|
-|600|22210.8|22877.58|42.61|41.85|3.00|
-|900|25249.81|26431.12|55.82|53.85|4.68|
-
-v6.1.0 对比 v6.0.0,Update Index 性能提升 4.61%。
-
-
-
-### Read Write 性能
-
-| Threads | v6.0.0 TPS | v6.1.0 TPS | v6.0.0 95% latency (ms) | v6.1.0 95% latency (ms) | TPS 提升 (%) |
-|:----------|:----------|:----------|:----------|:----------|:----------|
-|300|4856.23|4914.11|84.47|82.96|1.19|
-|600|5676.46|5848.09|161.51|150.29|3.02|
-|900|6072.97|6223.95|240.02|223.34|2.49|
-
-v6.1.0 对比 v6.0.0,Read Write 性能提升了 2.23%。
-
-
diff --git a/benchmark/benchmark-sysbench-v6.2.0-vs-v6.1.0.md b/benchmark/benchmark-sysbench-v6.2.0-vs-v6.1.0.md
deleted file mode 100644
index 37c4b5ae941f..000000000000
--- a/benchmark/benchmark-sysbench-v6.2.0-vs-v6.1.0.md
+++ /dev/null
@@ -1,199 +0,0 @@
----
-title: TiDB Sysbench 性能对比测试报告 - v6.2.0 对比 v6.1.0
-summary: TiDB v6.2.0 和 v6.1.0 在 OLTP 场景下的 Sysbench 性能对比测试结果显示,两个版本性能基本持平。然而,v6.2.0 的 Point Select 性能下降了 3.58%,而 Update Non-index、Update Index 和 Read Write 性能基本持平或下降了不到 1.5%。
----
-
-# TiDB Sysbench 性能对比测试报告 - v6.2.0 对比 v6.1.0
-
-## 测试概况
-
-本次测试对比了 TiDB v6.2.0 和 v6.1.0 在 OLTP 场景下的 Sysbench 性能表现。结果显示,两个版本性能基本持平,相比于 v6.1.0,v6.2.0 的 Point Select 性能下降了 3.58%。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-| :------- | :--------- | :----- |
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge | 3 |
-| TiDB | c5.4xlarge | 3 |
-| Sysbench | c5.9xlarge | 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-| :------- | :------------- |
-| PD | v6.1.0、v6.2.0 |
-| TiDB | v6.1.0、v6.2.0 |
-| TiKV | v6.1.0、v6.2.0 |
-| Sysbench | 1.1.0-df89d34 |
-
-### 参数配置
-
-两个版本使用相同的配置。
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-storage.scheduler-worker-pool-size: 5
-raftstore.store-pool-size: 3
-raftstore.apply-pool-size: 3
-rocksdb.max-background-jobs: 8
-server.grpc-concurrency: 6
-readpool.unified.max-thread-count: 10
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-set global tidb_prepared_plan_cache_size=1000;
-```
-
-#### HAProxy 配置 - haproxy.cfg 文件
-
-更多有关 HAProxy 在 TiDB 上的使用,可参阅 [HAProxy 在 TiDB 中的最佳实践](/best-practices/haproxy-best-practices.md)。
-
-{{< copyable "" >}}
-
-```yaml
-global # 全局配置。
- pidfile /var/run/haproxy.pid # 将 HAProxy 进程的 PID 写入 pidfile。
- maxconn 4000 # 每个 HAProxy 进程所接受的最大并发连接数。
- user haproxy # 同 UID 参数。
- group haproxy # 同 GID 参数,建议使用专用用户组。
- nbproc 64 # 在后台运行时创建的进程数。在启动多个进程转发请求时,确保该值足够大,保证 HAProxy 不会成为瓶颈。
- daemon # 让 HAProxy 以守护进程的方式工作于后台,等同于命令行参数“-D”的功能。当然,也可以在命令行中用“-db”参数将其禁用。
-
-defaults # 默认配置。
- log global # 日志继承全局配置段的设置。
- retries 2 # 向上游服务器尝试连接的最大次数,超过此值便认为后端服务器不可用。
- timeout connect 2s # HAProxy 与后端服务器连接超时时间。如果在同一个局域网内,可设置成较短的时间。
- timeout client 30000s # 客户端与 HAProxy 连接后,数据传输完毕,即非活动连接的超时时间。
- timeout server 30000s # 服务器端非活动连接的超时时间。
-
-listen tidb-cluster # 配置 database 负载均衡。
- bind 0.0.0.0:3390 # 浮动 IP 和 监听端口。
- mode tcp # HAProxy 要使用第 4 层的传输层。
- balance leastconn # 连接数最少的服务器优先接收连接。`leastconn` 建议用于长会话服务,例如 LDAP、SQL、TSE 等,而不是短会话协议,如 HTTP。该算法是动态的,对于启动慢的服务器,服务器权重会在运行中作调整。
- server tidb-1 10.9.18.229:4000 check inter 2000 rise 2 fall 3 # 检测 4000 端口,检测频率为每 2000 毫秒一次。如果 2 次检测为成功,则认为服务器可用;如果 3 次检测为失败,则认为服务器不可用。
- server tidb-2 10.9.39.208:4000 check inter 2000 rise 2 fall 3
- server tidb-3 10.9.64.166:4000 check inter 2000 rise 2 fall 3
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v6.2.0 和 v6.1.0。
-2. 通过 Sysbench 导入 16 张表,每张表有 1000 万行数据。
-3. 分别对每个表执行 `analyze table` 命令。
-4. 备份数据,用于不同并发测试前进行数据恢复,以保证每次数据一致。
-5. 启动 Sysbench 客户端,进行 `point_select`、`read_write`、`update_index` 和 `update_non_index` 测试。通过 HAProxy 向 TiDB 加压,每种负载每个并发数各测试 20 分钟。
-6. 每轮完成后停止集群,使用之前的备份的数据覆盖,再启动集群。
-
-### 准备测试数据
-
-执行以下命令来准备测试数据:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench oltp_common \
- --threads=16 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- --mysql-user=root \
- --mysql-password=password \
- prepare --tables=16 --table-size=10000000
-```
-
-### 执行测试命令
-
-执行以下命令来执行测试:
-
-{{< copyable "shell-regular" >}}
-
-```bash
-sysbench $testname \
- --threads=$threads \
- --time=1200 \
- --report-interval=1 \
- --rand-type=uniform \
- --db-driver=mysql \
- --mysql-db=sbtest \
- --mysql-host=$aws_nlb_host \
- --mysql-port=$aws_nlb_port \
- run --tables=16 --table-size=10000000
-```
-
-## 测试结果
-
-### Point Select 性能
-
-| Threads | v6.1.0 TPS | v6.2.0 TPS | v6.1.0 95% latency (ms) | v6.2.0 95% latency (ms) | TPS 提升 (%) |
-| :------ | :--------- | :--------- | :---------------------- | :---------------------- | :----------- |
-| 300 | 243530.01 | 236885.24 | 1.93 | 2.07 | -2.73 |
-| 600 | 304121.47 | 291395.84 | 3.68 | 4.03 | -4.18 |
-| 900 | 327301.23 | 314720.02 | 5 | 5.47 | -3.84 |
-
-v6.2.0 对比 v6.1.0,Point Select 性能下降了 3.58%。
-
-
-
-### Update Non-index 性能
-
-| Threads | v6.1.0 TPS | v6.2.0 TPS | v6.1.0 95% latency (ms) | v6.2.0 95% latency (ms) | TPS 提升 (%) |
-| :------ | :--------- | :--------- | :---------------------- | :---------------------- | :----------- |
-| 300 | 42608.8 | 42372.82 | 11.45 | 11.24 | -0.55 |
-| 600 | 54264.47 | 53672.69 | 18.95 | 18.95 | -1.09 |
-| 900 | 60667.47 | 60116.14 | 26.2 | 26.68 | -0.91 |
-
-v6.2.0 对比 v6.1.0,Update Non-index 性能基本持平,下降了 0.85%。
-
-
-
-### Update Index 性能
-
-| Threads | v6.1.0 TPS | v6.2.0 TPS | v6.1.0 95% latency (ms) | v6.2.0 95% latency (ms) | TPS 提升 (%) |
-| :------ | :--------- | :--------- | :---------------------- | :---------------------- | :----------- |
-| 300 | 19384.75 | 19353.58 | 23.52 | 23.52 | -0.16 |
-| 600 | 24144.78 | 24007.57 | 38.25 | 37.56 | -0.57 |
-| 900 | 26770.9 | 26589.84 | 51.94 | 52.89 | -0.68 |
-
-v6.2.0 对比 v6.1.0,Update Index 性能基本持平,下降了 0.47%。
-
-
-
-### Read Write 性能
-
-| Threads | v6.1.0 TPS | v6.2.0 TPS | v6.1.0 95% latency (ms) | v6.2.0 95% latency (ms) | TPS 提升 (%) |
-| :------ | :--------- | :--------- | :---------------------- | :---------------------- | :----------- |
-| 300 | 4849.67 | 4797.59 | 86 | 84.47 | -1.07 |
-| 600 | 5643.89 | 5565.17 | 161.51 | 161.51 | -1.39 |
-| 900 | 5954.91 | 5885.22 | 235.74 | 235.74 | -1.17 |
-
-v6.2.0 对比 v6.1.0,Read Write 性能下降了 1.21%。
-
-
diff --git a/benchmark/benchmark-tidb-using-sysbench.md b/benchmark/benchmark-tidb-using-sysbench.md
index 420e347d402c..a12be2bcf992 100644
--- a/benchmark/benchmark-tidb-using-sysbench.md
+++ b/benchmark/benchmark-tidb-using-sysbench.md
@@ -1,6 +1,5 @@
---
title: 如何用 Sysbench 测试 TiDB
-aliases: ['/docs-cn/dev/benchmark/benchmark-tidb-using-sysbench/','/docs-cn/dev/benchmark/how-to-run-sysbench/']
summary: 使用 Sysbench 1.0 或更新版本测试 TiDB 性能。调整 TiDB 和 TiKV 的日志级别以提高性能。配置 RocksDB 的 block cache 以充分利用内存。调整 Sysbench 配置文件并导入数据。进行数据预热和统计信息收集。执行 Point select、Update index 和 Read-only 测试命令。解决可能出现的性能问题。
---
diff --git a/benchmark/benchmark-tidb-using-tpcc.md b/benchmark/benchmark-tidb-using-tpcc.md
index 7e923e4331fe..b53217be3696 100644
--- a/benchmark/benchmark-tidb-using-tpcc.md
+++ b/benchmark/benchmark-tidb-using-tpcc.md
@@ -1,6 +1,5 @@
---
title: 如何对 TiDB 进行 TPC-C 测试
-aliases: ['/docs-cn/dev/benchmark/benchmark-tidb-using-tpcc/','/docs-cn/dev/benchmark/how-to-run-tpcc/']
summary: 本文介绍了如何对 TiDB 进行 TPC-C 测试。TPC-C 是一个对 OLTP 系统进行测试的规范,使用商品销售模型对系统进行测试,包含五类事务:NewOrder、Payment、OrderStatus、Delivery、StockLevel。测试使用 tpmC 值衡量系统最大有效吞吐量,以 NewOrder Transaction 为准。使用 go-tpc 进行测试实现,通过 TiUP 命令下载测试程序。测试包括数据导入、运行测试和清理测试数据。
---
diff --git a/benchmark/benchmark-tpch.md b/benchmark/benchmark-tpch.md
index 14720a389b69..d9bd01120f39 100644
--- a/benchmark/benchmark-tpch.md
+++ b/benchmark/benchmark-tpch.md
@@ -1,6 +1,5 @@
---
title: TiDB TPC-H 50G 性能测试报告
-aliases: ['/docs-cn/dev/benchmark/benchmark-tpch/','/docs-cn/dev/benchmark/tpch/']
summary: TiDB TPC-H 50G 性能测试报告显示,TiDB 2.0 在大部分查询中表现优于 TiDB 1.0。然而,部分查询在 TiDB 1.0 中未能完成或因内存占用过多而被终止。测试环境包括不同操作系统和硬件信息,测试结果以图表形式展示。
---
diff --git a/benchmark/online-workloads-and-add-index-operations.md b/benchmark/online-workloads-and-add-index-operations.md
index 15379f39366a..1a894ee40b48 100644
--- a/benchmark/online-workloads-and-add-index-operations.md
+++ b/benchmark/online-workloads-and-add-index-operations.md
@@ -1,6 +1,5 @@
---
title: 线上负载与 `ADD INDEX` 相互影响测试
-aliases: ['/docs-cn/dev/benchmark/online-workloads-and-add-index-operations/','/docs-cn/dev/benchmark/add-index-with-load/']
summary: 线上负载与 ADD INDEX 相互影响测试结果显示,当目标列频繁更新时,会造成写冲突和长时间完成。目标列仅涉及查询负载或与线上负载不相关时,可以直接使用默认配置。
---
diff --git a/benchmark/v3.0-performance-benchmarking-with-sysbench.md b/benchmark/v3.0-performance-benchmarking-with-sysbench.md
index 048fc8bf9add..de7ed220039f 100644
--- a/benchmark/v3.0-performance-benchmarking-with-sysbench.md
+++ b/benchmark/v3.0-performance-benchmarking-with-sysbench.md
@@ -1,6 +1,5 @@
---
title: TiDB Sysbench 性能对比测试报告 - v3.0 对比 v2.1
-aliases: ['/docs-cn/dev/benchmark/v3.0-performance-benchmarking-with-sysbench/','/docs-cn/dev/benchmark/sysbench-v4/']
summary: TiDB 3.0 版本和 2.1 版本在 OLTP 场景下进行了性能对比测试。测试环境为 AWS EC2,使用 Sysbench 向集群导入 16 张表,每张数据 1000 万。测试结果显示,v3.0 在 Point Select、Update Non-Index、Update Index 和 Read Write 测试中的性能均优于 v2.1。
---
diff --git a/benchmark/v3.0-performance-benchmarking-with-tpcc.md b/benchmark/v3.0-performance-benchmarking-with-tpcc.md
index 63b3ac78c966..b01fa9692b8a 100644
--- a/benchmark/v3.0-performance-benchmarking-with-tpcc.md
+++ b/benchmark/v3.0-performance-benchmarking-with-tpcc.md
@@ -1,6 +1,5 @@
---
title: TiDB TPC-C 性能对比测试报告 - v3.0 对比 v2.1
-aliases: ['/docs-cn/dev/benchmark/v3.0-performance-benchmarking-with-tpcc/','/docs-cn/dev/benchmark/tpcc/']
summary: TiDB 3.0 版本在 TPC-C 性能上提升了 450%,性能表现明显优于 2.1 版本。
---
diff --git a/benchmark/v4.0-performance-benchmarking-with-tpcc.md b/benchmark/v4.0-performance-benchmarking-with-tpcc.md
index 0ccfef075ec1..976d8328f5a4 100644
--- a/benchmark/v4.0-performance-benchmarking-with-tpcc.md
+++ b/benchmark/v4.0-performance-benchmarking-with-tpcc.md
@@ -1,6 +1,5 @@
---
title: TiDB TPC-C 性能对比测试报告 - v4.0 对比 v3.0
-aliases: ['/docs-cn/dev/benchmark/v4.0-performance-benchmarking-with-tpcc/']
summary: TiDB v4.0 在 TPC-C 性能上提升了 50%,比 v3.0 高出一半。
---
diff --git a/benchmark/v4.0-performance-benchmarking-with-tpch.md b/benchmark/v4.0-performance-benchmarking-with-tpch.md
index c4f46626e29e..a2fe3fdc0680 100644
--- a/benchmark/v4.0-performance-benchmarking-with-tpch.md
+++ b/benchmark/v4.0-performance-benchmarking-with-tpch.md
@@ -1,6 +1,5 @@
---
title: TiDB TPC-H 性能对比测试报告 - v4.0 对比 v3.0
-aliases: ['/docs-cn/dev/benchmark/v4.0-performance-benchmarking-with-tpch/']
summary: TiDB v4.0 和 v3.0 在 OLAP 场景下的性能对比测试报告显示,v4.0 通过智能选择混合读取 TiKV、TiFlash 的数据,性能明显优于 v3.0 仅从 TiKV 读取数据。在完整的 HTAP 形态下,v4.0 的性能得到了显著提升。
---
diff --git a/benchmark/v5.0-performance-benchmarking-with-tpcc.md b/benchmark/v5.0-performance-benchmarking-with-tpcc.md
deleted file mode 100644
index aef70a124bd0..000000000000
--- a/benchmark/v5.0-performance-benchmarking-with-tpcc.md
+++ /dev/null
@@ -1,149 +0,0 @@
----
-title: TiDB TPC-C 性能对比测试报告 - v5.0 对比 v4.0
-summary: TiDB v5.0 在 TPC-C 性能上提升了 36%,比 v4.0 更优。
----
-
-# TiDB TPC-C 性能对比测试报告 - v5.0 对比 v4.0
-
-## 测试目的
-
-测试对比 TiDB v5.0 和 v4.0 OLTP 场景下的性能。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| TPC-C | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | 4.0、5.0 |
-| TiDB | 4.0、5.0 |
-| TiKV | 4.0、5.0 |
-| BenchmarkSQL | 无 |
-
-### 配置参数
-
-#### TiDB v4.0 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-performance.max-procs: 20
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV v4.0 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-pessimistic-txn.pipelined: true
-raftdb.allow-concurrent-memtable-write: true
-raftdb.max-background-jobs: 4
-raftstore.apply-max-batch-size: 2048
-raftstore.apply-pool-size: 3
-raftstore.store-max-batch-size: 2048
-raftstore.store-pool-size: 3
-readpool.storage.normal-concurrency: 10
-readpool.unified.max-thread-count: 20
-readpool.unified.min-thread-count: 5
-rocksdb.max-background-jobs: 8
-server.grpc-concurrency: 6
-storage.scheduler-worker-pool-size: 20
-```
-
-#### TiDB v5.0 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-performance.max-procs: 20
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV v5.0 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-pessimistic-txn.pipelined: true
-raftdb.allow-concurrent-memtable-write: true
-raftdb.max-background-jobs: 4
-raftstore.apply-max-batch-size: 2048
-raftstore.apply-pool-size: 3
-raftstore.store-max-batch-size: 2048
-raftstore.store-pool-size: 3
-readpool.storage.normal-concurrency: 10
-readpool.unified.max-thread-count: 20
-readpool.unified.min-thread-count: 5
-rocksdb.max-background-jobs: 8
-server.grpc-concurrency: 6
-storage.scheduler-worker-pool-size: 20
-server.enable-request-batch: false
-```
-
-#### TiDB v4.0 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-```
-
-#### TiDB v5.0 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v5.0 和 v4.0。
-
-2. 通过 BenchmarkSQL 导入 TPC-C 5000 Warehouse 数据。
-
- 1. 编译 BenchmarkSQL:
-
- {{< copyable "bash" >}}
-
- ```bash
- git clone https://github.com/pingcap/benchmarksql && cd benchmarksql && ant
- ```
-
- 2. 进入 `run` 目录,根据实际情况编辑 `props.mysql` 文件,调整 `conn`、`warehouses`、`loadWorkers`、`terminals`、`runMins` 配置项。
-
- 3. 运行 `runSQL.sh ./props.mysql sql.mysql/tableCreates.sql` 命令。
-
- 4. 运行 `runSQL.sh ./props.mysql sql.mysql/indexCreates.sql` 命令。
-
- 5. 运行 MySQL client 并对每个表执行 `analyze table` 语句。
-
-3. 运行 `runBenchmark.sh ./props.mysql` 命令。
-
-4. 从结果中提取 New Order 的 tpmC 的数据。
-
-## 测试结果
-
-v5.0 比 v4.0 在 TPC-C 性能上**提升了 36%**。
-
-
diff --git a/benchmark/v5.1-performance-benchmarking-with-tpcc.md b/benchmark/v5.1-performance-benchmarking-with-tpcc.md
deleted file mode 100644
index 8a523f3cf0a3..000000000000
--- a/benchmark/v5.1-performance-benchmarking-with-tpcc.md
+++ /dev/null
@@ -1,93 +0,0 @@
----
-title: TiDB TPC-C 性能对比测试报告 - v5.1.0 对比 v5.0.2
-summary: TiDB v5.1.0 在 TPC-C 性能上提升了 2.8%,测试环境为 AWS EC2,硬件配置包括 PD、TiKV、TiDB 和 TPC-C 实例,软件版本为 v5.0.2 和 v5.1.0,配置参数相同。测试方案包括部署、创建数据库、导入数据和运行压力测试,结果显示性能提升。
----
-
-# TiDB TPC-C 性能对比测试报告 - v5.1.0 对比 v5.0.2
-
-## 测试概况
-
-本次测试对比了 TiDB v5.1.0 和 v5.0.2 在 OLTP 场景下的 TPC-C 性能表现。结果显示,v5.1.0 相比于 v5.0.2 在 TPC-C 性能上提升了 2.8%。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| TPC-C | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | v5.0.2、v5.1.0 |
-| TiDB | v5.0.2、v5.1.0 |
-| TiKV | v5.0.2、v5.1.0 |
-| TiUP | 1.5.1 |
-
-### 配置参数
-
-两个版本使用同样的配置
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-performance.max-procs: 20
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-pessimistic-txn.pipelined: true
-raftdb.allow-concurrent-memtable-write: true
-raftdb.max-background-jobs: 4
-raftstore.apply-max-batch-size: 2048
-raftstore.apply-pool-size: 3
-raftstore.store-max-batch-size: 2048
-raftstore.store-pool-size: 3
-readpool.storage.normal-concurrency: 10
-readpool.unified.max-thread-count: 20
-readpool.unified.min-thread-count: 5
-rocksdb.max-background-jobs: 8
-server.grpc-concurrency: 6
-storage.scheduler-worker-pool-size: 20
-server.enable-request-batch: false
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v5.1.0 和 v5.0.2。
-2. 创建数据库 tpcc:`create database tpcc;`
-3. 通过 tiup bench 导入 TPC-C 5000 Warehouse 数据:`tiup bench tpcc prepare --warehouses 5000 --db tpcc -H 127.0.0.1 -p 4000`。
-4. 运行 `tiup bench tpcc run -U root --db tpcc --host 127.0.0.1 --port 4000 --time 300s --warehouses 5000 --threads {{thread}}` 命令,通过 HAProxy 向 TiDB 加压。
-5. 从结果中提取 New Order 的 tpmC 的数据。
-
-## 测试结果
-
-v5.1.0 比 v5.0.2 在 TPC-C 性能上**提升了 2.8%**。
-
-
diff --git a/benchmark/v5.2-performance-benchmarking-with-tpcc.md b/benchmark/v5.2-performance-benchmarking-with-tpcc.md
deleted file mode 100644
index f82f66b87c69..000000000000
--- a/benchmark/v5.2-performance-benchmarking-with-tpcc.md
+++ /dev/null
@@ -1,93 +0,0 @@
----
-title: TiDB TPC-C 性能对比测试报告 - v5.2.0 对比 v5.1.1
-summary: TiDB v5.2.0 在 TPC-C 性能上下降了 4.22%,测试环境为 AWS EC2,硬件配置包括 PD、TiKV、TiDB 和 TPC-C 实例,软件版本为 v5.1.1 和 v5.2.0,配置参数相同。测试方案包括部署、创建数据库、导入数据和运行压力测试,结果显示性能下降。
----
-
-# TiDB TPC-C 性能对比测试报告 - v5.2.0 对比 v5.1.1
-
-## 测试概况
-
-本次测试对比了 TiDB v5.2.0 和 v5.1.1 在 OLTP 场景下的 TPC-C 性能表现。结果显示,v5.2.0 相比于 v5.1.1 在 TPC-C 性能上下降了 4.22%。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| TPC-C | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | v5.1.1、v5.2.0 |
-| TiDB | v5.1.1、v5.2.0 |
-| TiKV | v5.1.1、v5.2.0 |
-| TiUP | 1.5.1 |
-
-### 配置参数
-
-两个版本使用同样的配置
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-performance.max-procs: 20
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-pessimistic-txn.pipelined: true
-raftdb.allow-concurrent-memtable-write: true
-raftdb.max-background-jobs: 4
-raftstore.apply-max-batch-size: 2048
-raftstore.apply-pool-size: 3
-raftstore.store-max-batch-size: 2048
-raftstore.store-pool-size: 3
-readpool.storage.normal-concurrency: 10
-readpool.unified.max-thread-count: 20
-readpool.unified.min-thread-count: 5
-rocksdb.max-background-jobs: 8
-server.grpc-concurrency: 6
-storage.scheduler-worker-pool-size: 20
-server.enable-request-batch: false
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v5.2.0 和 v5.1.1。
-2. 创建数据库 tpcc:`create database tpcc;`
-3. 通过 tiup bench 导入 TPC-C 5000 Warehouse 数据:`tiup bench tpcc prepare --warehouses 5000 --db tpcc -H 127.0.0.1 -p 4000`。
-4. 运行 `tiup bench tpcc run -U root --db tpcc --host 127.0.0.1 --port 4000 --time 300s --warehouses 5000 --threads {{thread}}` 命令,通过 HAProxy 向 TiDB 加压。
-5. 从结果中提取 New Order 的 tpmC 的数据。
-
-## 测试结果
-
-v5.2.0 相比 v5.1.1 在 TPC-C 性能上**下降了 4.22%**。
-
-
diff --git a/benchmark/v5.3-performance-benchmarking-with-tpcc.md b/benchmark/v5.3-performance-benchmarking-with-tpcc.md
deleted file mode 100644
index 2130833a9c44..000000000000
--- a/benchmark/v5.3-performance-benchmarking-with-tpcc.md
+++ /dev/null
@@ -1,131 +0,0 @@
----
-title: TiDB TPC-C 性能对比测试报告 - v5.3.0 对比 v5.2.2
-summary: TiDB v5.3.0 在 TPC-C 性能上略下降了 2.99%,与 v5.2.2 相比。测试结果显示,不同线程下,v5.3.0 的 tpmC 提升率分别为 -1.54%,-2.33%,-2.99%,-5.10%。
----
-
-# TiDB TPC-C 性能对比测试报告 - v5.3.0 对比 v5.2.2
-
-## 测试概况
-
-本次测试对比了 TiDB v5.3.0 和 v5.2.2 在 OLTP 场景下的 TPC-C 性能表现。结果显示,v5.3.0 相比于 v5.2.2 在 TPC-C 性能上略下降了 2.99%。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| TPC-C | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | v5.2.2、v5.3.0 |
-| TiDB | v5.2.2、v5.3.0 |
-| TiKV | v5.2.2、v5.3.0 |
-| TiUP | 1.5.1 |
-
-### 配置参数
-
-两个版本使用同样的配置
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-performance.max-procs: 20
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-pessimistic-txn.pipelined: true
-raftdb.allow-concurrent-memtable-write: true
-raftdb.max-background-jobs: 4
-raftstore.apply-max-batch-size: 2048
-raftstore.apply-pool-size: 3
-raftstore.store-max-batch-size: 2048
-raftstore.store-pool-size: 3
-readpool.storage.normal-concurrency: 10
-readpool.unified.max-thread-count: 20
-readpool.unified.min-thread-count: 5
-rocksdb.max-background-jobs: 8
-server.grpc-concurrency: 6
-storage.scheduler-worker-pool-size: 20
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-```
-
-#### HAProxy 配置 - haproxy.cfg 文件
-
-更多有关 HAProxy 在 TiDB 上的使用,可参阅 [HAProxy 在 TiDB 中的最佳实践](/best-practices/haproxy-best-practices.md)。
-
-{{< copyable "" >}}
-
-```yaml
-global # 全局配置。
- chroot /var/lib/haproxy # 更改当前目录并为启动进程设置超级用户权限,从而提高安全性。
- pidfile /var/run/haproxy.pid # 将 HAProxy 进程的 PID 写入 pidfile。
- maxconn 4000 # 每个 HAProxy 进程所接受的最大并发连接数。
- user haproxy # 同 UID 参数。
- group haproxy # 同 GID 参数,建议使用专用用户组。
- nbproc 64 # 在后台运行时创建的进程数。在启动多个进程转发请求时,确保该值足够大,保证 HAProxy 不会成为瓶颈。
- daemon # 让 HAProxy 以守护进程的方式工作于后台,等同于命令行参数“-D”的功能。当然,也可以在命令行中用“-db”参数将其禁用。
-
-defaults # 默认配置。
- log global # 日志继承全局配置段的设置。
- retries 2 # 向上游服务器尝试连接的最大次数,超过此值便认为后端服务器不可用。
- timeout connect 2s # HAProxy 与后端服务器连接超时时间。如果在同一个局域网内,可设置成较短的时间。
- timeout client 30000s # 客户端与 HAProxy 连接后,数据传输完毕,即非活动连接的超时时间。
- timeout server 30000s # 服务器端非活动连接的超时时间。
-
-listen tidb-cluster # 配置 database 负载均衡。
- bind 0.0.0.0:3390 # 浮动 IP 和 监听端口。
- mode tcp # HAProxy 要使用第 4 层的传输层。
- balance roundrobin # 连接数最少的服务器优先接收连接。`leastconn` 建议用于长会话服务,例如 LDAP、SQL、TSE 等,而不是短会话协议,如 HTTP。该算法是动态的,对于启动慢的服务器,服务器权重会在运行中作调整。
- server tidb-1 10.9.18.229:4000 check inter 2000 rise 2 fall 3 # 检测 4000 端口,检测频率为每 2000 毫秒一次。如果 2 次检测为成功,则认为服务器可用;如果 3 次检测为失败,则认为服务器不可用。
- server tidb-2 10.9.39.208:4000 check inter 2000 rise 2 fall 3
- server tidb-3 10.9.64.166:4000 check inter 2000 rise 2 fall 3
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v5.3.0 和 v5.2.2。
-2. 创建数据库 tpcc:`create database tpcc;`
-3. 通过 tiup bench 导入 TPC-C 5000 Warehouse 数据:`tiup bench tpcc prepare --warehouses 5000 --db tpcc -H 127.0.0.1 -p 4000`。
-4. 运行 `tiup bench tpcc run -U root --db tpcc --host 127.0.0.1 --port 4000 --time 1800s --warehouses 5000 --threads {{thread}}` 命令,通过 HAProxy 向 TiDB 加压,每个并发数各测试 30 分钟。
-5. 从结果中提取 New Order 的 tpmC 的数据。
-
-## 测试结果
-
-v5.3.0 相比 v5.2.2 在 TPC-C 性能上**略下降了 2.99%**。
-
-| Threads | v5.2.2 tpmC | v5.3.0 tpmC | tpmC 提升 (%) |
-|:----------|:----------|:----------|:----------|
-|50|42228.8|41580|-1.54|
-|100|49400|48248.2|-2.33|
-|200|54436.6|52809.4|-2.99|
-|400|57026.7|54117.1|-5.10|
-
-
diff --git a/benchmark/v5.4-performance-benchmarking-with-tpcc.md b/benchmark/v5.4-performance-benchmarking-with-tpcc.md
deleted file mode 100644
index 3831300d64f6..000000000000
--- a/benchmark/v5.4-performance-benchmarking-with-tpcc.md
+++ /dev/null
@@ -1,131 +0,0 @@
----
-title: TiDB TPC-C 性能对比测试报告 - v5.4.0 对比 v5.3.0
-summary: TiDB v5.4.0 在 TPC-C 性能上提升了 3.16%,测试结果显示不同并发下,性能均有提升。
----
-
-# TiDB TPC-C 性能对比测试报告 - v5.4.0 对比 v5.3.0
-
-## 测试概况
-
-本次测试对比了 TiDB v5.4.0 和 v5.3.0 在 OLTP 场景下的 TPC-C 性能表现。结果显示,v5.4.0 相比于 v5.3.0 在 TPC-C 性能提升了 3.16%。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| TPC-C | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | v5.3.0、v5.4.0 |
-| TiDB | v5.3.0、v5.4.0 |
-| TiKV | v5.3.0、v5.4.0 |
-| TiUP | 1.5.1 |
-
-### 配置参数
-
-两个版本使用同样的配置
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-performance.max-procs: 20
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-pessimistic-txn.pipelined: true
-raftdb.allow-concurrent-memtable-write: true
-raftdb.max-background-jobs: 4
-raftstore.apply-max-batch-size: 2048
-raftstore.apply-pool-size: 3
-raftstore.store-max-batch-size: 2048
-raftstore.store-pool-size: 3
-readpool.storage.normal-concurrency: 10
-readpool.unified.max-thread-count: 20
-readpool.unified.min-thread-count: 5
-rocksdb.max-background-jobs: 8
-server.grpc-concurrency: 6
-storage.scheduler-worker-pool-size: 20
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-```
-
-#### HAProxy 配置 - haproxy.cfg 文件
-
-更多有关 HAProxy 在 TiDB 上的使用,可参阅 [HAProxy 在 TiDB 中的最佳实践](/best-practices/haproxy-best-practices.md)。
-
-{{< copyable "" >}}
-
-```yaml
-global # 全局配置。
- chroot /var/lib/haproxy # 更改当前目录并为启动进程设置超级用户权限,从而提高安全性。
- pidfile /var/run/haproxy.pid # 将 HAProxy 进程的 PID 写入 pidfile。
- maxconn 4000 # 每个 HAProxy 进程所接受的最大并发连接数。
- user haproxy # 同 UID 参数。
- group haproxy # 同 GID 参数,建议使用专用用户组。
- nbproc 64 # 在后台运行时创建的进程数。在启动多个进程转发请求时,确保该值足够大,保证 HAProxy 不会成为瓶颈。
- daemon # 让 HAProxy 以守护进程的方式工作于后台,等同于命令行参数“-D”的功能。当然,也可以在命令行中用“-db”参数将其禁用。
-
-defaults # 默认配置。
- log global # 日志继承全局配置段的设置。
- retries 2 # 向上游服务器尝试连接的最大次数,超过此值便认为后端服务器不可用。
- timeout connect 2s # HAProxy 与后端服务器连接超时时间。如果在同一个局域网内,可设置成较短的时间。
- timeout client 30000s # 客户端与 HAProxy 连接后,数据传输完毕,即非活动连接的超时时间。
- timeout server 30000s # 服务器端非活动连接的超时时间。
-
-listen tidb-cluster # 配置 database 负载均衡。
- bind 0.0.0.0:3390 # 浮动 IP 和 监听端口。
- mode tcp # HAProxy 要使用第 4 层的传输层。
- balance roundrobin # 连接数最少的服务器优先接收连接。`leastconn` 建议用于长会话服务,例如 LDAP、SQL、TSE 等,而不是短会话协议,如 HTTP。该算法是动态的,对于启动慢的服务器,服务器权重会在运行中作调整。
- server tidb-1 10.9.18.229:4000 check inter 2000 rise 2 fall 3 # 检测 4000 端口,检测频率为每 2000 毫秒一次。如果 2 次检测为成功,则认为服务器可用;如果 3 次检测为失败,则认为服务器不可用。
- server tidb-2 10.9.39.208:4000 check inter 2000 rise 2 fall 3
- server tidb-3 10.9.64.166:4000 check inter 2000 rise 2 fall 3
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v5.4.0 和 v5.3.0。
-2. 创建数据库 tpcc:`create database tpcc;`。
-3. 通过 tiup bench 导入 TPC-C 5000 Warehouse 数据:`tiup bench tpcc prepare --warehouses 5000 --db tpcc -H 127.0.0.1 -P 4000`。
-4. 运行 `tiup bench tpcc run -U root --db tpcc --host 127.0.0.1 --port 4000 --time 1800s --warehouses 5000 --threads {{thread}}` 命令,通过 HAProxy 向 TiDB 加压,每个并发数各测试 30 分钟。
-5. 从结果中提取 New Order 的 tpmC 的数据。
-
-## 测试结果
-
-v5.4.0 相比 v5.3.0 在 TPC-C 性能上**提升了 3.16%**。
-
-| Threads | v5.3.0 tpmC | v5.4.0 tpmC | tpmC 提升 (%) |
-|:----------|:----------|:----------|:----------|
-|50|43002.4|44204.4|2.80|
-|100|50162.7|52305|4.27|
-|200|55768.2|57690.7|3.45|
-|400|56836.8|58034.6|2.11|
-
-
diff --git a/benchmark/v5.4-performance-benchmarking-with-tpch.md b/benchmark/v5.4-performance-benchmarking-with-tpch.md
deleted file mode 100644
index f3fedd1e231c..000000000000
--- a/benchmark/v5.4-performance-benchmarking-with-tpch.md
+++ /dev/null
@@ -1,121 +0,0 @@
----
-title: TiDB TPC-H 性能对比测试报告 - v5.4 MPP 模式对比 Greenplum 6.15.0 以及 Apache Spark 3.1.1
-summary: TiDB v5.4 MPP 模式在 TPC-H 100 GB 数据下的性能测试结果显示,相对于 Greenplum 6.15.0 和 Apache Spark 3.1.1,有 2-3 倍的性能提升。测试环境包括 TiDB v5.4 MPP、Greenplum 6.15.0 和 Apache Spark 3.1.1 + Parquet。测试结果显示 TiDB v5.4 在各个查询中的处理时间明显低于其他两者,表现更优。
----
-
-# TiDB TPC-H 性能对比测试报告 - v5.4 MPP 模式对比 Greenplum 6.15.0 以及 Apache Spark 3.1.1
-
-## 测试概况
-
-本次测试对比了 TiDB v5.4 MPP 模式下和主流分析引擎例如 Greenplum 和 Apache Spark 最新版本在 TPC-H 100 GB 数据下的性能表现。结果显示,TiDB v5.4 MPP 模式下相对这些方案有 2-3 倍的性能提升。
-
-TiDB v5.0 中引入的 [TiFlash](/tiflash/tiflash-overview.md) 组件的 MPP 模式大大幅增强了 TiDB HTAP 形态。本文的测试对象如下:
-
-+ TiDB v5.4 MPP 执行模式下的列式存储
-+ Greenplum 6.15.0
-+ Apache Spark 3.1.1 + Parquet
-
-## 测试环境
-
-### 硬件配置
-
-| 实例类型 | 实例数 |
-|:----------|:----------|
-| PD | 1 |
-| TiDB | 1 |
-| TiKV | 3 |
-| TiFlash | 3 |
-
-+ CPU:Intel(R) Xeon(R) CPU E5-2630 v4 @ 2.20GHz,40 核
-+ 内存:189 GB
-+ 磁盘:NVMe 3TB * 2
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| TiDB | 5.4 |
-| Greenplum | 6.15.0 |
-| Apache Spark | 3.1.1 |
-
-### 配置参数
-
-#### TiDB v5.4 配置
-
-v5.4 的 TiDB 集群除以下配置项外均使用默认参数配置。所有 TPC-H 测试表均以 TiFlash 列存进行同步,无额外分区和索引。
-
-在 TiFlash 的 `users.toml` 配置文件中进行如下配置:
-
-```toml
-[profiles.default]
-max_memory_usage = 10000000000000
-```
-
-使用 SQL 语句设置以下会话变量:
-
-```sql
-set @@tidb_isolation_read_engines='tiflash';
-set @@tidb_allow_mpp=1;
-set @@tidb_mem_quota_query = 10 << 30;
-```
-
-#### Greenplum 配置
-
-Greenplum 集群使用额外的一台 Master 节点部署(共四台),每台 Segment Server 部署 8 Segments(每个 NVMe SSD 各 4 个),总共 24 Segments。存储格式为 append-only / 列式存储,分区键为主键。
-
-{{< copyable "" >}}
-
-```
-log_statement = all
-gp_autostats_mode = none
-statement_mem = 2048MB
-gp_vmem_protect_limit = 16384
-```
-
-#### Apache Spark 配置
-
-Apache Spark 测试使用 Apache Parquet 作为存储格式,数据存储在 HDFS 上。HDFS 为三节点,为每个节点指定两块 NVMe SSD 盘作为数据盘。通过 Standalone 方式启动 Spark 集群,使用 NVMe SSD 盘作为 `spark.local.dir` 本地目录以借助快速盘加速 Shuffle Spill 过程,无额外分区和索引。
-
-{{< copyable "" >}}
-
-```
---driver-memory 20G
---total-executor-cores 120
---executor-cores 5
---executor-memory 15G
-```
-
-## 测试结果
-
-> **注意:**
->
-> 以下测试结果均为 3 次测试的平均值,单位均为秒。
-
-| Query ID | TiDB v5.4 | Greenplum 6.15.0 | Apache Spark 3.1.1 + Parquet |
-| :-------- | :----------- | :------------ | :-------------- |
-| 1 | 8.08 | 64.1307 | 52.64 |
-| 2 | 2.53 | 4.76612 | 11.83 |
-| 3 | 4.84 | 15.62898 | 13.39 |
-| 4 | 10.94 | 12.88318 | 8.54 |
-| 5 | 12.27 | 23.35449 | 25.23 |
-| 6 | 1.32 | 6.033 | 2.21 |
-| 7 | 5.91 | 12.31266 | 25.45 |
-| 8 | 6.71 | 11.82444 | 23.12 |
-| 9 | 44.19 | 22.40144 | 35.2 |
-| 10 | 7.13 | 12.51071 | 12.18 |
-| 11 | 2.18 | 2.6221 | 10.99 |
-| 12 | 2.88 | 7.97906 | 6.99 |
-| 13 | 6.84 | 10.15873 | 12.26 |
-| 14 | 1.69 | 4.79394 | 3.89 |
-| 15 | 3.29 | 10.48785 | 9.82 |
-| 16 | 5.04 | 4.64262 | 6.76 |
-| 17 | 11.7 | 74.65243 | 44.65 |
-| 18 | 12.87 | 64.87646 | 30.27 |
-| 19 | 4.75 | 8.08625 | 4.7 |
-| 20 | 8.89 | 15.47016 | 8.4 |
-| 21 | 24.44 | 39.08594 | 34.83 |
-| 22 | 1.23 | 7.67476 | 4.59 |
-
-
-
-以上性能图中蓝色为 TiDB v5.4,红色为 Greenplum 6.15.0,黄色为 Apache Spark 3.1.1,纵坐标是查询的处理时间。纵坐标数值越低,表示 TPC-H 性能越好。
diff --git a/benchmark/v6.0-performance-benchmarking-with-tpcc.md b/benchmark/v6.0-performance-benchmarking-with-tpcc.md
deleted file mode 100644
index 033c382ddc37..000000000000
--- a/benchmark/v6.0-performance-benchmarking-with-tpcc.md
+++ /dev/null
@@ -1,127 +0,0 @@
----
-title: TiDB TPC-C 性能对比测试报告 - v6.0.0 对比 v5.4.0
-summary: TiDB v6.0.0 在 TPC-C 性能上比 v5.4.0 提升了 24.20%,表现更好。测试环境为 AWS EC2,硬件配置包括 PD、TiKV、TiDB 和 TPC-C 实例。软件版本为 v5.4.0 和 v6.0.0,配置参数相同。测试方案包括通过 TiUP 部署 TiDB,创建数据库 tpcc,导入数据,运行压力测试,提取结果。测试结果显示 v6.0.0 在不同并发下的 tpmC 均有提升,最高达 26.97%。
----
-
-# TiDB TPC-C 性能对比测试报告 - v6.0.0 对比 v5.4.0
-
-## 测试概况
-
-本次测试对比了 TiDB v6.0.0 和 v5.4.0 在 OLTP 场景下的 TPC-C 性能表现。结果显示,v6.0.0 相比于 v5.4.0 在 TPC-C 性能提升了 24.20%。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| TPC-C | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | v5.4.0、v6.0.0 |
-| TiDB | v5.4.0、v6.0.0 |
-| TiKV | v5.4.0、v6.0.0 |
-| TiUP | 1.9.3 |
-| HAProxy | 2.5.0 |
-
-### 配置参数
-
-两个版本使用同样的配置
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-pessimistic-txn.pipelined: true
-raftdb.allow-concurrent-memtable-write: true
-raftdb.max-background-jobs: 4
-raftstore.apply-max-batch-size: 2048
-raftstore.apply-pool-size: 3
-raftstore.store-max-batch-size: 2048
-raftstore.store-pool-size: 3
-readpool.storage.normal-concurrency: 10
-rocksdb.max-background-jobs: 8
-server.grpc-concurrency: 6
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-```
-
-#### HAProxy 配置 - haproxy.cfg 文件
-
-更多有关 HAProxy 在 TiDB 上的使用,可参阅 [HAProxy 在 TiDB 中的最佳实践](/best-practices/haproxy-best-practices.md)。
-
-{{< copyable "" >}}
-
-```yaml
-global # 全局配置。
- pidfile /var/run/haproxy.pid # 将 HAProxy 进程的 PID 写入 pidfile。
- maxconn 4000 # 每个 HAProxy 进程所接受的最大并发连接数。
- user haproxy # 同 UID 参数。
- group haproxy # 同 GID 参数,建议使用专用用户组。
- nbproc 64 # 在后台运行时创建的进程数。在启动多个进程转发请求时,确保该值足够大,保证 HAProxy 不会成为瓶颈。
- daemon # 让 HAProxy 以守护进程的方式工作于后台,等同于命令行参数“-D”的功能。当然,也可以在命令行中用“-db”参数将其禁用。
-
-defaults # 默认配置。
- log global # 日志继承全局配置段的设置。
- retries 2 # 向上游服务器尝试连接的最大次数,超过此值便认为后端服务器不可用。
- timeout connect 2s # HAProxy 与后端服务器连接超时时间。如果在同一个局域网内,可设置成较短的时间。
- timeout client 30000s # 客户端与 HAProxy 连接后,数据传输完毕,即非活动连接的超时时间。
- timeout server 30000s # 服务器端非活动连接的超时时间。
-
-listen tidb-cluster # 配置 database 负载均衡。
- bind 0.0.0.0:3390 # 浮动 IP 和 监听端口。
- mode tcp # HAProxy 要使用第 4 层的传输层。
- balance leastconn # 连接数最少的服务器优先接收连接。`leastconn` 建议用于长会话服务,例如 LDAP、SQL、TSE 等,而不是短会话协议,如 HTTP。该算法是动态的,对于启动慢的服务器,服务器权重会在运行中作调整。
- server tidb-1 10.9.18.229:4000 check inter 2000 rise 2 fall 3 # 检测 4000 端口,检测频率为每 2000 毫秒一次。如果 2 次检测为成功,则认为服务器可用;如果 3 次检测为失败,则认为服务器不可用。
- server tidb-2 10.9.39.208:4000 check inter 2000 rise 2 fall 3
- server tidb-3 10.9.64.166:4000 check inter 2000 rise 2 fall 3
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v6.0.0 和 v5.4.0。
-2. 创建数据库 tpcc:`create database tpcc;`。
-3. 通过 tiup bench 导入 TPC-C 5000 Warehouse 数据:`tiup bench tpcc prepare --warehouses 5000 --db tpcc -H 127.0.0.1 -p 4000`。
-4. 运行 `tiup bench tpcc run -U root --db tpcc --host 127.0.0.1 --port 4000 --time 1800s --warehouses 5000 --threads {{thread}}` 命令,通过 HAProxy 向 TiDB 加压,每个并发数各测试 30 分钟。
-5. 从结果中提取 New Order 的 tpmC 的数据。
-
-## 测试结果
-
-v6.0.0 相比 v5.4.0 在 TPC-C 性能上有大幅提升,**平均提升了 24.20%**。
-
-| Threads | v5.4.0 tpmC | v6.0.0 tpmC | tpmC 提升 (%) |
-|:----------|:----------|:----------|:----------|
-|50|44822.8|54956.6|22.61|
-|100|52150.3|66216.6|26.97|
-|200|57344.9|72116.7|25.76|
-|400|58675|71254.8|21.44|
-
-
diff --git a/benchmark/v6.0-performance-benchmarking-with-tpch.md b/benchmark/v6.0-performance-benchmarking-with-tpch.md
deleted file mode 100644
index 0d20f8c38b76..000000000000
--- a/benchmark/v6.0-performance-benchmarking-with-tpch.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: TiFlash 与 Greenplum/Spark 性能比较
-summary: TiFlash 与 Greenplum/Spark 性能进行了比较。请参考 TiDB v5.4 TPC-H 性能对比测试报告。
----
-
-# TiFlash 与 Greenplum/Spark 性能比较
-
-请参考 [TiDB v5.4 TPC-H 性能对比测试报告](https://docs.pingcap.com/zh/tidb/stable/v5.4-performance-benchmarking-with-tpch)。
\ No newline at end of file
diff --git a/benchmark/v6.1-performance-benchmarking-with-tpcc.md b/benchmark/v6.1-performance-benchmarking-with-tpcc.md
deleted file mode 100644
index 045caf09cc99..000000000000
--- a/benchmark/v6.1-performance-benchmarking-with-tpcc.md
+++ /dev/null
@@ -1,124 +0,0 @@
----
-title: TiDB TPC-C 性能对比测试报告 - v6.1.0 对比 v6.0.0
-summary: TiDB v6.1.0 在 TPC-C 性能上平均提升了 2.85%,分别为:50 线程提升 2.31%,100 线程提升 2.71%,200 线程提升 3.86%,400 线程提升 2.52%。
----
-
-# TiDB TPC-C 性能对比测试报告 - v6.1.0 对比 v6.0.0
-
-## 测试概况
-
-本次测试对比了 TiDB v6.1.0 和 v6.0.0 在 OLTP 场景下的 TPC-C 性能表现。结果显示,v6.1.0 相比于 v6.0.0 在 TPC-C 性能提升了 2.85%。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-|:----------|:----------|:----------|
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge| 3 |
-| TiDB | c5.4xlarge| 3 |
-| TPC-C | c5.9xlarge| 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-|:----------|:-----------|
-| PD | v6.0.0、v6.1.0 |
-| TiDB | v6.0.0、v6.1.0 |
-| TiKV | v6.0.0、v6.1.0 |
-| TiUP | 1.9.3 |
-| HAProxy | 2.5.0 |
-
-### 配置参数
-
-两个版本使用同样的配置。
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-raftstore.apply-max-batch-size: 2048
-raftstore.apply-pool-size: 3
-raftstore.store-max-batch-size: 2048
-raftstore.store-pool-size: 2
-readpool.storage.normal-concurrency: 10
-server.grpc-concurrency: 6
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-set global tidb_prepared_plan_cache_size=1000;
-```
-
-#### HAProxy 配置 - haproxy.cfg 文件
-
-更多有关 HAProxy 在 TiDB 上的使用,可参阅 [HAProxy 在 TiDB 中的最佳实践](/best-practices/haproxy-best-practices.md)。
-
-{{< copyable "" >}}
-
-```yaml
-global # 全局配置。
- pidfile /var/run/haproxy.pid # 将 HAProxy 进程的 PID 写入 pidfile。
- maxconn 4000 # 每个 HAProxy 进程所接受的最大并发连接数。
- user haproxy # 同 UID 参数。
- group haproxy # 同 GID 参数,建议使用专用用户组。
- nbproc 64 # 在后台运行时创建的进程数。在启动多个进程转发请求时,确保该值足够大,保证 HAProxy 不会成为瓶颈。
- daemon # 让 HAProxy 以守护进程的方式工作于后台,等同于命令行参数“-D”的功能。当然,也可以在命令行中用“-db”参数将其禁用。
-
-defaults # 默认配置。
- log global # 日志继承全局配置段的设置。
- retries 2 # 向上游服务器尝试连接的最大次数,超过此值便认为后端服务器不可用。
- timeout connect 2s # HAProxy 与后端服务器连接超时时间。如果在同一个局域网内,可设置成较短的时间。
- timeout client 30000s # 客户端与 HAProxy 连接后,数据传输完毕,即非活动连接的超时时间。
- timeout server 30000s # 服务器端非活动连接的超时时间。
-
-listen tidb-cluster # 配置 database 负载均衡。
- bind 0.0.0.0:3390 # 浮动 IP 和 监听端口。
- mode tcp # HAProxy 要使用第 4 层的传输层。
- balance leastconn # 连接数最少的服务器优先接收连接。`leastconn` 建议用于长会话服务,例如 LDAP、SQL、TSE 等,而不是短会话协议,如 HTTP。该算法是动态的,对于启动慢的服务器,服务器权重会在运行中作调整。
- server tidb-1 10.9.18.229:4000 check inter 2000 rise 2 fall 3 # 检测 4000 端口,检测频率为每 2000 毫秒一次。如果 2 次检测为成功,则认为服务器可用;如果 3 次检测为失败,则认为服务器不可用。
- server tidb-2 10.9.39.208:4000 check inter 2000 rise 2 fall 3
- server tidb-3 10.9.64.166:4000 check inter 2000 rise 2 fall 3
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v6.1.0 和 v6.0.0。
-2. 创建数据库 tpcc:`create database tpcc;`。
-3. 通过 tiup bench 导入 TPC-C 5000 Warehouse 数据:`tiup bench tpcc prepare --warehouses 5000 --db tpcc -H 127.0.0.1 -p 4000`。
-4. 运行 `tiup bench tpcc run -U root --db tpcc --host 127.0.0.1 --port 4000 --time 1800s --warehouses 5000 --threads {{thread}}` 命令,通过 HAProxy 向 TiDB 加压,每个并发数各测试 30 分钟。
-5. 从结果中提取 New Order 的 tpmC 的数据。
-
-## 测试结果
-
-v6.1.0 相比 v6.0.0 在 TPC-C 性能上**平均提升了 2.85%**。
-
-| Threads | v6.0.0 tpmC | v6.1.0 tpmC | tpmC 提升 (%) |
-|:----------|:----------|:----------|:----------|
-|50|59059.2|60424.4|2.31|
-|100|69357.6|71235.5|2.71|
-|200|71364.8|74117.8|3.86|
-|400|72694.3|74525.3|2.52|
-
-
diff --git a/benchmark/v6.1-performance-benchmarking-with-tpch.md b/benchmark/v6.1-performance-benchmarking-with-tpch.md
deleted file mode 100644
index 6533d99ced5c..000000000000
--- a/benchmark/v6.1-performance-benchmarking-with-tpch.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: TiFlash 与 Greenplum/Spark 性能比较
-summary: TiFlash 与 Greenplum/Spark 性能比较。请参考 TiDB v5.4 TPC-H 性能对比测试报告。
----
-
-# TiFlash 与 Greenplum/Spark 性能比较
-
-请参考 [TiDB v5.4 TPC-H 性能对比测试报告](https://docs.pingcap.com/zh/tidb/stable/v5.4-performance-benchmarking-with-tpch)。
\ No newline at end of file
diff --git a/benchmark/v6.2-performance-benchmarking-with-tpcc.md b/benchmark/v6.2-performance-benchmarking-with-tpcc.md
deleted file mode 100644
index 0b83fbe7e552..000000000000
--- a/benchmark/v6.2-performance-benchmarking-with-tpcc.md
+++ /dev/null
@@ -1,124 +0,0 @@
----
-title: TiDB TPC-C 性能对比测试报告 - v6.2.0 对比 v6.1.0
-summary: TiDB v6.2.0 在 TPC-C 性能测试中相比 v6.1.0 下降了 2.00%,平均性能下降了 2.00%。在不同并发数下,v6.2.0 的性能都有所下降,最高下降达到 3.60%。
----
-
-# TiDB TPC-C 性能对比测试报告 - v6.2.0 对比 v6.1.0
-
-## 测试概况
-
-本次测试对比了 TiDB v6.2.0 和 v6.1.0 在 OLTP 场景下的 TPC-C 性能表现。结果显示,v6.2.0 相比于 v6.1.0 在 TPC-C 性能下降了 2.00%。
-
-## 测试环境 (AWS EC2)
-
-### 硬件配置
-
-| 服务类型 | EC2 类型 | 实例数 |
-| :------- | :--------- | :----- |
-| PD | m5.xlarge | 3 |
-| TiKV | i3.4xlarge | 3 |
-| TiDB | c5.4xlarge | 3 |
-| TPC-C | c5.9xlarge | 1 |
-
-### 软件版本
-
-| 服务类型 | 软件版本 |
-| :------- | :------------- |
-| PD | v6.1.0、v6.2.0 |
-| TiDB | v6.1.0、v6.2.0 |
-| TiKV | v6.1.0、v6.2.0 |
-| TiUP | 1.9.3 |
-| HAProxy | 2.5.0 |
-
-### 配置参数
-
-两个版本使用同样的配置。
-
-#### TiDB 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-log.level: "error"
-prepared-plan-cache.enabled: true
-tikv-client.max-batch-wait-time: 2000000
-```
-
-#### TiKV 参数配置
-
-{{< copyable "" >}}
-
-```yaml
-raftstore.apply-max-batch-size: 2048
-raftstore.apply-pool-size: 3
-raftstore.store-max-batch-size: 2048
-raftstore.store-pool-size: 2
-readpool.storage.normal-concurrency: 10
-server.grpc-concurrency: 6
-```
-
-#### TiDB 全局变量配置
-
-{{< copyable "sql" >}}
-
-```sql
-set global tidb_hashagg_final_concurrency=1;
-set global tidb_hashagg_partial_concurrency=1;
-set global tidb_enable_async_commit = 1;
-set global tidb_enable_1pc = 1;
-set global tidb_guarantee_linearizability = 0;
-set global tidb_enable_clustered_index = 1;
-set global tidb_prepared_plan_cache_size=1000;
-```
-
-#### HAProxy 配置 - haproxy.cfg 文件
-
-更多有关 HAProxy 在 TiDB 上的使用,可参阅 [HAProxy 在 TiDB 中的最佳实践](/best-practices/haproxy-best-practices.md)。
-
-{{< copyable "" >}}
-
-```yaml
-global # 全局配置。
- pidfile /var/run/haproxy.pid # 将 HAProxy 进程的 PID 写入 pidfile。
- maxconn 4000 # 每个 HAProxy 进程所接受的最大并发连接数。
- user haproxy # 同 UID 参数。
- group haproxy # 同 GID 参数,建议使用专用用户组。
- nbproc 64 # 在后台运行时创建的进程数。在启动多个进程转发请求时,确保该值足够大,保证 HAProxy 不会成为瓶颈。
- daemon # 让 HAProxy 以守护进程的方式工作于后台,等同于命令行参数“-D”的功能。当然,也可以在命令行中用“-db”参数将其禁用。
-
-defaults # 默认配置。
- log global # 日志继承全局配置段的设置。
- retries 2 # 向上游服务器尝试连接的最大次数,超过此值便认为后端服务器不可用。
- timeout connect 2s # HAProxy 与后端服务器连接超时时间。如果在同一个局域网内,可设置成较短的时间。
- timeout client 30000s # 客户端与 HAProxy 连接后,数据传输完毕,即非活动连接的超时时间。
- timeout server 30000s # 服务器端非活动连接的超时时间。
-
-listen tidb-cluster # 配置 database 负载均衡。
- bind 0.0.0.0:3390 # 浮动 IP 和 监听端口。
- mode tcp # HAProxy 要使用第 4 层的传输层。
- balance leastconn # 连接数最少的服务器优先接收连接。`leastconn` 建议用于长会话服务,例如 LDAP、SQL、TSE 等,而不是短会话协议,如 HTTP。该算法是动态的,对于启动慢的服务器,服务器权重会在运行中作调整。
- server tidb-1 10.9.18.229:4000 check inter 2000 rise 2 fall 3 # 检测 4000 端口,检测频率为每 2000 毫秒一次。如果 2 次检测为成功,则认为服务器可用;如果 3 次检测为失败,则认为服务器不可用。
- server tidb-2 10.9.39.208:4000 check inter 2000 rise 2 fall 3
- server tidb-3 10.9.64.166:4000 check inter 2000 rise 2 fall 3
-```
-
-## 测试方案
-
-1. 通过 TiUP 部署 TiDB v6.2.0 和 v6.1.0。
-2. 创建数据库 tpcc:`create database tpcc;`。
-3. 通过 tiup bench 导入 TPC-C 5000 Warehouse 数据:`tiup bench tpcc prepare --warehouses 5000 --db tpcc -H 127.0.0.1 -P 4000`。
-4. 运行 `tiup bench tpcc run -U root --db tpcc --host 127.0.0.1 --port 4000 --time 1800s --warehouses 5000 --threads {{thread}}` 命令,通过 HAProxy 向 TiDB 加压,每个并发数各测试 30 分钟。
-5. 从结果中提取 New Order 的 tpmC 的数据。
-
-## 测试结果
-
-v6.2.0 相比 v6.1.0 在 TPC-C 性能上**平均下降了 2.00%**。
-
-| Threads | v6.1.0 tpmC | v6.2.0 tpmC | tpmC 提升 (%) |
-| :------ | :---------- | :---------- | :------------ |
-| 50 | 62212.4 | 61874.4 | -0.54 |
-| 100 | 72790.7 | 71317.5 | -2.02 |
-| 200 | 75818.6 | 73090.4 | -3.60 |
-| 400 | 74515.3 | 73156.9 | -1.82 |
-
-
diff --git a/benchmark/v6.2-performance-benchmarking-with-tpch.md b/benchmark/v6.2-performance-benchmarking-with-tpch.md
deleted file mode 100644
index 50487b04284f..000000000000
--- a/benchmark/v6.2-performance-benchmarking-with-tpch.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: TiFlash 与 Greenplum/Spark 性能比较
-summary: TiFlash 与 Greenplum/Spark 性能进行了比较。请参考 TiDB v5.4 TPC-H 性能对比测试报告。
----
-
-# TiFlash 与 Greenplum/Spark 性能比较
-
-请参考 [TiDB v5.4 TPC-H 性能对比测试报告](https://docs.pingcap.com/zh/tidb/stable/v5.4-performance-benchmarking-with-tpch)。
diff --git a/best-practices-for-security-configuration.md b/best-practices-for-security-configuration.md
index daca3966fd3e..8a059df2d0eb 100644
--- a/best-practices-for-security-configuration.md
+++ b/best-practices-for-security-configuration.md
@@ -20,6 +20,8 @@ TiDB 的安全性对于保护数据完整性和机密性至关重要。本文提
- 使用 TiUP 部署时,参考[使用 TiUP 部署 TiDB 集群](/production-deployment-using-tiup.md#第-7-步启动集群)为 root 用户生成随机密码。
- 使用 TiDB Operator 部署时,参考[初始化账号和密码设置](https://docs.pingcap.com/zh/tidb-in-kubernetes/stable/initialize-a-cluster#初始化账号和密码设置)为 root 用户设置密码。
+你也可以使用 [`--initialize-secure`](/command-line-flags-for-tidb-configuration.md#--initialize-secure) 选项来限制初始 root 用户的网络访问。
+
## 启用密码复杂性检查
默认情况下,TiDB 未启用密码复杂性策略,这可能导致使用弱密码或空密码,增加安全风险。
@@ -64,7 +66,7 @@ TiDB Dashboard 的账号体系与 TiDB SQL 用户一致,并基于 TiDB SQL 用
TiDB 的默认安装中存在许多用于组件间通信的特权接口。这些端口通常不需要向用户端开放,因为它们主要用于内部通信。当这些端口直接暴露在公共网络上时,会增加潜在的攻击面,违反了安全最小化原则,增加了安全风险的产生。下表列出了 TiDB 集群默认监听端口的详细情况:
-| 组件 | 默认监听端口 | 协议 |
+| 组件 | 默认监听端口 | 协议 |
|-------------------|--------------|------------|
| TiDB | 4000 | MySQL |
| TiDB | 10080 | HTTP |
@@ -76,14 +78,13 @@ TiDB 的默认安装中存在许多用于组件间通信的特权接口。这些
| TiFlash | 20170 | Protocol |
| TiFlash | 20292 | HTTP |
| TiFlash | 8234 | HTTP |
-| TiFlow | 8261/8291 | HTTP |
-| TiFlow | 8262 | HTTP |
-| TiFlow | 8300 | HTTP |
+| DM master | 8261 | HTTP |
+| DM master | 8291 | HTTP |
+| DM worker | 8262 | HTTP |
+| TiCDC | 8300 | HTTP |
| TiDB Lightning | 8289 | HTTP |
| TiDB Operator | 6060 | HTTP |
| TiDB Dashboard | 2379 | HTTP |
-| TiDB Binlog | 8250 | HTTP |
-| TiDB Binlog | 8249 | HTTP |
| TMS | 8082 | HTTP |
| TEM | 8080 | HTTP |
| TEM | 8000 | HTTP |
@@ -97,18 +98,18 @@ TiDB 的默认安装中存在许多用于组件间通信的特权接口。这些
| AlertManager | 9093 | HTTP |
| AlertManager | 9094 | Protocol |
| Node Exporter | 9100 | HTTP |
-| Blackbox Exporter | 9115 | HTTP |
+| Blackbox Exporter | 9115 | HTTP |
| NG Monitoring | 12020 | HTTP |
-建议向普通用户只公开数据库的 `4000` 端口和 Grafana 面板的 `9000` 端口,并通过网络安全策略组或防火墙限制其他端口。以下是使用 `iptables` 限制端口访问的示例:
+建议向普通用户只公开数据库的 `4000` 端口和 Grafana 面板的 `3000` 端口,并通过网络安全策略组或防火墙限制其他端口。以下是使用 `iptables` 限制端口访问的示例:
```shell
# 允许来自各组件白名单 IP 地址范围的内部端口通讯
sudo iptables -A INPUT -s 内网 IP 地址范围 -j ACCEPT
-# 仅对外部用户开放 4000 和 9000 端口
+# 仅对外部用户开放 4000 和 3000 端口
sudo iptables -A INPUT -p tcp --dport 4000 -j ACCEPT
-sudo iptables -A INPUT -p tcp --dport 9000 -j ACCEPT
+sudo iptables -A INPUT -p tcp --dport 3000 -j ACCEPT
# 默认拒绝所有其他流量
sudo iptables -P INPUT DROP
diff --git a/best-practices/_index.md b/best-practices/_index.md
new file mode 100644
index 000000000000..b4f1550974bb
--- /dev/null
+++ b/best-practices/_index.md
@@ -0,0 +1,58 @@
+---
+title: TiDB 最佳实践
+summary: 了解部署、配置和使用 TiDB 的最佳实践。
+---
+
+# TiDB 最佳实践
+
+通过遵循 TiDB 在部署、配置和使用方面的最佳实践,你可以有效优化 TiDB 集群的性能、可靠性和可扩展性。本文档对 TiDB 的各类最佳实践进行了总体介绍,帮助你更高效地使用 TiDB。
+
+## 使用概览
+
+从使用 TiDB 的基本原则和通用建议入手,快速了解如何高效使用 TiDB。
+
+| 最佳实践主题 | 说明 |
+| ------------- | ---- |
+| [TiDB 最佳实践](/best-practices/tidb-best-practices.md) | TiDB 使用最佳实践的整体概览。 |
+
+## 库表设计
+
+了解 TiDB 库表设计最佳实践,包括 DDL 管理、主键选择,以及索引的设计与维护,以兼顾系统的性能、可扩展性和可维护性。
+
+| 最佳实践主题 | 说明 |
+| ------------- | ---- |
+| [DDL 最佳实践](/best-practices/ddl-introduction.md) | 在 TiDB 中管理数据定义语言 (DDL) 操作的最佳实践。 |
+| [将 UUID 用作主键的最佳实践](/best-practices/uuid.md) | 使用 UUID(通用唯一标识符)作为主键时,高效存储和索引 UUID 的最佳实践。 |
+| [多列索引优化最佳实践](/best-practices/multi-column-index-best-practices.md) | 通过合理设计和使用多列索引来提升 TiDB 查询性能的最佳实践。 |
+| [管理索引和识别未使用索引的最佳实践](/best-practices/index-management-best-practices.md) | 管理和优化索引、识别并清理未使用索引,以提升 TiDB 性能的最佳实践。 |
+
+## 集群部署
+
+探索适用于不同场景的推荐部署模式,例如在公有云上部署和多数据中心部署,以确保高可用性和资源使用效率。
+
+| 最佳实践主题 | 说明 |
+| ------------- | ---- |
+| [在公有云上部署 TiDB 的最佳实践](/best-practices/best-practices-on-public-cloud.md) | 在公有云环境中部署 TiDB 的最佳实践,以兼顾性能、成本、可靠性和可扩展性。 |
+| [三节点混合部署的最佳实践](/best-practices/three-nodes-hybrid-deployment.md) | 在保证系统稳定性的前提下,实现高性价比、三节点混合部署的最佳实践。 |
+| [在三数据中心下就近读取数据的最佳实践](/best-practices/three-dc-local-read.md) | 通过使用 Stale Read 减少跨数据中心访问延迟的最佳实践。 |
+
+## 运维管理
+
+掌握 TiDB 在生产环境中的运维最佳实践,包括流量路由、负载均衡和监控,以确保系统稳定性和可观测性。
+
+| 最佳实践主题 | 说明 |
+| ------------- | ---- |
+| [HAProxy 最佳实践](/best-practices/haproxy-best-practices.md) | 配置 HAProxy 将应用流量分发到多个 TiDB 节点的最佳实践。 |
+| [只读存储节点最佳实践](/best-practices/readonly-nodes.md) | 使用只读节点将分析型或重读负载与 OLTP 流量隔离的最佳实践。 |
+| [Grafana 监控最佳实践](/best-practices/grafana-monitor-best-practices.md) | 通过关键指标和面板配置实现故障诊断的最佳实践。 |
+
+## 性能调优
+
+深入了解如何通过对 TiKV 和 PD 等 TiDB 核心组件进行调优,以及利用只读存储节点等特性,提升不同业务负载下的系统性能。
+
+| 最佳实践主题 | 说明 |
+| ------------- | ---- |
+| [SaaS 多租户场景下处理百万张表的最佳实践](/best-practices/saas-best-practices.md) | TiDB 在 SaaS 多租户环境的最佳实践,尤其适用于单集群表数量超过百万级别的场景。 |
+| [高并发写入场景最佳实践](/best-practices/high-concurrency-best-practices.md) | 在高并发写入场景下避免写入热点、优化 TiDB 性能的最佳实践。 |
+| [海量 Region 集群调优最佳实践](/best-practices/massive-regions-best-practices.md) | 在管理百万级 Region 时,优化 TiKV 性能并降低心跳开销的最佳实践。 |
+| [PD 调度策略最佳实践](/best-practices/pd-scheduling-best-practices.md) | 通过调整 PD 调度策略实现负载均衡并加快故障恢复的最佳实践。 |
diff --git a/best-practices-on-public-cloud.md b/best-practices/best-practices-on-public-cloud.md
similarity index 96%
rename from best-practices-on-public-cloud.md
rename to best-practices/best-practices-on-public-cloud.md
index 619ffc0e0e7f..c67b5408284f 100644
--- a/best-practices-on-public-cloud.md
+++ b/best-practices/best-practices-on-public-cloud.md
@@ -1,6 +1,7 @@
---
title: 在公有云上部署 TiDB 的最佳实践
summary: 了解在公有云上部署 TiDB 的最佳实践。
+aliases: ['/zh/tidb/stable/best-practices-on-public-cloud/','/zh/tidb/dev/best-practices-on-public-cloud/']
---
# 在公有云上部署 TiDB 的最佳实践
@@ -13,7 +14,7 @@ summary: 了解在公有云上部署 TiDB 的最佳实践。
[RocksDB](https://rocksdb.org/) 是 TiKV 的存储引擎,负责存储用户数据。出于成本考虑,云上提供的 EBS IO 吞吐量通常比较有限,因此 RocksDB 可能会表现出较高的写放大,导致磁盘吞吐量成为负载的瓶颈。随着时间的推移,待 compaction 的字节总量会不断增加从而触发流量控制,这意味着此时 TiKV 缺乏足够的磁盘带宽来处理前台写入流量。
-要缓解由磁盘吞吐量受限引起的瓶颈,你可以通过[启用 Titan](#启用-titan) 来改善性能。如果数据的平均行大小低于 512 字节,Titan 并不适用,此时你可以通过[提高所有压缩级别](#提高所有压缩级别) 来改善性能。
+要缓解由磁盘吞吐量受限引起的瓶颈,你可以通过[启用 Titan](#启用-titan) 来改善性能。如果数据的平均行大小低于 512 字节,Titan 并不适用,此时你可以通过[提高所有压缩级别](#提高所有压缩级别)来改善性能。
### 启用 Titan
@@ -136,14 +137,6 @@ tikv:
要减少跨可用区的读取流量,你可以启用 [Follower Read 功能](/follower-read.md),该功能允许 TiDB 优先选择在同一可用区内的副本进行读取。要启用该功能,请将 [`tidb_replica_read`](/system-variables.md#tidb_replica_read-从-v40-版本开始引入) 变量设置为 `closest-replicas` 或 `closest-adaptive`。
-要减少 TiKV 实例中跨可用区的写入流量,你可以启用 gRPC 压缩功能,该功能在网络传输数据之前会对其进行压缩。以下配置示例展示了如何为 TiKV 启用 gzip gRPC 压缩:
-
-```
-server_configs:
- tikv:
- server.grpc-compression-type: gzip
-```
-
要减少 TiFlash MPP 任务中数据交换(data shuffle 过程)所带来的网络流量,建议在同一可用区内部署多个 TiFlash 实例。从 v6.6.0 开始,[Exchange 数据压缩](/explain-mpp.md#mpp-version-和-exchange-数据压缩)功能默认启用,以减少 MPP 数据交换导致的网络流量。
## 缓解 Google Cloud 上的实时迁移维护事件带来的性能影响
@@ -156,7 +149,7 @@ Google Cloud 的[实时迁移功能](https://cloud.google.com/compute/docs/insta
- TiKV:在维护期间驱逐受影响的 TiKV 存储上的 Leader。
- PD:如果当前 PD 实例是 PD Leader,则会重新分配 Leader。
-需要注意的是,此监控脚本是专门为 [TiDB Operator](https://docs.pingcap.com/tidb-in-kubernetes/dev/tidb-operator-overview) 部署的 TiDB 集群设计的,TiDB Operator 为 Kubernetes 环境中的 TiDB 提供了增强的管理功能。
+需要注意的是,此监控脚本是专门为 [TiDB Operator](https://docs.pingcap.com/zh/tidb-in-kubernetes/v1.6/tidb-operator-overview) 部署的 TiDB 集群设计的,TiDB Operator 为 Kubernetes 环境中的 TiDB 提供了增强的管理功能。
通过使用该监控脚本,并在维护事件期间采取必要的措施,TiDB 集群可以更好地应对 Google Cloud 上的实时迁移事件,确保对查询处理和响应时间的影响最小以及系统的平稳运行。
diff --git a/ddl-introduction.md b/best-practices/ddl-introduction.md
similarity index 93%
rename from ddl-introduction.md
rename to best-practices/ddl-introduction.md
index 32d810258406..d35bf5639b0f 100644
--- a/ddl-introduction.md
+++ b/best-practices/ddl-introduction.md
@@ -1,6 +1,7 @@
---
title: DDL 语句的执行原理及最佳实践
summary: 介绍 TiDB 中 DDL 语句的实现原理、在线变更过程、最佳实践等内容。
+aliases: ['/zh/tidb/stable/ddl-introduction/','/zh/tidb/dev/ddl-introduction/','/zh/tidbcloud/ddl-introduction/']
---
# DDL 语句的执行原理及最佳实践
@@ -13,11 +14,9 @@ TiDB 采用在线异步变更的方式执行 DDL 语句,从而实现 DDL 语
### DDL 语句类型简介
-按照执行期间是否阻塞用户业务,DDL 语句可以划分为:
+TiDB 支持在线 DDL (Online DDL),即在执行 DDL 语句时,数据库通过特定的机制确保 DDL 操作不会阻塞用户业务。你可以在 DDL 执行期间提交数据修改,数据库会保证数据的一致性和正确性。
-- **离线 DDL 语句**:即数据库接收到用户的 DDL 语句后,会先对要修改的数据库对象进行加锁,再执行元数据变更,在 DDL 执行过程中将阻塞用户业务对数据的修改。
-
-- **在线 DDL 语句**:即数据库在执行 DDL 语句时,通过一定的方法,使得 DDL 执行不阻塞用户业务,且能够保证用户业务可在 DDL 执行期间提交修改,在执行过程中保证对应对象的数据正确性与一致性。
+相比之下,离线 DDL (Offline DDL) 在执行期间会对数据库对象加锁,阻塞用户对数据的修改操作,直到 DDL 操作完成。TiDB 不支持离线 DDL。
按照是否需要操作 DDL 目标对象所包括的数据来划分,DDL 语句可以划分为:
@@ -88,7 +87,7 @@ absent -> delete only -> write only -> write reorg -> public
+ 涉及同一张表的 DDL 相互阻塞。
+ `DROP DATABASE` 和数据库内所有对象的 DDL 互相阻塞。
+ 涉及不同表的加索引和列类型变更可以并发执行。
-+ 逻辑 DDL 需要等待之前正在执行的逻辑 DDL 执行完才能执行。
++ 从 v8.2.0 版本开始,支持并行执行不同表的[逻辑 DDL 语句](/best-practices/ddl-introduction.md#ddl-语句类型简介)。
+ 其他情况下 DDL 可以根据 Concurrent DDL 并行度可用情况确定是否可以执行。
具体来说,TiDB 在 v6.2.0 中对 DDL 执行框架进行了如下升级:
@@ -186,6 +185,11 @@ absent -> delete only -> write only -> write reorg -> public
你只能对暂停状态的 DDL 任务进行恢复操作,否则会在 `RESULT` 列看到 `Job 3 can't be resumed`。
+## DDL 相关的表
+
+- [`information_schema.DDL_JOBS`](/information-schema/information-schema-ddl-jobs.md):当前正在运行和已完成的 DDL 任务信息。
+- [`mysql.tidb_mdl_view`](/mysql-schema/mysql-schema-tidb-mdl-view.md):元数据锁的信息。可帮助识别哪个查询阻塞了 DDL 的执行进程。
+
## 常见问题
DDL 语句执行相关的常见问题,参考 [SQL FAQ - DDL 执行](/faq/sql-faq.md#ddl-执行)。
diff --git a/best-practices/grafana-monitor-best-practices.md b/best-practices/grafana-monitor-best-practices.md
index b1613f940c70..01c083d220af 100644
--- a/best-practices/grafana-monitor-best-practices.md
+++ b/best-practices/grafana-monitor-best-practices.md
@@ -1,7 +1,7 @@
---
title: 使用 Grafana 监控 TiDB 的最佳实践
summary: 了解高效利用 Grafana 监控 TiDB 的七个技巧。
-aliases: ['/docs-cn/dev/best-practices/grafana-monitor-best-practices/','/docs-cn/dev/reference/best-practices/grafana-monitor/']
+aliases: ['/docs-cn/dev/best-practices/grafana-monitor-best-practices/','/docs-cn/dev/reference/best-practices/grafana-monitor/','/zh/tidb/stable/grafana-monitor-best-practices/','/zh/tidb/dev/grafana-monitor-best-practices/']
---
# 使用 Grafana 监控 TiDB 的最佳实践
diff --git a/best-practices/haproxy-best-practices.md b/best-practices/haproxy-best-practices.md
index 313036cd8f97..525473659a93 100644
--- a/best-practices/haproxy-best-practices.md
+++ b/best-practices/haproxy-best-practices.md
@@ -1,7 +1,7 @@
---
title: HAProxy 在 TiDB 中的最佳实践
-aliases: ['/docs-cn/dev/best-practices/haproxy-best-practices/','/docs-cn/dev/reference/best-practices/haproxy/']
summary: HAProxy 是 TiDB 中实现负载均衡的最佳实践。它提供 TCP 协议下的负载均衡能力,通过连接 HAProxy 提供的浮动 IP 对数据进行操作,实现 TiDB Server 层的负载均衡。HAProxy 提供高可用性、负载均衡、健康检查、会话保持、SSL 支持和监控统计等核心功能。部署 HAProxy 需要满足一定的硬件和软件要求,配置和启动 HAProxy 后即可实现数据库负载均衡。
+aliases: ['/docs-cn/dev/best-practices/haproxy-best-practices/','/docs-cn/dev/reference/best-practices/haproxy/','/zh/tidb/stable/haproxy-best-practices/','/zh/tidb/dev/haproxy-best-practices/']
---
# HAProxy 在 TiDB 中的最佳实践
@@ -69,8 +69,6 @@ HAProxy 由 Linux 内核的核心贡献者 Willy Tarreau 于 2000 年编写,
执行如下命令安装依赖包:
-{{< copyable "shell-regular" >}}
-
```bash
yum -y install epel-release gcc systemd-devel
```
@@ -81,28 +79,22 @@ HAProxy 配置 Database 负载均衡场景操作简单,以下部署操作具
### 安装 HAProxy
-1. 下载 HAProxy 2.6.2 的源码包:
-
- {{< copyable "shell-regular" >}}
+1. 下载 HAProxy 2.6.21 的源码包:
```bash
- wget https://www.haproxy.org/download/2.6/src/haproxy-2.6.2.tar.gz
+ wget https://www.haproxy.org/download/2.6/src/haproxy-2.6.21.tar.gz
```
2. 解压源码包:
- {{< copyable "shell-regular" >}}
-
```bash
- tar zxf haproxy-2.6.2.tar.gz
+ tar zxf haproxy-2.6.21.tar.gz
```
3. 从源码编译 HAProxy 应用:
- {{< copyable "shell-regular" >}}
-
```bash
- cd haproxy-2.6.2
+ cd haproxy-2.6.21
make clean
make -j 8 TARGET=linux-glibc USE_THREAD=1
make PREFIX=${/app/haproxy} SBINDIR=${/app/haproxy/bin} install # 将 `${/app/haproxy}` 和 `${/app/haproxy/bin}` 替换为自定义的实际路径。
@@ -110,8 +102,6 @@ HAProxy 配置 Database 负载均衡场景操作简单,以下部署操作具
4. 重新配置 `profile` 文件:
- {{< copyable "shell-regular" >}}
-
```bash
echo 'export PATH=/app/haproxy/bin:$PATH' >> /etc/profile
. /etc/profile
@@ -119,8 +109,6 @@ HAProxy 配置 Database 负载均衡场景操作简单,以下部署操作具
5. 检查 HAProxy 是否安装成功:
- {{< copyable "shell-regular" >}}
-
```bash
which haproxy
```
@@ -129,8 +117,6 @@ HAProxy 配置 Database 负载均衡场景操作简单,以下部署操作具
执行如下命令查看命令行参数及基本用法:
-{{< copyable "shell-regular" >}}
-
```bash
haproxy --help
```
@@ -202,7 +188,7 @@ listen admin_stats # frontend 和 backend 的组合体
stats admin if TRUE # 手工启用或禁用后端服务器(HAProxy 1.4.9 及之后版本开始支持)。
listen tidb-cluster # 配置 database 负载均衡。
- bind 0.0.0.0:3390 # 浮动 IP 和 监听端口。
+ bind 0.0.0.0:3390 # 浮动 IP 和监听端口。
mode tcp # HAProxy 要使用第 4 层的传输层。
balance leastconn # 连接数最少的服务器优先接收连接。`leastconn` 建议用于长会话服务,例如 LDAP、SQL、TSE 等,而不是短会话协议,如 HTTP。该算法是动态的,对于启动慢的服务器,服务器权重会在运行中作调整。
server tidb-1 10.9.18.229:4000 check inter 2000 rise 2 fall 3 # 检测 4000 端口,检测频率为每 2000 毫秒一次。如果 2 次检测为成功,则认为服务器可用;如果 3 次检测为失败,则认为服务器不可用。
@@ -226,8 +212,6 @@ listen tidb-cluster # 配置 database 负载均衡。
要启动 HAProxy,执行 `haproxy` 命令。默认读取 `/etc/haproxy/haproxy.cfg`(推荐)。
-{{< copyable "shell-regular" >}}
-
```bash
haproxy -f /etc/haproxy/haproxy.cfg
```
@@ -238,16 +222,12 @@ haproxy -f /etc/haproxy/haproxy.cfg
1. 执行如下命令:
- {{< copyable "shell-regular" >}}
-
```bash
ps -ef | grep haproxy
```
2. 终止 HAProxy 相关的 PID 进程:
- {{< copyable "shell-regular" >}}
-
```bash
kill -9 ${haproxy.pid}
```
diff --git a/best-practices/high-concurrency-best-practices.md b/best-practices/high-concurrency-best-practices.md
index 3b6c6fff413b..3f9e82853f5d 100644
--- a/best-practices/high-concurrency-best-practices.md
+++ b/best-practices/high-concurrency-best-practices.md
@@ -1,7 +1,7 @@
---
title: TiDB 高并发写入场景最佳实践
summary: 了解 TiDB 在高并发写入场景下的最佳实践。
-aliases: ['/docs-cn/dev/best-practices/high-concurrency-best-practices/','/docs-cn/dev/reference/best-practices/high-concurrency/']
+aliases: ['/docs-cn/dev/best-practices/high-concurrency-best-practices/','/docs-cn/dev/reference/best-practices/high-concurrency/','/zh/tidb/stable/high-concurrency-best-practices/','/zh/tidb/dev/high-concurrency-best-practices/']
---
# TiDB 高并发写入场景最佳实践
@@ -10,7 +10,7 @@ aliases: ['/docs-cn/dev/best-practices/high-concurrency-best-practices/','/docs-
## 目标读者
-本文假设你已对 TiDB 有一定的了解,推荐先阅读 TiDB 原理相关的三篇文章([讲存储](https://pingcap.com/blog-cn/tidb-internal-1/),[说计算](https://pingcap.com/blog-cn/tidb-internal-2/),[谈调度](https://pingcap.com/blog-cn/tidb-internal-3/)),以及 [TiDB Best Practice](https://pingcap.com/blog-cn/tidb-best-practice/)。
+本文假设你已对 TiDB 有一定的了解,推荐先阅读 TiDB 原理相关的三篇文章([讲存储](https://tidb.net/blog/dbe4f467),[说计算](https://tidb.net/blog/8427565a),[谈调度](https://tidb.net/blog/a558961f)),以及 [TiDB Best Practice](https://tidb.net/blog/7f818fc0)。
## 高并发批量插入场景
@@ -29,7 +29,7 @@ aliases: ['/docs-cn/dev/best-practices/high-concurrency-best-practices/','/docs-
## TiDB 数据分布原理
-如果要解决以上挑战,需要从 TiDB 数据切分以及调度的原理开始讲起。这里只作简单说明,详情可参阅[谈调度](https://pingcap.com/blog-cn/tidb-internal-3/)。
+如果要解决以上挑战,需要从 TiDB 数据切分以及调度的原理开始讲起。这里只作简单说明,详情可参阅[谈调度](https://tidb.net/blog/a558961f)。
TiDB 以 Region 为单位对数据进行切分,每个 Region 有大小限制(默认 96M)。Region 的切分方式是范围切分。每个 Region 会有多副本,每一组副本,称为一个 Raft Group。每个 Raft Group 中由 Leader 负责执行这块数据的读 & 写(TiDB 支持 [Follower-Read](/follower-read.md))。Leader 会自动地被 PD 组件均匀调度在不同的物理节点上,用以均分读写压力。
diff --git a/best-practices/index-management-best-practices.md b/best-practices/index-management-best-practices.md
new file mode 100644
index 000000000000..a8a31084052b
--- /dev/null
+++ b/best-practices/index-management-best-practices.md
@@ -0,0 +1,320 @@
+---
+title: 管理索引和识别未使用索引的最佳实践
+summary: 了解在 TiDB 中管理和优化索引、识别并移除未使用索引的最佳实践。
+aliases: ['/zh/tidb/stable/index-management-best-practices/','/zh/tidb/dev/index-management-best-practices/']
+---
+
+# 管理索引和识别未使用索引的最佳实践
+
+索引对于优化数据库查询性能至关重要,能够减少大规模数据扫描的需求。然而,随着应用的演进、业务逻辑的变化以及数据规模的增长,原有的索引设计也可能会遇到问题,包括以下两类:
+
+- 未使用索引:这些索引曾经有用,但现在查询优化器已不再选择它们,却仍占用存储空间,并给写入操作带来不必要的开销。
+- 低效索引:某些索引虽然被优化器使用,但扫描的数据量远超预期,导致磁盘 I/O 增加,查询速度变慢。
+
+如果不及时处理,这些索引问题会导致存储成本上升、性能下降和运维效率降低。在 TiDB 这样的分布式 SQL 数据库中,索引效率低下的影响更大,因为分布式查询规模大且多节点协同更复杂。因此,定期进行索引审计对于保持数据库优化至关重要。
+
+主动识别并优化索引有助于:
+
+- 降低存储开销:移除未使用索引可释放磁盘空间,降低长期存储成本。
+- 提升写入性能:写密集型场景(如 `INSERT`、`UPDATE`、`DELETE`)下,移除不必要的索引维护可以提升性能。
+- 优化查询执行:高效的索引能够减少扫描的行数,从而加快查询速度、缩短响应时间。
+- 简化数据库管理:减少并优化索引可以简化备份、恢复和 schema 变更。
+
+由于索引会随着业务逻辑的变化而不断演进,定期进行索引审计已成为数据库维护的标准流程。TiDB 提供了内置的可观测性手段,帮助你安全高效地观测、评估和优化索引。
+
+TiDB v8.0.0 引入了 [`INFORMATION_SCHEMA.TIDB_INDEX_USAGE`](/information-schema/information-schema-tidb-index-usage.md) 表和 [`sys.schema_unused_indexes`](/sys-schema/sys-schema-unused-indexes.md) 表,来帮助你追踪索引使用情况,并根据运行数据做出正确判断。
+
+本文介绍如何使用观测工具检测并移除未使用或低效索引,从而提升 TiDB 的性能与稳定性。
+
+## TiDB 索引优化:数据驱动的方法
+
+索引对于查询性能至关重要,但如果没有充分分析就移除索引,可能导致意想不到的性能回退,甚至引发系统不稳定。为确保索引管理的安全性与有效性,TiDB 提供了内置的可观测性手段,支持以下操作:
+
+- 实时追踪索引使用情况:识别索引的访问频率,并判断其是否有助于性能提升。
+- 检测未使用索引:定位自数据库上次重启以来从未被使用过的索引。
+- 评估索引效率:判断索引是否能有效过滤数据,或是否导致 I/O 开销过多。
+- 安全测试索引移除:在删除索引前,可将其暂时设为不可见,确认无查询依赖该索引后再删除。
+
+TiDB 通过以下手段简化了索引优化:
+
+- `INFORMATION_SCHEMA.TIDB_INDEX_USAGE`:监控索引使用模式和查询频率。
+- `sys.schema_unused_indexes`:列出自数据库上次重启以来未被使用过的索引。
+- 不可见索引:在永久删除索引之前,你可以先测试移除索引的影响。
+
+借助这些可观测性工具,你可以放心清理冗余索引,避免性能下降风险。
+
+## 使用 `TIDB_INDEX_USAGE` 追踪索引使用情况
+
+从 [TiDB v8.0.0](/releases/release-8.0.0.md) 开始,你可以使用 `TIDB_INDEX_USAGE` 系统表实时观测索引使用情况,帮助你优化查询性能并移除不必要的索引。
+
+具体来说,你可以通过 `TIDB_INDEX_USAGE` 进行以下操作:
+
+- 检测未使用索引:识别未被查询访问过的索引,帮助判断哪些索引可以安全移除。
+- 分析索引效率:追踪索引使用频率,评估其是否有助于提升查询执行效率。
+- 评估查询模式:了解索引对读操作、数据扫描和 KV 请求的影响。
+
+从 [TiDB v8.4.0](/releases/release-8.4.0.md) 开始,`TIDB_INDEX_USAGE` 还包含聚簇表的主键,进一步提升了索引性能可见性。
+
+### `TIDB_INDEX_USAGE` 关键指标
+
+如需查看 `TIDB_INDEX_USAGE` 系统表字段,可执行以下 SQL 语句:
+
+```sql
+USE INFORMATION_SCHEMA;
+DESC TIDB_INDEX_USAGE;
+```
+
+```sql
++--------------------------+-------------+------+------+---------+-------+
+| Field | Type | Null | Key | Default | Extra |
++--------------------------+-------------+------+------+---------+-------+
+| TABLE_SCHEMA | varchar(64) | YES | | NULL | |
+| TABLE_NAME | varchar(64) | YES | | NULL | |
+| INDEX_NAME | varchar(64) | YES | | NULL | |
+| QUERY_TOTAL | bigint(21) | YES | | NULL | |
+| KV_REQ_TOTAL | bigint(21) | YES | | NULL | |
+| ROWS_ACCESS_TOTAL | bigint(21) | YES | | NULL | |
+| PERCENTAGE_ACCESS_0 | bigint(21) | YES | | NULL | |
+| PERCENTAGE_ACCESS_0_1 | bigint(21) | YES | | NULL | |
+| PERCENTAGE_ACCESS_1_10 | bigint(21) | YES | | NULL | |
+| PERCENTAGE_ACCESS_10_20 | bigint(21) | YES | | NULL | |
+| PERCENTAGE_ACCESS_20_50 | bigint(21) | YES | | NULL | |
+| PERCENTAGE_ACCESS_50_100 | bigint(21) | YES | | NULL | |
+| PERCENTAGE_ACCESS_100 | bigint(21) | YES | | NULL | |
+| LAST_ACCESS_TIME | datetime | YES | | NULL | |
++--------------------------+-------------+------+------+---------+-------+
+共 14 行
+```
+
+关于这些列的详细说明,参见 [`TIDB_INDEX_USAGE`](/information-schema/information-schema-tidb-index-usage.md)。
+
+### 利用 `TIDB_INDEX_USAGE` 识别未使用和低效索引
+
+本节介绍如何利用 `TIDB_INDEX_USAGE` 系统表识别未使用和低效索引。
+
+- 未使用索引:
+
+ - 如果 `QUERY_TOTAL = 0`,说明该索引未被任何查询使用。
+ - 如果 `LAST_ACCESS_TIME` 显示的时间距今较久,说明该索引可能已无用。
+
+- 低效索引:
+
+ - 如果 `PERCENTAGE_ACCESS_100` 数值较大,说明存在全索引扫描,可能为低效索引。
+ - 对比 `ROWS_ACCESS_TOTAL` 与 `QUERY_TOTAL`,判断索引在查询中扫描的行数是否过多。
+
+通过 `TIDB_INDEX_USAGE` 系统表,你可以详细了解索引性能,以便移除冗余索引、优化查询执行。
+
+### 高效使用 `TIDB_INDEX_USAGE`
+
+以下要点可以帮助你正确理解并使用 `TIDB_INDEX_USAGE` 系统表。
+
+#### 数据更新存在延迟
+
+为降低性能影响,`TIDB_INDEX_USAGE` 的数据并非实时更新,索引使用指标可能会有最多 5 分钟的延迟。在分析查询时,需要考虑这一延迟。
+
+#### 索引使用数据不持久化
+
+`TIDB_INDEX_USAGE` 系统表的数据存储在每个 TiDB 实例的内存中,不会持久化,在节点重启后数据会丢失。
+
+#### 跟踪历史数据
+
+你可以定期使用以下 SQL 语句导出索引使用快照:
+
+```sql
+SELECT * FROM INFORMATION_SCHEMA.TIDB_INDEX_USAGE INTO OUTFILE '/backup/index_usage_snapshot.csv';
+```
+
+通过比较不同时间的快照,可以进行历史追踪,帮助你发现索引使用趋势,从而做出更有依据的索引优化或清理决策。
+
+## 使用 `CLUSTER_TIDB_INDEX_USAGE` 汇总全集群索引数据
+
+由于 TiDB 是分布式 SQL 数据库,查询负载会分布于多个节点。每个 TiDB 节点独立追踪本地索引使用情况。为获得全局索引性能,TiDB 提供了 [`CLUSTER_TIDB_INDEX_USAGE`](/information-schema/information-schema-tidb-index-usage.md#cluster_tidb_index_usage) 系统表,汇总了所有节点的索引使用数据,确保在优化索引策略时充分考虑分布式查询负载。
+
+不同 TiDB 节点的查询负载可能不同。某个索引在部分节点看似未被使用,但在其他节点可能仍然至关重要。如果要按查询负载对索引分析进行划分,执行以下 SQL 语句:
+
+```sql
+SELECT INSTANCE, TABLE_NAME, INDEX_NAME, SUM(QUERY_TOTAL) AS total_queries
+FROM INFORMATION_SCHEMA.CLUSTER_TIDB_INDEX_USAGE
+GROUP BY INSTANCE, TABLE_NAME, INDEX_NAME
+ORDER BY total_queries DESC;
+```
+
+这样可以帮助判断一个索引是在所有节点上都未被使用,还是仅在特定节点未被使用,从而帮助你在删除索引时做出更明智的决策。
+
+### `TIDB_INDEX_USAGE` 与 `CLUSTER_TIDB_INDEX_USAGE` 的区别
+
+`TIDB_INDEX_USAGE` 与 `CLUSTER_TIDB_INDEX_USAGE` 的区别如下表所示:
+
+| 功能 | `TIDB_INDEX_USAGE` | `CLUSTER_TIDB_INDEX_USAGE` |
+| -------------- | ----------------------------------------- | -------------------------------------------- |
+| 作用范围 | 追踪单个数据库实例内的索引使用情况 | 汇总整个 TiDB 集群的索引使用情况 |
+| 索引追踪 | 数据为本地实例级 | 提供集群级统一视图 |
+| 主要用途 | 调试数据库实例级的索引使用情况 | 分析全局索引模式及多节点行为 |
+
+### 高效使用 `CLUSTER_TIDB_INDEX_USAGE`
+
+由于 `CLUSTER_TIDB_INDEX_USAGE` 系统表汇总了多个节点的数据,使用时需注意以下事项:
+
+- 数据更新存在延迟
+
+ 为将对性能的影响降到最低,`CLUSTER_TIDB_INDEX_USAGE` 不会实时更新。索引使用指标可能会有最多 5 分钟的延迟。在分析查询时,需要考虑这一延迟。
+
+- 内存存储
+
+ 与 `TIDB_INDEX_USAGE` 一样,在节点重启后,储存在内存中的索引使用数据会丢失。
+
+通过 `CLUSTER_TIDB_INDEX_USAGE`,可获得全局视角的索引行为,确保索引策略与分布式查询负载匹配。
+
+## 使用 `schema_unused_indexes` 快速识别未使用索引
+
+手动分析索引使用数据可能会非常耗时。为简化该过程,TiDB 提供了 [`schema_unused_indexes`](/sys-schema/sys-schema-unused-indexes.md) 系统视图,用于列出自数据库上次重启以来未被使用过的索引。
+
+使用该视图,你可以:
+
+- 快速识别不再使用的索引,降低不必要的存储成本。
+- 通过移除无用索引,加速 DML 操作(如 `INSERT`、`UPDATE`、`DELETE`)。
+- 无需手动分析查询模式,简化索引审计。
+
+通过使用 `schema_unused_indexes`,你可以快速识别不必要的索引,轻松降低数据库开销。
+
+### `schema_unused_indexes` 的工作原理
+
+`schema_unused_indexes` 视图基于 `TIDB_INDEX_USAGE`,可以自动筛选出自上次 TiDB 重启以来查询次数为零的索引。
+
+查询未使用索引:
+
+```sql
+SELECT * FROM sys.schema_unused_indexes;
+```
+
+返回类似如下结果:
+
+```
++-----------------+---------------+--------------------+
+| object_schema | object_name | index_name |
++---------------- + ------------- + -------------------+
+| bookshop | users | nickname |
+| bookshop | ratings | uniq_book_user_idx |
++---------------- + ------------- + -------------------+
+```
+
+### 使用 `schema_unused_indexes` 的注意事项
+
+使用 `schema_unused_indexes` 时,需注意以下事项。
+
+#### 仅统计自上次重启以来的未使用索引
+
+- 如果 TiDB 节点重启,索引使用数据会被重置。
+- 在使用索引数据之前,确保系统已经运行了足够长的时间,以便捕获具有代表性的业务负载。
+
+#### 并非所有未使用索引都可立即删除
+
+有些索引可能使用频率很低,但对于特定查询、批处理或报表任务仍然至关重要。在删除索引之前,请考虑它是否支持以下场景:
+
+- 低频但关键的查询,如月度报表、分析任务
+- 非每日运行的批处理作业
+- 临时排查故障用的查询
+
+如果索引在重要但不频繁的查询中出现,建议先保留或设为不可见。
+
+你可以使用[不可见索引](#使用不可见索引安全测试索引移除)来安全地验证某个索引是否可以删除,而不会影响系统性能。
+
+### 手动创建 `schema_unused_indexes` 视图
+
+对于从较早版本升级到 TiDB v8.0.0 或更高版本的集群,需要手动创建系统 schema 及相关视图。
+
+详见[手动创建 `schema_unused_indexes` 视图](/sys-schema/sys-schema-unused-indexes.md#手动创建-schema_unused_indexes-视图)。
+
+## 使用不可见索引安全测试索引移除
+
+在未经充分验证的情况下直接删除索引可能带来性能风险,尤其是那些虽不常用但对特定查询仍至关重要的索引。
+
+为降低风险,TiDB 提供了不可见索引,可以临时禁用索引但不删除。通过使用不可见索引,你可以安全地验证索引删除决策,确保数据库优化过程更加可控和可预测。
+
+### 什么是不可见索引?
+
+不可见索引仍然存在于数据库中,但 TiDB 优化器会忽略它。你可以使用 [`ALTER TABLE ... INVISIBLE`](/sql-statements/sql-statement-alter-table.md) 将索引设为不可见,从而在不永久删除索引的情况下测试该索引是否真的无用。
+
+不可见索引的主要优势如下:
+
+- **安全测试索引**:查询将不再使用该索引,但相关的优化器统计信息仍然会被维护,必要时可随时快速恢复。
+- **不影响索引存储**:索引结构未变,无需重新创建,避免额外开销。
+- **性能监控**:数据库管理员可观察禁用索引后的查询表现,辅助决策。
+
+### 设置索引为不可见
+
+要在不删除索引的情况下使其不可见,可执行以下 SQL 语句:
+
+```sql
+ALTER TABLE bookshop.users ALTER INDEX nickname INVISIBLE;
+```
+
+设置索引为不可见后,观察系统的查询性能:
+
+- 如果性能保持不变,说明该索引可能不必要,可以安全删除。
+- 如果查询延迟增加,说明该索引可能仍有必要保留。
+
+### 高效使用不可见索引
+
+- **建议在业务低峰期测试**:便于在可控环境中监控对性能的影响。
+- **结合查询监控工具**:对比分析索引可见与不可见时的执行计划。
+- **在多种业务场景进行验证**:确保索引不被特定报表或定时任务依赖。
+
+### 不可见索引建议保留多久?
+
+- OLTP 负载:建议至少观察一周,覆盖日常波动。
+- 批处理或 ETL 负载:建议覆盖一个完整的报表周期,如月度财务报表。
+- 临时分析查询:结合查询日志确认不依赖该索引后再删除。
+
+安全起见,建议至少保持索引在一个完整业务周期内处于不可见状态,以确保所有工作负载都已经过验证,再做最终决定。
+
+## 索引优化的五大最佳实践
+
+为了保持高性能和高效的资源利用,定期进行索引优化是数据库运维的常规工作。以下是 TiDB 中有效管理索引的最佳实践:
+
+1. **定期监控索引使用。**
+
+ - 使用 [`TIDB_INDEX_USAGE`](/information-schema/information-schema-tidb-index-usage.md) 和 [`CLUSTER_TIDB_INDEX_USAGE`](/information-schema/information-schema-tidb-index-usage.md#cluster_tidb_index_usage) 追踪索引使用情况。
+ - 通过 [`schema_unused_indexes`](/sys-schema/sys-schema-unused-indexes.md) 识别未使用的索引,并评估是否可删除。
+ - 监控查询执行计划,识别可能导致高 I/O 的低效索引。
+
+2. **在删除索引前,务必进行验证。**
+
+ - 使用 [`ALTER TABLE ... INVISIBLE`](/sql-statements/sql-statement-alter-table.md) 将索引设为不可见,临时禁用索引,观察影响后再决定是否永久删除。
+ - 若查询性能保持稳定,可考虑删除索引。
+ - 确保有足够的观察周期,以覆盖所有业务场景或查询模式后再做最终决策。
+
+3. **优化现有索引。**
+
+ - 合并冗余索引。合并冗余索引可以减少存储开销、提升写入性能。如果多个索引服务于相似的查询,可以考虑将它们合并为单个更高效的复合索引。
+
+ - 执行以下 SQL 语句,查找前缀重叠的索引(表明可能存在冗余):
+
+ ```sql
+ SELECT TABLE_SCHEMA, TABLE_NAME, INDEX_NAME, COLUMN_NAME, SEQ_IN_INDEX
+ FROM INFORMATION_SCHEMA.STATISTICS
+ WHERE TABLE_NAME = 'your_table'
+ ORDER BY TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, SEQ_IN_INDEX;
+ ```
+
+ - 若两个索引的前导列相同,建议考虑将它们合并为复合索引。
+
+ - 提高选择性。可以通过以下方式优化低选择性索引(即那些过滤行数过多的索引):
+
+ - 增加额外的列,以提升过滤效率。
+ - 调整索引结构(如前缀索引、复合索引)。
+
+ - 分析索引选择性。利用 `TIDB_INDEX_USAGE` 的 `PERCENTAGE_ACCESS_*` 字段评估索引过滤数据的效果。
+
+4. **关注 DML 性能影响。**
+
+ - 避免过度索引。每增加一个索引,`INSERT`、`UPDATE` 和 `DELETE` 操作的开销都会增加。
+ - 仅为查询所必需的字段建立索引,以减少写入密集型负载的维护成本。
+
+5. **定期测试与调优。**
+
+ - 定期进行索引审计,尤其在业务负载发生重大变化后。
+ - 利用 TiDB 执行计划分析工具,验证索引是否被高效使用。
+ - 新增索引时,建议先在隔离环境中测试,避免出现意外的性能回退。
+
+通过遵循以上这些最佳实践,你可以确保查询高效执行,减少不必要的存储开销,并保持数据库性能最优。
diff --git a/best-practices/massive-regions-best-practices.md b/best-practices/massive-regions-best-practices.md
index afc4d6748e26..eb8d996fc21b 100644
--- a/best-practices/massive-regions-best-practices.md
+++ b/best-practices/massive-regions-best-practices.md
@@ -1,7 +1,7 @@
---
title: 海量 Region 集群调优最佳实践
summary: 了解海量 Region 导致性能问题的原因和优化方法。
-aliases: ['/docs-cn/dev/best-practices/massive-regions-best-practices/','/docs-cn/dev/reference/best-practices/massive-regions/']
+aliases: ['/docs-cn/dev/best-practices/massive-regions-best-practices/','/docs-cn/dev/reference/best-practices/massive-regions/','/zh/tidb/stable/massive-regions-best-practices/','/zh/tidb/dev/massive-regions-best-practices/']
---
# 海量 Region 集群调优最佳实践
@@ -146,7 +146,7 @@ Region 的默认大小为 256 MiB,将其调大可以减少 Region 个数,详
### 方法七:提高 Raft 通信的的最大连接数
-TiKV 节点间用于 Raft 通信的最大连接数默认为 1,将其调大可以减少因为海量 Region 通信量过大而导致的阻塞情况。具体的配置说明可以参考 [`grpc-raft-conn-num`](/tikv-configuration-file.md#grpc-raft-conn-num)。
+TiKV 节点间用于 Raft 通信的最大连接数可以通过 [`server.grpc-raft-conn-num`](/tikv-configuration-file.md#grpc-raft-conn-num) 配置项调整,将其值调大可以减少因为海量 Region 通信量过大而导致的阻塞情况。
> **注意:**
>
diff --git a/best-practices/multi-column-index-best-practices.md b/best-practices/multi-column-index-best-practices.md
new file mode 100644
index 000000000000..1ee1d1d3ebff
--- /dev/null
+++ b/best-practices/multi-column-index-best-practices.md
@@ -0,0 +1,264 @@
+---
+title: 多列索引优化最佳实践
+summary: 了解如何在 TiDB 中高效使用多列索引,并应用高级优化技巧。
+aliases: ['/zh/tidb/stable/multi-column-index-best-practices/','/zh/tidb/dev/multi-column-index-best-practices/']
+---
+
+# 多列索引优化最佳实践
+
+在当今数据驱动的世界中,高效处理大数据集上的复杂查询对于保持应用响应和性能至关重要。对于 TiDB 这样专为高规模、高需求环境设计的分布式 SQL 数据库来说,优化数据访问路径是实现高效查询的关键。
+
+索引是提升查询性能的重要工具,可以避免全表扫描。TiDB 的查询优化器能够利用多列索引 (Multi-Column Indexes) 智能过滤数据,处理复杂的查询条件,这在传统数据库(如 MySQL)中往往难以实现。
+
+本文将介绍多列索引的工作原理、重要性,以及 TiDB 如何将复杂的查询条件优化为高效的数据访问路径。通过这些优化,即使在大规模场景下,你也能获得更快的响应速度、最小化的表扫描,以及更流畅的性能。
+
+如果没有这些优化,大型 TiDB 数据库中的查询性能可能会迅速下降。全表扫描和低效过滤会让毫秒级的查询变成分钟级,内存消耗过大还可能导致内存溢出 (Out of Memory, OOM) 错误,尤其是在资源受限的环境下。TiDB 的针对性优化方式确保只访问相关数据,从而保持低延迟和高效的内存使用,即使面对最复杂的查询也能应对自如。
+
+## 前提条件
+
+- 多列索引功能在 TiDB v8.3.0 及以上版本可用。
+- 使用该功能前,需将[优化器 Fix Control **54337**](/optimizer-fix-controls.md#54337-从-v830-版本开始引入) 设置为 `ON`。
+
+## 背景:多列索引
+
+本文以一个租房信息表为例,每条记录包含唯一 ID、城市、卧室数、租金和可入住日期:
+
+```sql
+CREATE TABLE listings (
+ listing_id INT PRIMARY KEY AUTO_INCREMENT,
+ city VARCHAR(100) NOT NULL,
+ bedrooms INT NOT NULL,
+ price DECIMAL(10, 2) NOT NULL,
+ availability_date DATE NOT NULL
+);
+```
+
+假设该表在全中国有 2000 万条房源。如果你想查找租金低于 2000 元的房源,可以在 `price` 列上建索引。这样优化器只需扫描 `[-inf, 2000.00)` 范围的数据,假设 70% 房源高于 2000 元,实际扫描量约为 1400 万行。执行计划如下:
+
+```sql
+-- 查询 1:查找租金低于 2000 的房源
+EXPLAIN FORMAT = "brief" SELECT * FROM listings WHERE price < 2000;
+```
+
+```
++-----------------------------+---------+----------------------------------------------+---------------------------+
+| id | task | access object | operator info |
++-----------------------------+---------+----------------------------------------------+---------------------------+
+| IndexLookUp | root | | |
+| ├─IndexRangeScan(Build) | root | table: listings, index: price_idx(price) | range: [-inf, 2000.00) |
+| └─TableRowIDScan(Probe) | root | table: listings | |
++-----------------------------+---------+----------------------------------------------+---------------------------+
+```
+
+虽然这样能提升性能,但返回的结果仍然数量庞大。若你需要更精确的房源,可以增加过滤条件,如指定城市、卧室数和最高租金。例如,查找北京两居室且租金低于 2000 元的房源,结果会大大缩小,可能只剩几十条。
+
+为优化此查询,可以在 `city`、`bedrooms` 和 `price` 上创建一个多列索引:
+
+```sql
+CREATE INDEX idx_city_bedrooms_price ON listings (city, bedrooms, price);
+```
+
+SQL 中的多列索引按字典序排序。以 `(city, bedrooms, price)` 为例,数据先按 `city` 排序,再在每个 `city` 内按 `bedrooms` 排序,最后在每个 `(city, bedrooms)` 内按 `price` 排序。这样 TiDB 能高效利用每个条件:
+
+1. 先按 `city` 过滤;
+2. 再按 `bedrooms` 过滤;
+3. 最后按 `price` 过滤。
+
+## 示例数据
+
+下表展示了多列索引如何细化搜索结果:
+
+| City | Bedrooms| Price |
+| -------- | ------- | ------|
+| Beijing | 1 | 1000 |
+| Beijing | 1 | 1500 |
+| Beijing | 2 | 1000 |
+| Beijing | 2 | 1500 |
+| Beijing | 3 | 2500 |
+| Beijing | 3 | 3000 |
+| Shanghai | 1 | 1000 |
+| Shanghai | 1 | 1500 |
+| Shanghai | 2 | 1000 |
+| Shanghai | 2 | 2500 |
+| Shanghai | 3 | 1000 |
+| Shanghai | 3 | 2500 |
+
+## 优化查询与结果
+
+利用多列索引,TiDB 能高效定位北京两居室且租金低于 2000 元的房源:
+
+```sql
+-- 查询 2:查找北京两居室且租金低于 2000 的房源
+EXPLAIN FORMAT = "brief"
+ SELECT * FROM listings
+ WHERE city = 'Beijing' AND bedrooms = 2 AND price < 2000;
+```
+
+```
++------------------------+------+---------------------------------------------------------------------------------------------+---------------------------------+
+| id | task | access object | operator info |
++------------------------+------+---------------------------------------------------------------------------------------------+---------------------------------+
+| IndexLookUp | root | | |
+| ├─IndexRangeScan(Build)| root |table:listings,index:idx_city_bedrooms_price ["Beijing" 2 -inf,(city, bedrooms, price)]|range:["Beijing" 2 2000.00)|
+| └─TableRowIDScan(Probe)| root |table:listings | |
++------------------------+------+---------------------------------------------------------------------------------------------+---------------------------------+
+```
+
+该查询在示例数据中返回:
+
+| City | Bedrooms| Price |
+| -------------- | ------- | ------ |
+| Beijing | 2 | 1000 |
+| Beijing | 2 | 1500 |
+
+通过多列索引,TiDB 避免了不必要的行扫描,大幅提升查询性能。
+
+## 索引范围推导 (Index Range Derivation)
+
+TiDB 优化器内置了强大的范围推导组件。该组件会根据查询条件和相关索引列,生成高效的索引范围,并传递给表访问组件,来决定最优的数据访问方式。
+
+对于查询中的每个表,表访问组件会评估所有可用索引,以确定最佳的访问方式,无论是全表扫描还是索引扫描。它会计算每个相关索引的范围,评估访问代价,选择代价最低的路径。这一过程结合了范围推导和代价评估,确保数据检索既高效又节省资源。
+
+下图展示了 TiDB 如何通过范围推导和代价评估协同工作,以选择最优的表访问路径:
+
+
+
+多列过滤条件往往比上述示例更复杂,可能包含 **AND**、**OR** 或两者组合。TiDB 的范围推导子系统能高效处理这些情况,生成最具选择性或最有效的索引范围。
+
+一般来说,该子系统会对 **OR** 条件生成的范围执行 **UNION** 操作,对 **AND** 条件生成的范围执行 **INTERSECT** 操作。通过这种方式,TiDB 即使在面对复杂的过滤逻辑时,也能尽可能精确地筛选数据。
+
+## 多列索引中的析取条件(`OR` 条件)
+
+当查询中包含 `OR` 条件(Disjunctive Predicates,析取谓词)时,优化器会分别处理每个条件,为每部分生成范围。如果范围有重叠,则合并为一个连续范围;否则保留为多个独立范围,均可用于索引扫描。
+
+### 示例 1:重叠范围
+
+假设要查找杭州两居室,租金在以下两个重叠区间的房源:
+
+- 租金在 1000~2000 元之间
+- 租金在 1500~2500 元之间
+
+优化器会将两个区间合并为 1000 ~ 2500。查询及执行计划如下:
+
+```sql
+-- 查询 3:重叠租金区间
+EXPLAIN FORMAT = "brief"
+ SELECT * FROM listings
+ WHERE (city = 'Hangzhou' AND bedrooms = 2 AND price >= 1000 AND price < 2000)
+ OR (city = 'Hangzhou' AND bedrooms = 2 AND price >= 1500 AND price < 2500);
+```
+
+```
++-------------------------+------+----------------------------------------------------------------------+--------------------------------------------------+
+| id | task | access object | operator info |
++-------------------------+------+----------------------------------------------------------------------+--------------------------------------------------+
+| IndexLookUp | root | | |
+| ├─IndexRangeScan(Build) | root | table:listings,index:idx_city_bedrooms_price(city, bedrooms, price) | range:["Hangzhou" 2 1000.00,"Hangzhou" 2 2500.00)|
+| └─TableRowIDScan(Probe) | root | table:listings | |
++-------------------------+------+----------------------------------------------------------------------+--------------------------------------------------+
+```
+
+### 示例 2:不重叠范围
+
+再比如查找北京或上海的一居室,分别在不同租金区间:
+
+- 北京一居室,租金 1500 ~ 2500
+- 上海一居室,租金 1000 ~ 1500
+
+由于区间不重叠,执行计划中会保留两个独立范围:
+
+```sql
+-- 查询 4:不同城市的不重叠区间
+
+EXPLAIN FORMAT = "brief"
+ SELECT * FROM listings
+ WHERE
+ (city = 'Beijing' AND bedrooms = 1 AND price >= 1500 AND price < 2500)
+ OR (city = 'Shanghai' AND bedrooms = 1 AND price >= 1000 AND price < 1500);
+```
+
+```
++-------------------------+------+--------------------------------------------------------------------+------------------------------------------------------------+
+| id | task | access object | operator info |
++-------------------------+------+--------------------------------------------------------------------+------------------------------------------------------------+
+| IndexLookUp | root | | |
+| ├─IndexRangeScan(Build) | root | table:listings,index:idx_city_bedrooms_price(city, bedrooms, price)| range:["Beijing" 1 1500.00,"Beijing" 1 2500.00) ["Shanghai" 1 1000, "Shanghai" 1 1500) |
+| └─TableRowIDScan(Probe) | root | table:listings | |
++-------------------------+------+--------------------------------------------------------------------+------------------------------------------------------------+
+```
+
+通过合并或保留独立范围,优化器能高效利用索引处理 `OR` 条件,避免无谓扫描,提升性能。
+
+## 多列索引中的合取条件(`AND` 条件)
+
+对于 **AND** 条件(合取条件),TiDB 优化器会为每个条件生成范围,并取其交集 (`INTERSECT`),得到最精确的索引访问范围。如果某条件包含多个范围,TiDB 会组合这些范围,确保结果最优。
+
+### 示例 1:表结构
+
+假设有如下表 t1:
+
+```sql
+CREATE TABLE t1 (
+ a1 INT,
+ b1 INT,
+ c1 INT,
+ KEY iab (a1,b1)
+);
+```
+
+有如下查询条件:
+
+```sql
+(a1, b1) > (1, 10) AND (a1, b1) < (10, 20)
+```
+
+该查询涉及多列比较,TiDB 优化器的处理步骤如下:
+
+1. 拆解表达式。
+
+ - `(a1, b1) > (1, 10)` 转换为 `(a1 > 1) OR (a1 = 1 AND b1 > 10)`,表示包括所有 `a1` 大于 `1` 的情况,或 `a1` 等于 `1` 且 `b1` 大于 `10` 的情况。
+ - `(a1, b1) < (10, 20)` 转换为 `(a1 < 10) OR (a1 = 10 AND b1 < 20)`,表示包括所有 `a1` 小于 `10` 的情况,或 `a1` 等于 `10` 且 `b1` 小于 `20` 的情况。
+
+ 合并后为:
+
+ ```sql
+ ((a1 > 1) OR (a1 = 1 AND b1 > 10)) AND ((a1 < 10) OR (a1 = 10 AND b1 < 20))
+ ```
+
+2. 推导并组合范围。
+
+ - `(a1, b1) > (1, 10)`:推导出的范围包括 `(1, +inf]`(`a1 > 1` 的情况)和 `(1, 10, 1, +inf]`(`a1 = 1` 且 `b1 > 10` 的情况)。
+ - `(a1, b1) < (10, 20)`:推导出的范围包括 `[-inf, 10)`(`a1 < 10` 的情况)和 `[10, -inf, 10, 20)`(`a1 = 10` 且 `b1 < 20` 的情况)。
+
+ 组合范围后,最终的索引范围为 `(1, 10, 1, +inf] UNION (1, 10) UNION [10, -inf, 10, 20)`。
+
+### 示例 2:查询计划
+
+查询计划如下:
+
+```sql
+-- 查询 5:多列合取条件
+EXPLAIN FORMAT = "brief"
+ SELECT * FROM t1
+ WHERE (a1, b1) > (1, 10) AND (a1, b1) < (10, 20);
+```
+
+```
++-------------------------+------+----------------------------+-------------------------------------------+
+| id | task | access object | operator info |
++-------------------------+------+----------------------------+-------------------------------------------+
+| IndexLookUp | root | | |
+| ├─IndexRangeScan(Build) | root | table:t1,index:iab(a1, b1) | range:(1 10,1 +inf],(1,10)[10 -inf,10 20) |
+| └─TableRowIDScan(Probe) | root | table:t1 | |
++-------------------------+------+----------------------------+-------------------------------------------+
+```
+
+假设表有 5 亿行,通过优化后只需访问约 4000 行,仅占总数据的 0.0008%。查询延迟从两分钟降至几毫秒。
+
+与 MySQL 需全表扫描不同,TiDB 优化器可高效处理复杂行表达式,充分利用推导范围。
+
+## 总结
+
+TiDB 优化器通过多列索引和高级范围推导,可大幅降低复杂 SQL 查询的数据访问代价。无论是合取 (`AND`) 还是析取 (`OR`) 条件,TiDB 都能将行表达式转化为最优访问路径,缩短查询时间,提升性能。与 MySQL 不同,TiDB 支持多列索引上的并集与交集操作,能高效处理复杂过滤条件。在实际应用中,优化后查询可在几毫秒内完成,而未优化时可能需两分钟以上,极大降低了延迟。
+
+更多 TiDB 与 MySQL 架构差异及其对可扩展性、可靠性和 HTAP 工作负载的影响,详见 [MySQL vs. TiDB: A Guide to Open Source Database Selection](https://www.pingcap.com/ebook-whitepaper/tidb-vs-mysql-product-comparison-guide/)。
diff --git a/best-practices/pd-scheduling-best-practices.md b/best-practices/pd-scheduling-best-practices.md
index 2b9681d151c0..286860e8270c 100644
--- a/best-practices/pd-scheduling-best-practices.md
+++ b/best-practices/pd-scheduling-best-practices.md
@@ -1,7 +1,7 @@
---
title: PD 调度策略最佳实践
summary: 了解 PD 调度策略的最佳实践和调优方式
-aliases: ['/docs-cn/dev/best-practices/pd-scheduling-best-practices/','/docs-cn/dev/reference/best-practices/pd-scheduling/']
+aliases: ['/docs-cn/dev/best-practices/pd-scheduling-best-practices/','/docs-cn/dev/reference/best-practices/pd-scheduling/','/zh/tidb/stable/pd-scheduling-best-practices/','/zh/tidb/dev/pd-scheduling-best-practices/']
---
# PD 调度策略最佳实践
@@ -254,7 +254,7 @@ PD 的打分机制决定了一般情况下,不同 Store 的 Leader Count 和 R
- 从 PD 的统计来看没有热点,但是从 TiKV 的相关 Metrics 可以看出部分节点负载明显高于其他节点,成为整个系统的瓶颈。这是因为目前 PD 统计热点 Region 的维度比较单一,仅针对流量进行分析,在某些场景下无法准确定位热点。例如部分 Region 有大量的点查请求,从流量上来看并不显著,但是过高的 QPS 导致关键模块达到瓶颈。
- **解决方法**:首先从业务层面确定形成热点的 table,然后添加 `scatter-range-scheduler` 调度器使这个 table 的所有 Region 均匀分布。TiDB 也在其 HTTP API 中提供了相关接口来简化这个操作,具体可以参考 [TiDB HTTP API](https://github.com/pingcap/tidb/blob/master/docs/tidb_http_api.md) 文档。
+ **解决方法**:首先从业务层面确定形成热点的 table,然后添加 `scatter-range-scheduler` 调度器使这个 table 的所有 Region 均匀分布。TiDB 也在其 HTTP API 中提供了相关接口来简化这个操作,具体可以参考 [TiDB HTTP API](https://github.com/pingcap/tidb/blob/release-8.5/docs/tidb_http_api.md) 文档。
### Region Merge 速度慢
@@ -297,7 +297,9 @@ Region Merge 速度慢也很有可能是受到 limit 配置的限制(`merge-sc
实践中,如果能确定这个节点的故障是不可恢复的,可以立即做下线处理,这样 PD 能尽快补齐副本,降低数据丢失的风险。与之相对,如果确定这个节点是能恢复的,但可能半小时之内来不及,则可以把 `max-store-down-time` 临时调整为比较大的值,这样能避免超时之后产生不必要的副本补充,造成资源浪费。
-自 v5.2.0 起,TiKV 引入了慢节点检测机制。通过对 TiKV 中的请求进行采样,计算出一个范围在 1~100 的分数。当分数大于等于 80 时,该 TiKV 节点会被设置为 slow 状态。可以通过添加 [`evict-slow-store-scheduler`](/pd-control.md#scheduler-show--add--remove--pause--resume--config--describe) 来针对慢节点进行对应的检测和调度。当检测到有且只有一个 TiKV 节点为慢节点,并且该 TiKV 的 slow score 到达限定值(默认 80)时,将节点上的 Leader 驱逐(其作用类似于 `evict-leader-scheduler`)。
+自 v5.2.0 起,TiKV 引入了磁盘的慢节点检测机制。通过对 TiKV 中的请求进行采样,计算出一个范围在 1~100 的分数。当分数大于等于 80 时,该 TiKV 节点会被设置为 slow 状态。可以通过添加 [`evict-slow-store-scheduler`](/pd-control.md#scheduler-show--add--remove--pause--resume--config--describe) 来针对慢节点进行对应的调度。当检测到有且只有一个 TiKV 节点为慢节点,并且该 TiKV 的 slow score 到达限定值(默认 80)时,将节点上的 Leader 驱逐(其作用类似于 `evict-leader-scheduler`)。
+
+自 v8.5.5 起,TiKV 引入了网络的慢节点检测机制。与磁盘慢节点检测类似,该机制通过在 TiKV 节点之间进行网络延时探测并计算分数,来判断节点的网络是否出现异常。可以通过 [`enable-network-slow-store`](/pd-control.md#scheduler-config-evict-slow-store-scheduler) 来开启该机制(默认关闭)。
> **注意:**
>
diff --git a/best-practices/readonly-nodes.md b/best-practices/readonly-nodes.md
index c43f1fbb3093..5d857ccf01e0 100644
--- a/best-practices/readonly-nodes.md
+++ b/best-practices/readonly-nodes.md
@@ -1,6 +1,7 @@
---
title: 只读存储节点最佳实践
summary: 介绍如何通过使用只读存储节点,达到物理隔离部分流量的目的。
+aliases: ['/zh/tidb/stable/readonly-nodes/','/zh/tidb/dev/readonly-nodes/']
---
# 只读存储节点最佳实践
@@ -115,15 +116,7 @@ tikv_servers:
set tidb_replica_read=learner;
```
-#### 3.2 在 TiSpark 中使用 Follower Read
-
-你可以在 Spark 配置文件中设置 `spark.tispark.replica_read = learner` 来读取只读节点上的数据:
-
-```
-spark.tispark.replica_read learner
-```
-
-#### 3.3 在备份集群数据时只备份 Follower 节点
+#### 3.2 在备份集群数据时只备份 Follower 节点
你可以在 br 命令行中添加 `--replica-read-label` 参数,来读取只读节点上的数据。注意,在 shell 中运行如下命令时需使用单引号包裹 label,以防止 `$` 被 shell 解析。
diff --git a/best-practices/saas-best-practices.md b/best-practices/saas-best-practices.md
new file mode 100644
index 000000000000..59dcabc93ed8
--- /dev/null
+++ b/best-practices/saas-best-practices.md
@@ -0,0 +1,100 @@
+---
+title: SaaS 多租户场景下处理百万张表的最佳实践
+summary: 介绍 TiDB 在 SaaS (Software as a service) 多租户场景的最佳实践,特别适用于单集群表数量超过百万级别的场景。
+aliases: ['/zh/tidb/stable/saas-best-practices/','/zh/tidb/dev/saas-best-practices/']
+---
+
+# SaaS 多租户场景下处理百万张表的最佳实践
+
+本文档介绍 TiDB 在 SaaS (Software as a service) 多租户环境中的最佳实践,特别适用于**单集群表数量超过百万级别**的场景。通过合理的配置和选择,可以实现 TiDB 在 SaaS 场景下的高效稳定运行,同时降低资源消耗和成本。
+
+> **注意:**
+>
+> 推荐使用 TiDB v8.5.0 及以上版本。
+
+关于该最佳实践的实操案例,请参阅博客 [Scaling 3 Million Tables: How TiDB Powers Atlassian Forge's SaaS Platform](https://www.pingcap.com/blog/scaling-3-million-tables-how-tidb-powers-atlassian-forge-saas-platform/)。
+
+## 硬件配置建议
+
+建议使用高内存规格的 TiDB 实例,例如:
+
+- 100 万张表:使用 32 GiB 或更高内存。
+- 300 万张表:使用 64 GiB 或更高内存。
+
+高内存规格的 TiDB 实例可以为 Infoschema、Statistics 和执行计划缓存分配更多的缓存空间,提高缓存命中率,从而提升业务性能。同时,更大的内存可以缓解 TiDB GC 带来的性能波动和稳定性问题。
+
+TiKV 和 PD 推荐的硬件配置如下:
+
+* **TiKV**:8 vCPU 和 32 GiB 或更高内存。
+* **PD**:8 CPU 和 16 GiB 或更高内存。
+
+## 控制 Region 数量
+
+如果需要创建大量的表(例如 10 万张以上),建议将 TiDB 的配置 [`split-table`](/tidb-configuration-file.md#split-table) 设置为 `false`,减少集群 Region 数量,从而降低 TiKV 内存压力。
+
+## 缓存配置
+
+* 从 TiDB v8.4.0 开始,TiDB 在执行 SQL 语句时,会按需将 SQL 语句涉及的表信息加载到 Infoschema 缓存中。
+
+ * 通过 TiDB 监控中 **Schema Load** 面板下的 **Infoschema v2 Cache Size** 和 **Infoschema v2 Cache Operation** 子面板,可以查看 Infoschema 缓存的大小和命中率。
+ * 使用系统变量 [`tidb_schema_cache_size`](/system-variables.md#tidb_schema_cache_size-从-v800-版本开始引入) 可以调整 Infoschema 缓存的内存上限,以满足业务需求。Infoschema 缓存大小与执行 SQL 语句涉及的不同表数量呈线性关系。在实际测试中,全量缓存 100 万张表(每张表含 4 列、1 个主键和 1 个索引)的元数据大约需要 2.4 GiB 内存。
+
+* TiDB 在执行 SQL 语句时,也会按需将相关表的统计信息加载到 Statistics 缓存中。
+
+ * 通过 TiDB 监控中 **Statistics & Plan Management** 面板下的 **Stats Cache Cost** 和 **Stats Cache OPS** 子面板,可以查看 Statistics 缓存的使用情况。
+ * 使用系统变量 [`tidb_stats_cache_mem_quota`](/system-variables.md#tidb_stats_cache_mem_quota-从-v610-版本开始引入) 可以调整 Statistics 缓存的内存上限,以满足业务需求。在实际测试中,执行 10 万张表的简单 SQL(使用 IndexRangeScan 操作符)时,Statistics 缓存大约消耗 3.96 GiB 内存。
+
+## 统计信息收集
+
+* 从 TiDB v8.4.0 开始,TiDB 引入了 [`tidb_auto_analyze_concurrency`](/system-variables.md#tidb_auto_analyze_concurrency-从-v840-版本开始引入) 系统变量,用来设置 TiDB 集群中自动更新统计信息操作的并发度。多表场景下,适当提升并发度可提高自动分析吞吐量。随着并发值的增加,自动分析的吞吐量和 TiDB Owner 节点的 CPU 使用率会线性增加。在实际测试中,使用并发度 16 时,每分钟可自动分析 320 张表(每张表有 1 万行数据、4 列和 1 个索引),占用 TiDB Owner 节点一个 CPU 核心。
+* [`tidb_auto_build_stats_concurrency`](/system-variables.md#tidb_auto_build_stats_concurrency-从-v650-版本开始引入) 和 [`tidb_build_sampling_stats_concurrency`](/system-variables.md#tidb_build_sampling_stats_concurrency-从-v750-版本开始引入) 影响 TiDB 统计信息构建的并发度,需根据具体场景调整:
+ - 分区表较多时,优先提高 `tidb_auto_build_stats_concurrency` 的值。
+ - 列数较多时,优先提高 `tidb_build_sampling_stats_concurrency` 的值。
+* 建议确保 `tidb_auto_analyze_concurrency`、`tidb_auto_build_stats_concurrency` 和 `tidb_build_sampling_stats_concurrency` 三个变量的值的乘积不超过 TiDB CPU 核心数,避免过度占用资源。
+
+## 系统表查询
+
+在查询系统表时,建议添加 `TABLE_SCHEMA` 和 `TABLE_NAME` 或 `TIDB_TABLE_ID` 等过滤条件,以避免扫描大量无关数据,从而提高查询速度并降低资源消耗。
+
+例如,在 300 万表的场景下:
+
+- 执行以下 SQL 语句要消耗约 8 GiB 内存:
+
+ ```sql
+ SELECT COUNT(*) FROM information_schema.tables;
+ ```
+
+- 执行以下 SQL 语句需要约 20 分钟:
+
+ ```sql
+ SELECT COUNT(*) FROM information_schema.views;
+ ```
+
+在以上示例中的两个 SQL 语句加上建议的查询条件之后,内存消耗可以忽略不计,查询耗时降至毫秒级别。
+
+## 大量连接场景
+
+在 SaaS 多租户场景中,通常每个用户连接到 TiDB 操作各自租户 (database) 的数据。为支持更多连接数,建议:
+
+* 调高 TiDB 的配置项 [`token-limit`](/tidb-configuration-file.md#token-limit)(默认值为 `1000`)以支持更多并发请求。
+* TiDB 内存使用量与连接数基本上呈线性关系。在实际测试中,20 万个空闲连接将使 TiDB 进程增加约 30 GiB 内存。建议根据实际连接数调整 TiDB 内存规格。
+* 使用 `PREPARED` 语句时,每个连接都会维护一个会话级的 Prepared Plan Cache。如果长时间未执行 `DEALLOCATE` 预编译语句,可能导致缓存中的计划数量过多,增加内存消耗。在实际测试中,40 万条涉及 IndexRangeScan 的执行计划占用约 5 GiB 内存。建议相应提高内存规格。
+
+## Stale Read
+
+使用 [Stale Read](/stale-read.md) 时,如果使用的 schema 版本过于陈旧,可能触发历史 schema 全量加载,影响性能。建议通过提高 [`tidb_schema_version_cache_limit`](/system-variables.md#tidb_schema_version_cache_limit-从-v740-版本开始引入) 的值(例如 `255`)来缓解此问题。
+
+## BR 备份恢复
+
+* 在全量恢复百万张表的场景中,建议使用高内存 BR 实例。例如:
+ - 100 万张表:使用 32 GiB 或更高内存的 BR 实例
+ - 300 万张表:使用 64 GiB 或更高内存的 BR 实例
+* BR 日志备份和快照恢复会额外消耗 TiKV 内存,建议 TiKV 使用 32 GiB 或更高规格的内存。
+* 可根据业务需求,适当增加 BR 的 [`pitr-batch-count` 和 `pitr-concurrency`](/br/br-pitr-manual.md#恢复到指定时间点-pitr) 配置以提升 BR 日志恢复速度。
+
+## TiDB Lightning 数据导入
+
+在使用 [TiDB Lightning](/tidb-lightning/tidb-lightning-overview.md) 导入百万张表数据时,建议:
+
+- 对大表(超过 100 GiB)使用 TiDB Lightning [物理导入模式](/tidb-lightning/tidb-lightning-physical-import-mode.md)。
+- 对小表(通常数量较多)使用 TiDB Lightning [逻辑导入模式](/tidb-lightning/tidb-lightning-logical-import-mode.md)。
diff --git a/best-practices/three-dc-local-read.md b/best-practices/three-dc-local-read.md
index 00209d00e2d6..5bde68135262 100644
--- a/best-practices/three-dc-local-read.md
+++ b/best-practices/three-dc-local-read.md
@@ -1,6 +1,7 @@
---
title: 在三数据中心下就近读取数据
summary: 了解通过 Stale Read 功能在三数据中心下就近读取数据,减少跨数据中心请求。
+aliases: ['/zh/tidb/stable/three-dc-local-read/','/zh/tidb/dev/three-dc-local-read/']
---
# 在三数据中心下就近读取数据
diff --git a/best-practices/three-nodes-hybrid-deployment.md b/best-practices/three-nodes-hybrid-deployment.md
index 44cceebffbb3..b8a4646b3776 100644
--- a/best-practices/three-nodes-hybrid-deployment.md
+++ b/best-practices/three-nodes-hybrid-deployment.md
@@ -1,7 +1,7 @@
---
title: 三节点混合部署最佳实践
summary: 了解三节点混合部署最佳实践。
-aliases: ['/docs-cn/dev/best-practices/three-nodes-hybrid-deployment/']
+aliases: ['/docs-cn/dev/best-practices/three-nodes-hybrid-deployment/','/zh/tidb/stable/three-nodes-hybrid-deployment/','/zh/tidb/dev/three-nodes-hybrid-deployment/']
---
# 三节点混合部署的最佳实践
@@ -62,7 +62,7 @@ tikv:
#### `server.grpc-concurrency`
-该参数默认为 `4`。因为现有部署方案的 CPU 资源有限,实际请求数也不会很多。可以把该参数值调低,后续观察监控面板保持其使用率在 80% 以下即可。
+因为现有部署方案的 CPU 资源有限,实际请求数也不会很多,可以把 [`server.grpc-concurrency`](/tikv-configuration-file.md#grpc-concurrency) 参数值调低,后续观察监控面板保持其使用率在 80% 以下即可。
本次测试最后选择设置该参数值为 `2`,通过 **gRPC poll CPU** 面板观察,利用率正好在 80% 左右。
diff --git a/best-practices/tidb-best-practices.md b/best-practices/tidb-best-practices.md
index 9bd160c060b0..9120c27b2af7 100644
--- a/best-practices/tidb-best-practices.md
+++ b/best-practices/tidb-best-practices.md
@@ -1,14 +1,14 @@
---
title: TiDB 最佳实践
-aliases: ['/docs-cn/dev/best-practices/tidb-best-practices/']
summary: TiDB 最佳实践总结了使用 TiDB 的一些优化技巧,包括 Raft 一致性协议、分布式事务、数据分片、负载均衡、SQL 到 KV 的映射方案、二级索引的实现方法等。建议阅读官方文档和知乎专栏了解更多细节。部署时推荐使用 TiUP,导入数据时可对 TiKV 参数进行调优。在写入和查询时需注意事务大小限制和并发度设置。监控系统和日志查看也是了解系统状态的重要方法。适用场景包括数据量大、不希望做 Sharding、需要事务和强一致性等。
+aliases: ['/zh/tidb/stable/tidb-best-practices/','/zh/tidb/dev/tidb-best-practices/','/docs-cn/dev/best-practices/tidb-best-practices/']
---
# TiDB 最佳实践
本文档总结使用 TiDB 时的一些最佳实践,主要涉及 SQL 使用和 OLAP/OLTP 优化技巧,特别是一些 TiDB 专有的优化开关。
-建议先阅读讲解 TiDB 原理的三篇文章([讲存储](https://pingcap.com/blog-cn/tidb-internal-1/),[说计算](https://pingcap.com/blog-cn/tidb-internal-2/),[谈调度](https://pingcap.com/blog-cn/tidb-internal-3/)),再来看这篇文章。
+建议先阅读讲解 TiDB 原理的三篇文章([讲存储](https://tidb.net/blog/dbe4f467),[说计算](https://tidb.net/blog/8427565a),[谈调度](https://tidb.net/blog/a558961f)),再来看这篇文章。
## 前言
@@ -28,7 +28,7 @@ Raft 是一种一致性协议,能提供强一致的数据复制保证,TiDB
### 分布式事务
-TiDB 提供完整的分布式事务,事务模型是在 [Google Percolator](https://research.google.com/pubs/pub36726.html) 的基础上做了一些优化。具体的实现可以参考[《Percolator 和 TiDB 事务算法》](https://pingcap.com/blog-cn/percolator-and-txn/)这篇文章。本文档只讨论以下几点:
+TiDB 提供完整的分布式事务,事务模型是在 [Google Percolator](https://research.google/pubs/large-scale-incremental-processing-using-distributed-transactions-and-notifications/) 的基础上做了一些优化。具体的实现可以参考[《Percolator 和 TiDB 事务算法》](https://tidb.net/blog/f537be2c)这篇文章。本文档只讨论以下几点:
+ 乐观锁
@@ -58,7 +58,7 @@ PD 会根据整个 TiKV 集群的状态,对集群的负载进行调度。调
### SQL on KV
-TiDB 自动将 SQL 结构映射为 KV 结构。具体的可以参考[《三篇文章了解 TiDB 技术内幕 - 说计算》](https://pingcap.com/blog-cn/tidb-internal-2/)这篇文档。简单来说,TiDB 执行了以下操作:
+TiDB 自动将 SQL 结构映射为 KV 结构。具体的可以参考[《三篇文章了解 TiDB 技术内幕 - 说计算》](https://tidb.net/blog/8427565a)这篇文档。简单来说,TiDB 执行了以下操作:
+ 一行数据映射为一个 KV,Key 以 `TableID` 构造前缀,以行 ID 为后缀
+ 一条索引映射为一个 KV,Key 以 `TableID+IndexID` 构造前缀,以索引值构造后缀
@@ -84,7 +84,7 @@ TiDB 支持完整的二级索引,并且是全局索引,很多查询可以通
+ 通过索引查询和直接扫描 Table 的区别
- TiDB 实现了全局索引,所以索引和 Table 中的数据并不一定在一个数据分片上。通过索引查询的时候,需要先扫描索引,得到对应的行 ID,然后通过行 ID 去取数据,所以可能会涉及到两次网络请求,会有一定的性能开销。
+ TiDB 实现了[全局索引](/global-indexes.md),所以索引和 Table 中的数据并不一定在一个数据分片上。通过索引查询的时候,需要先扫描索引,得到对应的行 ID,然后通过行 ID 去取数据,所以可能会涉及到两次网络请求,会有一定的性能开销。
如果查询涉及到大量的行,那么扫描索引是并发进行,只要第一批结果已经返回,就可以开始去取 Table 的数据,所以这里是一个并行 + Pipeline 的模式,虽然有两次访问的开销,但是延迟并不会很大。
@@ -186,7 +186,7 @@ TiDB [使用 Grafana + Prometheus 监控系统状态](/tidb-monitoring-framework
+ 公众号:微信搜索 PingCAP
+ 知乎专栏:[TiDB 的后花园](https://zhuanlan.zhihu.com/newsql)
-+ [官方博客](https://pingcap.com/blog-cn/)
++ [官方博客](https://tidb.net/blog)
## TiDB 的最佳适用场景
diff --git a/best-practices/uuid.md b/best-practices/uuid.md
index ab4bd2e15984..a55ac82a700a 100644
--- a/best-practices/uuid.md
+++ b/best-practices/uuid.md
@@ -1,13 +1,16 @@
---
-title: UUID 最佳实践
-summary: 了解在 TiDB 中使用 UUID 的最佳实践和策略。
+title: 将 UUID 用作主键的最佳实践
+summary: 了解在 TiDB 中将 UUID 用作主键的最佳实践。
+aliases: ['/zh/tidb/stable/uuid/','/zh/tidb/dev/uuid/','/zh/tidbcloud/uuid/']
---
-# UUID 最佳实践
+# 将 UUID 用作主键的最佳实践
+
+通用唯一标识符 (UUID) 是分布式数据库中常用的主键替代方案,相较于自增整数,它具有独特优势。本文将介绍在 TiDB 中使用 UUID 的优势,并提供高效存储和索引 UUID 的最佳实践。
## UUID 概述
-通用唯一标识符 (UUID) 用作主键而不是 [`AUTO_INCREMENT`](/auto-increment.md) 整数值时,可以提供以下好处:
+当用作主键时,UUID 相较于 [`AUTO_INCREMENT`](/auto-increment.md) 整数具有以下优势:
- UUID 可以在多个系统生成,而不会产生冲突。某些情况下可以减少到 TiDB 的网络往返次数,从而提高性能。
- 绝大多数编程语言和数据库系统都支持 UUID。
@@ -15,6 +18,8 @@ summary: 了解在 TiDB 中使用 UUID 的最佳实践和策略。
## 最佳实践
+本节介绍在 TiDB 中存储和索引 UUID 的最佳实践。
+
### 二进制存储
UUID 文本是一个包含 36 字符的字符串,如 `ab06f63e-8fe7-11ec-a514-5405db7aad56`。使用 [`UUID_TO_BIN()`](/functions-and-operators/miscellaneous-functions.md#uuid_to_bin) 可将 UUID 文本格式转换为 16 字节的二进制格式。这样,你可以将文本存储在 [`BINARY(16)`](/data-type-string.md#binary-类型) 列中。检索 UUID 时,可以使用 [`BIN_TO_UUID()`](/functions-and-operators/miscellaneous-functions.md#bin_to_uuid) 函数再将其转换回文本格式。
@@ -27,7 +32,7 @@ UUID 文本是一个包含 36 字符的字符串,如 `ab06f63e-8fe7-11ec-a514-
为了演示 `swap_flag` 的效果,本文以表结构相同的两张表为例。区别在于,`uuid_demo_1` 表中插入的数据使用 `UUID_TO_BIN(?, 0)`,而 `uuid_demo_2` 表中使用 `UUID_TO_BIN(?, 1)`。
-在如下的[流量可视化页面](/dashboard/dashboard-key-visualizer.md),你可以看到写入操作集中在 `uuid_demo_2` 表的单个 Region 中,而这个表中的二进制格式字段顺序被调换过。
+在如下的[流量可视化页面](/dashboard/dashboard-key-visualizer.md) (Key Visualizer),你可以看到写入操作集中在 `uuid_demo_2` 表的单个 Region 中,而这个表中的二进制格式字段顺序被调换过。

@@ -47,6 +52,11 @@ CREATE TABLE `uuid_demo_2` (
)
```
+关于流量可视化页面的更多信息,参见:
+
+- TiDB 的[流量可视化页面](/dashboard/dashboard-key-visualizer.md)
+- TiDB Cloud 的[流量可视化页面](https://docs.pingcap.com/zh/tidbcloud/tune-performance/#key-visualizer)
+
## 与 MySQL 兼容性
UUID 也可以在 MySQL 中使用。MySQL 8.0 引入了 `BIN_TO_UUID()` 和 `UUID_TO_BIN()` 函数。`UUID()` 函数在较早的 MySQL 版本中也可以使用。
diff --git a/binary-package.md b/binary-package.md
index bbc355251a4a..faf4c3997c25 100644
--- a/binary-package.md
+++ b/binary-package.md
@@ -5,7 +5,7 @@ summary: 了解 TiDB 离线包及其包含的内容。
# TiDB 离线包
-在[使用 TiUP 离线部署 TiDB](/production-deployment-using-tiup.md#离线部署) 前,你需要在[官方下载页面](https://cn.pingcap.com/product-community/)选择对应版本的 TiDB server 离线镜像包(包含 TiUP 离线组件包)。
+在[使用 TiUP 离线部署 TiDB](/production-deployment-using-tiup.md#离线部署) 前,你需要在[软件下载中心](https://pingkai.cn/download#tidb-community)选择对应版本的 TiDB server 离线镜像包(包含 TiUP 离线组件包)。
TiDB 提供了 amd64 和 arm64 两种架构的离线包。对于每种架构,TiDB 提供了两个二进制离线包:`TiDB-community-server` 软件包和 `TiDB-community-toolkit` 软件包。
diff --git a/blocklist-control-plan.md b/blocklist-control-plan.md
index f13e441ba527..b8a7de827137 100644
--- a/blocklist-control-plan.md
+++ b/blocklist-control-plan.md
@@ -1,7 +1,6 @@
---
title: 优化规则与表达式下推的黑名单
summary: 了解优化规则与表达式下推的黑名单。
-aliases: ['/docs-cn/dev/blacklist-control-plan/','/zh/tidb/dev/blacklist-control-plan']
---
# 优化规则与表达式下推的黑名单
diff --git a/br/backup-and-restore-overview.md b/br/backup-and-restore-overview.md
index 4facc4de6482..6cb03507356e 100644
--- a/br/backup-and-restore-overview.md
+++ b/br/backup-and-restore-overview.md
@@ -1,7 +1,6 @@
---
title: TiDB 备份与恢复概述
summary: 了解不同场景下如何使用 TiDB 的备份与恢复功能,以及不同功能、版本间的兼容性。
-aliases: ['/docs-cn/dev/br/backup-and-restore-tool/','/docs-cn/dev/reference/tools/br/br/','/docs-cn/dev/how-to/maintain/backup-and-restore/br/','/zh/tidb/dev/backup-and-restore-tool/','/zh/tidb/dev/point-in-time-recovery/']
---
# TiDB 备份与恢复概述
@@ -17,15 +16,14 @@ TiDB 备份恢复功能可以用于满足以下业务的需求:
## 使用须知
-本部分介绍使用 TiDB 备份恢复功能前的注意事项,包括使用限制和使用建议。
+本部分介绍使用 TiDB 备份恢复功能前的注意事项,包括使用限制和使用建议。有关 BR 工具与其他功能或版本间的兼容性,请参考[兼容性](#兼容性)。
### 使用限制
- PITR 仅支持恢复到**全新的空集群**。
-- PITR 仅支持集群粒度的恢复,不支持对单个 database 或 table 的恢复。
- PITR 不支持恢复系统表中用户表和权限表的数据。
- 不支持在一个集群上**同时**运行多个数据备份任务。
-- 不支持在一个集群上**同时**运行快照备份任务和数据恢复任务。
+- 不建议备份正在恢复的表,这样备份的数据可能存在异常。
- PITR 数据恢复任务运行期间,不支持同时运行日志备份任务,也不支持通过 TiCDC 同步数据到下游集群。
### 使用建议
@@ -94,7 +92,7 @@ TiDB 备份恢复功能可以用于满足以下业务的需求:
#### 恢复的性能
-- 恢复集群快照数据备份,速度可以达到单 TiKV 存储节点 100 MiB/s,恢复速度具有可扩展性。更详细说明请参考[恢复性能和影响](/br/br-snapshot-guide.md#快照恢复的性能与影响)。
+- 恢复集群快照数据备份,速度可以达到单 TiKV 存储节点 1 GiB/s,恢复速度具有可扩展性。更详细说明请参考[恢复性能和影响](/br/br-snapshot-guide.md#快照恢复的性能与影响)。
- 恢复日志备份数据,速度可以达到 30 GiB/h。更详细说明请参考 [PITR 的性能指标](/br/br-pitr-guide.md#pitr-的性能指标)。
## 备份存储
@@ -119,8 +117,8 @@ TiDB 支持将数据备份到 Amazon S3、Google Cloud Storage (GCS)、Azure Blo
| New collation | [#352](https://github.com/pingcap/br/issues/352) | 确保恢复时集群的 `mysql.tidb` 表中 `new_collation_enabled` 变量值和备份时的一致,否则会导致数据索引不一致和 checksum 通不过。更多信息,请参考 [FAQ - BR 为什么会报 `new_collations_enabled_on_first_bootstrap` 不匹配?](/faq/backup-and-restore-faq.md#恢复时为什么会报-new_collation_enabled-不匹配)。 |
| 全局临时表 | | 确保使用 BR v5.3.0 及以上版本进行备份和恢复,否则会导致全局临时表的表定义错误。 |
| TiDB Lightning 物理导入模式| |上游数据库使用 TiDB Lightning 物理导入模式导入的数据,无法作为数据日志备份下来。推荐在数据导入后执行一次全量备份,细节参考[上游数据库使用 TiDB Lightning 物理导入模式导入数据的恢复](/faq/backup-and-restore-faq.md#上游数据库使用-tidb-lightning-物理导入模式导入数据时为什么无法使用日志备份功能)。|
-| TiCDC | | BR v8.2.0 及以上版本:如果在恢复的目标集群有 [CheckpointTS](/ticdc/ticdc-architecture.md#checkpointts) 早于 BackupTS 的 Changefeed,BR 会拒绝执行恢复。BR v8.2.0 之前的版本:如果在恢复的目标集群有任何活跃的 TiCDC Changefeed,BR 会拒绝执行恢复。 |
-| 向量搜索 | | 确保使用 BR v8.4.0 及以上版本进行备份与恢复。不支持将带有[向量数据类型](/vector-search-data-types.md)的表恢复至 v8.4.0 之前的 TiDB 集群。 |
+| TiCDC | | BR v8.2.0 及以上版本:如果在恢复的目标集群有 [CheckpointTS](/ticdc/ticdc-classic-architecture.md#checkpointts) 早于 BackupTS 的 Changefeed,BR 会拒绝执行恢复。BR v8.2.0 之前的版本:如果在恢复的目标集群有任何活跃的 TiCDC Changefeed,BR 会拒绝执行恢复。 |
+| 向量搜索 | | 确保使用 BR v8.4.0 及以上版本进行备份与恢复。不支持将带有[向量数据类型](/ai/reference/vector-search-data-types.md)的表恢复至 v8.4.0 之前的 TiDB 集群。 |
### 版本间兼容性
@@ -132,6 +130,8 @@ TiDB 支持将数据备份到 Amazon S3、Google Cloud Storage (GCS)、Azure Blo
从 v7.0.0 开始,TiDB 逐步支持通过 SQL 语句来执行备份和恢复操作。因此,强烈建议在备份和恢复集群时使用与 TiDB 集群相同大版本的 BR 工具,并避免跨大版本进行数据备份和恢复操作。这有助于确保恢复操作的顺利执行和数据的一致性。特别是从 v7.6.0 起,BR 默认支持在恢复数据的同时恢复 `mysql` 库下的系统表,即恢复时默认配置为 `--with-sys-table=true`。在跨版本进行数据恢复时,如果遇到 `mysql` 库的系统表结构不同导致类似 `[BR:Restore:ErrRestoreIncompatibleSys]incompatible system table` 异常,你可以通过设置 `--with-sys-table=false` 跳过恢复系统表以规避该问题。
+#### TiDB v6.6.0 版本之前的 BR 版本兼容性矩阵
+
TiDB v6.6.0 版本之前的 BR 版本兼容性矩阵:
| 备份版本(纵向)\ 恢复版本(横向) | 恢复到 TiDB v6.0 | 恢复到 TiDB v6.1| 恢复到 TiDB v6.2 | 恢复到 TiDB v6.3、v6.4 或 v6.5 | 恢复到 TiDB v6.6 |
@@ -139,6 +139,41 @@ TiDB v6.6.0 版本之前的 BR 版本兼容性矩阵:
| TiDB v6.0、v6.1、v6.2、v6.3、v6.4 或 v6.5 快照备份 | 兼容(已知问题,如果备份数据中包含空库可能导致报错,参考 [#36379](https://github.com/pingcap/tidb/issues/36379)) | 兼容 | 兼容 | 兼容 | 兼容(需使用 v6.6 的 BR) |
| TiDB v6.3、v6.4、v6.5 或 v6.6 日志备份| 不兼容 | 不兼容 | 不兼容 | 兼容 | 兼容 |
+#### TiDB v6.5.0 版本到 v8.5.0 之间的 BR 版本兼容性矩阵
+
+本节列出了 TiDB v6.5.0 版本到 v8.5.0 之间所有[长期支持版本 (LTS)](/releases/versioning.md#长期支持版本)(包括 v6.5.0、v7.1.0、v7.5.0、v8.1.0、v8.5.0)的 BR 兼容性矩阵。这个矩阵中的 BR 版本与对应的 TiDB Server 的大版本一致。
+
+> **注意:**
+>
+> - 已知问题:从 v7.2.0 开始,新建集群的部分系统表字段变为大小写不敏感。然而,对于从 v7.2.0 之前的版本**在线升级**到 v7.2.0 及以上版本的集群,对应的系统表字段仍然大小写敏感。如果在这两类集群之间进行包含系统表的备份和恢复操作,可能会失败。详情参见 [Issue #43717](https://github.com/pingcap/tidb/issues/43717)。
+> - 从 v8.5.5 起,BR 在恢复系统表时支持通过参数 `--sys-check-collation` 检查排序规则 (Collation) 兼容性。在恢复过程中,BR 会验证系统表数据在目标集群排序规则下是否存在大小写冲突。如果数据在目标序规则下兼容,则可以成功恢复旧版本备份。否则,BR 会报错并终止恢复。
+
+下表列出了全量备份的兼容性矩阵,表格中所有信息均适用于新建集群。如果备份集群是从 v7.2.0 之前升级过来的集群,行为等同于 v7.1.0:
+
+| 备份集群版本 | 兼容的恢复目标集群版本 | 不兼容的恢复目标集群版本 |
+|:--|:--|:--|
+| v6.5.0 | v7.1.0 | v7.5.0 及以上 |
+| v7.1.0 | - | v7.5.0 及以上 |
+| v7.5.0 | v7.5.0 及以上 | - |
+| v8.1.0 | v8.1.0 及以上 | - |
+| v8.5.0 | v8.5.0 及以上 | - |
+
+下表列出了日志备份的兼容性矩阵,表格中所有信息均适用于新建集群。如果备份集群是从 v7.2.0 之前升级过来的集群,行为等同于 v7.1.0:
+
+| 备份集群版本 | 兼容的恢复目标集群版本 | 不兼容的恢复目标集群版本 |
+|:--|:--|:--|
+| v6.5.0 | v7.1.0 | v7.5.0 及以上 |
+| v7.1.0 | - | v7.5.0 及以上 |
+| v7.5.0 | v7.5.0 及以上 | - |
+| v8.1.0 | v8.1.0 及以上 | - |
+| v8.5.0 | v8.5.0 及以上 | - |
+
+> **注意:**
+>
+> - 当仅备份非系统表的业务数据时(全量备份或日志备份),所有版本之间均兼容。
+> - 在恢复 `mysql` 系统表时,可能会出现不兼容情况。为避免此问题,你可以通过设置 `--with-sys-table=false` 跳过恢复所有系统表,或者使用更精细的过滤器仅仅跳过不兼容的系统表,例如:`--filter '*.*' --filter "__TiDB_BR_Temporary_*.*" --filter '!mysql.*' --filter 'mysql.bind_info' --filter 'mysql.user' --filter 'mysql.global_priv' --filter 'mysql.global_grants' --filter 'mysql.default_roles' --filter 'mysql.role_edges' --filter '!sys.*' --filter '!INFORMATION_SCHEMA.*' --filter '!PERFORMANCE_SCHEMA.*' --filter '!METRICS_SCHEMA.*' --filter '!INSPECTION_SCHEMA.*'`。
+> - "-" 表示该版本在对应场景下没有兼容性限制。
+
## 探索更多
- [TiDB 快照备份与恢复使用指南](/br/br-snapshot-guide.md)
diff --git a/br/backup-and-restore-storages.md b/br/backup-and-restore-storages.md
index 177e280d175f..db456a6db067 100644
--- a/br/backup-and-restore-storages.md
+++ b/br/backup-and-restore-storages.md
@@ -1,7 +1,6 @@
---
title: 备份存储
summary: 了解 BR 支持的备份存储服务的 URI 格式、鉴权方案和使用方式。
-aliases: ['/docs-cn/dev/br/backup-and-restore-storages/','/zh/tidb/dev/backup-storage-S3/','/zh/tidb/dev/backup-storage-azblob/','/zh/tidb/dev/backup-storage-gcs/','/zh/tidb/dev/external-storage/']
---
# 备份存储
@@ -203,6 +202,66 @@ tiup br restore db --db test -u "${PD_IP}:2379" \
--storage "azure://external/backup-20220915?account-name=${account-name}"
```
+- 方式四:使用 Azure 托管标识 (Managed Identity)
+
+ 从 v8.5.5 起,如果你的 TiDB 集群和 br 命令行工具运行在 Azure 虚拟机 (VM) 或 Azure Kubernetes Service (AKS) 环境中,并且已为节点分配了 Azure 托管标识,则可以使用 Azure 托管标识进行鉴权。
+
+ 使用此方式前,请确保已在 [Azure Portal](https://azure.microsoft.com/) 中为对应的托管标识授予目标存储账户的访问权限(如 `Storage Blob Data Contributor`)。
+
+ - **系统分配的托管标识 (System-assigned)**:
+
+ 使用系统分配的托管标识时,无需配置任何 Azure 相关环境变量,直接运行 br 备份命令即可。
+
+ ```shell
+ tiup br backup full -u "${PD_IP}:2379" \
+ --storage "azure://external/backup-20220915?account-name=${account-name}"
+ ```
+
+ > **注意:**
+ >
+ > 请确保运行环境中**不存在** `AZURE_CLIENT_ID`、`AZURE_TENANT_ID` 或 `AZURE_CLIENT_SECRET` 环境变量,否则 Azure SDK 可能会优先使用其他认证方式,导致托管标识未生效。
+
+ - **用户分配的托管标识 (User-assigned)**:
+
+ 使用用户分配的托管标识时,需要在 TiKV 运行环境和 br 命令行工具运行环境中配置环境变量 `AZURE_CLIENT_ID` (其值为该托管标识的 Client ID),然后再执行 br 备份命令。具体步骤如下:
+
+ 1. 使用 TiUP 启动时为 TiKV 配置 Client ID:
+
+ 以下步骤以 TiKV 端口 `24000`、systemd 服务名 `tikv-24000` 为例:
+
+ 1. 执行以下命令进入服务配置编辑界面:
+
+ ```shell
+ systemctl edit tikv-24000
+ ```
+
+ 2. 配置 `AZURE_CLIENT_ID` 环境变量:
+
+ ```ini
+ [Service]
+ Environment="AZURE_CLIENT_ID="
+ ```
+
+ 3. 重新加载 systemd 配置并重启 TiKV:
+
+ ```shell
+ systemctl daemon-reload
+ systemctl restart tikv-24000
+ ```
+
+ 2. 为 br 命令行工具配置 `AZURE_CLIENT_ID` 环境变量:
+
+ ```shell
+ export AZURE_CLIENT_ID=""
+ ```
+
+ 3. 使用 br 命令行工具将数据备份至 Azure Blob Storage:
+
+ ```shell
+ tiup br backup full -u "${PD_IP}:2379" \
+ --storage "azure://external/backup-20220915?account-name=${account-name}"
+ ```
+