This is an automated email from the ASF dual-hosted git repository.
terrymanu pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new 29c79a75903 Refine docs and remove embedded H2 demo (#38749)
29c79a75903 is described below
commit 29c79a75903e148944b626038393ad6a10759b83
Author: Liang Zhang <[email protected]>
AuthorDate: Fri May 29 12:46:39 2026 +0800
Refine docs and remove embedded H2 demo (#38749)
* Refine ShardingSphere MCP user manual
Clarify MCP Server terminology and Chinese protocol wording.
Replace the H2-based quick start path with a ShardingSphere-Proxy logical
database example.
Simplify startup, session initialization, and troubleshooting instructions
in CN/EN docs.
* Refine docs and remove embedded H2 demo
Refine the ShardingSphere-MCP documentation to clarify MCP Server
wording, protocol terminology, startup flow, and the requirement for a
user-prepared ShardingSphere-Proxy/MySQL logical database.
Remove the embedded H2 demo runtime, including demo SQL, distribution
dependency, data directory setup, H2 MCP capability registration, and
related test fixtures.
Update default MCP configurations and examples to use Proxy/MySQL
placeholders instead of project-provided demo data.
---
distribution/mcp/Dockerfile | 2 +-
distribution/mcp/pom.xml | 6 --
distribution/mcp/src/main/bin/start.bat | 6 +-
distribution/mcp/src/main/bin/start.sh | 5 +-
.../mcp/src/main/resources/conf/demo-h2.sql | 45 ----------
.../mcp/src/main/resources/conf/mcp-http.yaml | 22 ++---
.../mcp/src/main/resources/conf/mcp-stdio.yaml | 22 ++---
.../user-manual/shardingsphere-mcp/_index.cn.md | 18 ++--
.../user-manual/shardingsphere-mcp/_index.en.md | 17 ++--
.../shardingsphere-mcp/client-integration.cn.md | 34 ++++----
.../shardingsphere-mcp/client-integration.en.md | 12 +--
.../shardingsphere-mcp/configuration.cn.md | 28 +++---
.../shardingsphere-mcp/configuration.en.md | 20 ++---
.../shardingsphere-mcp/deployment.cn.md | 13 +--
.../shardingsphere-mcp/deployment.en.md | 13 +--
.../shardingsphere-mcp/features/_index.cn.md | 12 +--
.../shardingsphere-mcp/features/_index.en.md | 2 +-
.../shardingsphere-mcp/features/encrypt.cn.md | 24 +++---
.../shardingsphere-mcp/features/encrypt.en.md | 2 +-
.../shardingsphere-mcp/features/mask.cn.md | 20 ++---
.../shardingsphere-mcp/quick-start.cn.md | 99 ++++++++++++----------
.../shardingsphere-mcp/quick-start.en.md | 85 ++++++++++---------
.../shardingsphere-mcp/troubleshooting.cn.md | 61 +++++++------
.../shardingsphere-mcp/troubleshooting.en.md | 7 +-
.../shardingsphere-mcp/workflow-basics.cn.md | 50 +++++------
.../shardingsphere-mcp/workflow-basics.en.md | 14 +--
.../mcp/bootstrap/MCPRuntimeLauncher.java | 8 +-
.../config/MCPLaunchConfigurationTest.java | 4 +-
.../config/loader/MCPConfigurationLoaderTest.java | 16 ++--
.../YamlMCPLaunchConfigurationSwapperTest.java | 50 +++++------
.../YamlMCPTransportConfigurationSwapperTest.java | 6 +-
...amlRuntimeDatabaseConfigurationSwapperTest.java | 20 ++---
...mlRuntimeDatabaseConfigurationsSwapperTest.java | 22 ++---
.../mcp/core/resource/ResourceTestDataFactory.java | 2 +-
.../execute/MCPJdbcStatementExecutorTest.java | 34 ++++----
.../MCPSQLExecutionFacadeConcurrencyTest.java | 6 +-
.../metadata/SearchMetadataToolServiceTest.java | 6 +-
.../registry/MCPRegistryMetadataCommandTest.java | 2 +-
mcp/server.json | 2 +-
.../dialect/H2MCPDatabaseCapabilityOption.java | 37 --------
.../jdbc/MCPJdbcDatabaseProfileLoader.java | 6 --
.../metadata/jdbc/MCPJdbcMetadataLoader.java | 2 -
...database.capability.MCPDatabaseCapabilityOption | 1 -
.../MCPDatabaseCapabilityProviderTest.java | 3 +-
.../metadata/jdbc/MCPJdbcMetadataLoaderTest.java | 48 +++++------
.../jdbc/RuntimeDatabaseConfigurationTest.java | 6 +-
.../metadata/query/DatabaseTestDataFactory.java | 2 +-
47 files changed, 410 insertions(+), 512 deletions(-)
diff --git a/distribution/mcp/Dockerfile b/distribution/mcp/Dockerfile
index 53a491252f2..0410d17b1f1 100644
--- a/distribution/mcp/Dockerfile
+++ b/distribution/mcp/Dockerfile
@@ -18,7 +18,7 @@ FROM eclipse-temurin:21-jre
ARG MCP_SERVER_NAME=io.github.apache/shardingsphere-mcp
ARG MCP_IMAGE_VERSION=unknown
ARG MCP_SOURCE_URL=https://github.com/apache/shardingsphere
-ARG MCP_DESCRIPTION="Standalone MCP runtime for Apache ShardingSphere metadata
and SQL access"
+ARG MCP_DESCRIPTION="Standalone MCP Server for Apache ShardingSphere metadata
and SQL access"
LABEL org.opencontainers.image.authors="ShardingSphere
[email protected]" \
org.opencontainers.image.description="${MCP_DESCRIPTION}" \
diff --git a/distribution/mcp/pom.xml b/distribution/mcp/pom.xml
index ff5d3c063bc..3ec8c97c1cd 100644
--- a/distribution/mcp/pom.xml
+++ b/distribution/mcp/pom.xml
@@ -50,11 +50,6 @@
<version>${project.version}</version>
<scope>runtime</scope>
</dependency>
- <dependency>
- <groupId>com.h2database</groupId>
- <artifactId>h2</artifactId>
- <scope>runtime</scope>
- </dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
@@ -142,7 +137,6 @@
<phase>package</phase>
<configuration>
<target>
- <mkdir
dir="${project.build.directory}/apache-shardingsphere-mcp-${project.version}/data"
/>
<mkdir
dir="${project.build.directory}/apache-shardingsphere-mcp-${project.version}/plugins"
/>
<mkdir
dir="${project.build.directory}/apache-shardingsphere-mcp-${project.version}/logs"
/>
<chmod
file="${project.build.directory}/apache-shardingsphere-mcp-${project.version}/bin/start.sh"
perm="755" />
diff --git a/distribution/mcp/src/main/bin/start.bat
b/distribution/mcp/src/main/bin/start.bat
index 5bdd6bd4c3a..9224de15c58 100644
--- a/distribution/mcp/src/main/bin/start.bat
+++ b/distribution/mcp/src/main/bin/start.bat
@@ -28,7 +28,6 @@ if "%~1"=="" (
)
set "LIB_DIR=%APP_HOME%\lib"
set "PLUGINS_DIR=%APP_HOME%\plugins"
-set "DATA_DIR=%APP_HOME%\data"
set "LOG_DIR=%APP_HOME%\logs"
if not exist "%CONF_FILE%" (
@@ -37,13 +36,10 @@ if not exist "%CONF_FILE%" (
)
if not exist "%LIB_DIR%" (
- >&2 echo Error: MCP runtime libraries are missing under '%LIB_DIR%'.
+ >&2 echo Error: MCP Server libraries are missing under '%LIB_DIR%'.
exit /b 1
)
-if not exist "%DATA_DIR%" (
- mkdir "%DATA_DIR%"
-)
if not exist "%PLUGINS_DIR%" (
mkdir "%PLUGINS_DIR%"
)
diff --git a/distribution/mcp/src/main/bin/start.sh
b/distribution/mcp/src/main/bin/start.sh
index a3324d8bb07..4b1a782811d 100644
--- a/distribution/mcp/src/main/bin/start.sh
+++ b/distribution/mcp/src/main/bin/start.sh
@@ -22,7 +22,6 @@ APP_HOME=$(cd "${SCRIPT_DIR}/.." && pwd)
CONF_FILE=${1:-"${APP_HOME}/conf/mcp-http.yaml"}
LIB_DIR="${APP_HOME}/lib"
PLUGINS_DIR="${APP_HOME}/plugins"
-DATA_DIR="${APP_HOME}/data"
LOG_DIR="${APP_HOME}/logs"
if [ ! -f "${CONF_FILE}" ]; then
@@ -31,11 +30,11 @@ if [ ! -f "${CONF_FILE}" ]; then
fi
if [ ! -d "${LIB_DIR}" ]; then
- echo "Error: MCP runtime libraries are missing under '${LIB_DIR}'." 1>&2
+ echo "Error: MCP Server libraries are missing under '${LIB_DIR}'." 1>&2
exit 1
fi
-mkdir -p "${DATA_DIR}" "${PLUGINS_DIR}" "${LOG_DIR}"
+mkdir -p "${PLUGINS_DIR}" "${LOG_DIR}"
if [ -n "${JAVA_HOME:-}" ] && [ -x "${JAVA_HOME}/bin/java" ]; then
JAVA="${JAVA_HOME}/bin/java"
diff --git a/distribution/mcp/src/main/resources/conf/demo-h2.sql
b/distribution/mcp/src/main/resources/conf/demo-h2.sql
deleted file mode 100644
index 56e3330f33a..00000000000
--- a/distribution/mcp/src/main/resources/conf/demo-h2.sql
+++ /dev/null
@@ -1,45 +0,0 @@
--- Licensed to the Apache Software Foundation (ASF) under one or more
--- contributor license agreements. See the NOTICE file distributed with
--- this work for additional information regarding copyright ownership.
--- The ASF licenses this file to You under the Apache License, Version 2.0
--- (the "License"); you may not use this file except in compliance with
--- the License. You may obtain a copy of the License at
---
--- http://www.apache.org/licenses/LICENSE-2.0
---
--- Unless required by applicable law or agreed to in writing, software
--- distributed under the License is distributed on an "AS IS" BASIS,
--- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
--- See the License for the specific language governing permissions and
--- limitations under the License.
-
-CREATE SCHEMA IF NOT EXISTS public;
-SET SCHEMA public;
-CREATE TABLE IF NOT EXISTS orders (
- order_id INT PRIMARY KEY,
- status VARCHAR(32),
- amount INT
-);
-CREATE TABLE IF NOT EXISTS order_items (
- item_id INT PRIMARY KEY,
- order_id INT,
- sku VARCHAR(64)
-);
-INSERT INTO orders (order_id, status, amount)
-SELECT 1, 'NEW', 10
-WHERE NOT EXISTS (
- SELECT 1 FROM orders WHERE order_id = 1
-);
-INSERT INTO orders (order_id, status, amount)
-SELECT 2, 'DONE', 20
-WHERE NOT EXISTS (
- SELECT 1 FROM orders WHERE order_id = 2
-);
-INSERT INTO order_items (item_id, order_id, sku)
-SELECT 1, 1, 'sku-1'
-WHERE NOT EXISTS (
- SELECT 1 FROM order_items WHERE item_id = 1
-);
-CREATE VIEW IF NOT EXISTS active_orders AS
-SELECT order_id, status FROM orders WHERE status <> 'DONE';
-CREATE INDEX IF NOT EXISTS idx_orders_status ON orders(status);
diff --git a/distribution/mcp/src/main/resources/conf/mcp-http.yaml
b/distribution/mcp/src/main/resources/conf/mcp-http.yaml
index a5362ea7f6c..20d2ccee47e 100644
--- a/distribution/mcp/src/main/resources/conf/mcp-http.yaml
+++ b/distribution/mcp/src/main/resources/conf/mcp-http.yaml
@@ -17,17 +17,11 @@ transport:
type: STREAMABLE_HTTP
runtimeDatabases:
- # Replace this demo runtime block for real deployments.
- # For non-H2 databases, add the JDBC driver jar under plugins/ before
startup.
- orders:
- databaseType: H2
- jdbcUrl:
"jdbc:h2:file:./data/mcp-demo-orders;MODE=MySQL;DATABASE_TO_UPPER=false;DB_CLOSE_DELAY=-1;INIT=RUNSCRIPT
FROM 'conf/demo-h2.sql'"
- username: ""
- password: ""
- driverClassName: org.h2.Driver
- billing:
- databaseType: H2
- jdbcUrl:
"jdbc:h2:file:./data/mcp-demo-billing;MODE=MySQL;DATABASE_TO_UPPER=false;DB_CLOSE_DELAY=-1;INIT=RUNSCRIPT
FROM 'conf/demo-h2.sql'"
- username: ""
- password: ""
- driverClassName: org.h2.Driver
+ # Configure this entry before startup.
+ # Replace logic_db, JDBC URL, username, and password with your
ShardingSphere-Proxy logical database.
+ logic_db:
+ databaseType: MySQL
+ jdbcUrl:
"jdbc:mysql://127.0.0.1:3307/logic_db?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC"
+ username: "proxy_user"
+ password: "proxy_password"
+ driverClassName: com.mysql.cj.jdbc.Driver
diff --git a/distribution/mcp/src/main/resources/conf/mcp-stdio.yaml
b/distribution/mcp/src/main/resources/conf/mcp-stdio.yaml
index c2778fbec55..ccdc19c72c0 100644
--- a/distribution/mcp/src/main/resources/conf/mcp-stdio.yaml
+++ b/distribution/mcp/src/main/resources/conf/mcp-stdio.yaml
@@ -17,17 +17,11 @@ transport:
type: STDIO
runtimeDatabases:
- # Replace this demo runtime block for real deployments.
- # For non-H2 databases, add the JDBC driver jar under plugins/ before
startup.
- orders:
- databaseType: H2
- jdbcUrl:
"jdbc:h2:file:./data/mcp-demo-orders;MODE=MySQL;DATABASE_TO_UPPER=false;DB_CLOSE_DELAY=-1;INIT=RUNSCRIPT
FROM 'conf/demo-h2.sql'"
- username: ""
- password: ""
- driverClassName: org.h2.Driver
- billing:
- databaseType: H2
- jdbcUrl:
"jdbc:h2:file:./data/mcp-demo-billing;MODE=MySQL;DATABASE_TO_UPPER=false;DB_CLOSE_DELAY=-1;INIT=RUNSCRIPT
FROM 'conf/demo-h2.sql'"
- username: ""
- password: ""
- driverClassName: org.h2.Driver
+ # Configure this entry before startup.
+ # Replace logic_db, JDBC URL, username, and password with your
ShardingSphere-Proxy logical database.
+ logic_db:
+ databaseType: MySQL
+ jdbcUrl:
"jdbc:mysql://127.0.0.1:3307/logic_db?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC"
+ username: "proxy_user"
+ password: "proxy_password"
+ driverClassName: com.mysql.cj.jdbc.Driver
diff --git a/docs/document/content/user-manual/shardingsphere-mcp/_index.cn.md
b/docs/document/content/user-manual/shardingsphere-mcp/_index.cn.md
index c989a3ec009..ed709b113bd 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/_index.cn.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/_index.cn.md
@@ -5,17 +5,17 @@ weight = 7
chapter = true
+++
-ShardingSphere-MCP 是 Apache ShardingSphere 面向 Model Context Protocol 的独立运行时。
-它通过 MCP tools、resources、prompts 和 completions 暴露逻辑库元数据、安全 SQL
访问能力，以及由插件提供的治理工作流。
+ShardingSphere-MCP 是 Apache ShardingSphere 的 MCP Server，可以独立启动，并向 MCP 客户端暴露
ShardingSphere 逻辑库的元数据、安全 SQL 访问能力和插件工作流。
+本文将 MCP 协议中的 tools、resources、prompts 和 completions 分别称为工具、资源、提示和补全；协议方法名和 JSON
字段名仍保留英文，例如 `tools/list` 和 `resources/read`。
-本章面向使用者，说明如何启动 MCP runtime、连接 MCP client、配置运行时逻辑库、部署官方发行包，并排查通用问题。
+ShardingSphere-MCP 的配置以数据库为核心：先配置 MCP Server 可以连接的 ShardingSphere 逻辑库，再通过 MCP
客户端读取元数据或调用 SQL 工具。
## 文档结构
-- 快速开始：使用发行包内置 demo runtime 验证 metadata discovery 和 query。
-- 配置说明：说明 transport、runtimeDatabases、插件目录和启动参数。
-- Client 集成：说明 HTTP、STDIO、session header 和 discovery 调用方式。
-- Workflow 基础：说明插件工作流共享的 plan、apply、validate 机制。
-- Feature Plugins：说明官方 MCP 插件能力。
+- 快速开始：构建发行包，配置一个可连接的逻辑库，启动 HTTP MCP Server，并验证元数据读取和只读 SQL 查询。
+- 配置说明：说明传输方式、`runtimeDatabases`、插件目录和启动参数。
+- 客户端集成：说明 HTTP、STDIO、会话响应头和能力发现调用方式。
+- 工作流基础：说明插件工作流共享的规划、执行和校验机制。
+- 功能插件：说明官方 MCP 功能插件能力。
- 部署说明：说明发行包、OCI 镜像和安全部署建议。
-- 常见问题：排查 MCP runtime、transport、session 和 SQL tool 的通用问题。
+- 常见问题：排查 MCP Server、传输方式、会话和 SQL 工具的通用问题。
diff --git a/docs/document/content/user-manual/shardingsphere-mcp/_index.en.md
b/docs/document/content/user-manual/shardingsphere-mcp/_index.en.md
index 1a3ce5bcdc7..90b8eb64670 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/_index.en.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/_index.en.md
@@ -5,18 +5,17 @@ weight = 7
chapter = true
+++
-ShardingSphere-MCP is the standalone Model Context Protocol runtime for Apache
ShardingSphere.
-It exposes logical database metadata, safe SQL access, and plugin-provided
governance workflows through MCP tools, resources, prompts, and completions.
+ShardingSphere-MCP is the MCP Server for Apache ShardingSphere. It can run
independently and expose ShardingSphere logical database metadata, safe SQL
access, and plugin workflows to MCP clients.
+This manual uses the MCP terms tools, resources, prompts, and completions for
the corresponding protocol capabilities. Protocol method names and JSON field
names stay in their original form, such as `tools/list` and `resources/read`.
-This chapter is written for users who need to start the MCP runtime, connect
an MCP client, configure logical runtime databases,
-deploy the official distribution, and troubleshoot common runtime issues.
+ShardingSphere-MCP configuration starts from databases: configure the
ShardingSphere logical databases that the MCP Server can connect to, then read
metadata or call SQL tools through an MCP client.
## Structure
-- Quick Start: verify metadata discovery and query behavior with the packaged
demo runtime.
-- Configuration: configure transport, runtimeDatabases, plugin directories,
and launch parameters.
-- Client Integration: use HTTP, STDIO, session headers, and discovery calls.
-- Workflow Basics: understand the shared plan, apply, and validate flow used
by feature plugins.
+- Quick Start: build the distribution, configure a reachable logical database,
start the HTTP MCP Server, and verify metadata reads and read-only SQL queries.
+- Configuration: configure transport, `runtimeDatabases`, plugin directories,
and launch parameters.
+- Client Integration: use HTTP, STDIO, session response headers, and
capability discovery calls.
+- Workflow Basics: understand the shared planning, apply, and validation flow
used by feature plugins.
- Feature Plugins: use official MCP feature plugins.
- Deployment: deploy the binary distribution and OCI image safely.
-- Troubleshooting: diagnose common MCP runtime, transport, session, and SQL
tool issues.
+- Troubleshooting: diagnose common MCP Server, transport, session, and SQL
tool issues.
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/client-integration.cn.md
b/docs/document/content/user-manual/shardingsphere-mcp/client-integration.cn.md
index 016935e5644..a9579dadfe8 100644
---
a/docs/document/content/user-manual/shardingsphere-mcp/client-integration.cn.md
+++
b/docs/document/content/user-manual/shardingsphere-mcp/client-integration.cn.md
@@ -1,12 +1,12 @@
+++
-title = "Client 集成"
+title = "客户端集成"
weight = 3
+++
-MCP client 可以通过 Streamable HTTP 或 STDIO 连接 ShardingSphere-MCP。
-Client 应优先使用 MCP 官方 discovery 方法发现 public surface，再按任务调用
tools、resources、prompts 或 completions。
+MCP 客户端可以通过 Streamable HTTP 或 STDIO 连接 ShardingSphere-MCP。
+客户端应优先使用 MCP 官方能力发现方法获取工具、资源、提示和补全列表，再按任务发起调用。
-## HTTP 配置形态
+## HTTP 配置
```json
{
@@ -18,15 +18,15 @@ Client 应优先使用 MCP 官方 discovery 方法发现 public surface，再按
}
```
-HTTP client 需要先调用 `initialize`，并保存响应 header 中的：
+HTTP 客户端需要先调用 `initialize`，并保存响应头中的：
- `MCP-Session-Id`
- `MCP-Protocol-Version`
-后续请求必须继续携带这两个 header。
-关闭 session 后，该 session id 不能继续复用。
+后续请求必须继续携带这两个响应头。
+关闭会话后，该会话 ID 不能继续复用。
-## STDIO 配置形态
+## STDIO 配置
```json
{
@@ -39,18 +39,18 @@ HTTP client 需要先调用 `initialize`，并保存响应 header 中的：
}
```
-STDIO 模式适合由本地 MCP client 拉起 ShardingSphere-MCP 子进程。
+STDIO 模式适合由本地 MCP 客户端拉起 ShardingSphere-MCP 子进程。
它不是面向人工手输请求的交互式 Shell。
STDIO 模式下：
- stdout 只用于 MCP 协议帧。
- 诊断日志写到 stderr 或 `logs/mcp.log`。
-- client 配置中的 `command` 和 `args` 应指向发行包内的启动脚本和 STDIO 配置文件。
+- 客户端配置中的 `command` 和 `args` 应指向发行包内的启动脚本和 STDIO 配置文件。
-## Discovery 顺序
+## 能力发现顺序
-建议 client 按下面顺序发现能力：
+建议客户端按下面顺序发现能力：
1. `tools/list`
2. `resources/list`
@@ -58,11 +58,11 @@ STDIO 模式下：
4. `prompts/list`
5. `completion/complete`
-`shardingsphere://capabilities` 是 ShardingSphere 领域目录资源，可作为模型理解可用能力的补充信息，但不替代
MCP 官方 list 方法。
+`shardingsphere://capabilities` 是 ShardingSphere 领域目录资源，可作为模型理解可用能力的补充信息，但不替代
MCP 官方列表方法。
## 常用调用
-读取 runtime 状态：
+读取服务状态：
```json
{"jsonrpc":"2.0","id":"runtime-1","method":"resources/read","params":{"uri":"shardingsphere://runtime"}}
@@ -74,14 +74,14 @@ STDIO 模式下：
{"jsonrpc":"2.0","id":"capabilities-1","method":"resources/read","params":{"uri":"shardingsphere://capabilities"}}
```
-搜索 metadata：
+搜索元数据：
```json
-{"jsonrpc":"2.0","id":"search-1","method":"tools/call","params":{"name":"database_gateway_search_metadata","arguments":{"database":"logic_db","query":"orders","object_types":["table"]}}}
+{"jsonrpc":"2.0","id":"search-1","method":"tools/call","params":{"name":"database_gateway_search_metadata","arguments":{"database":"logic_db","query":"sample","object_types":["table"]}}}
```
执行只读 SQL：
```json
-{"jsonrpc":"2.0","id":"query-1","method":"tools/call","params":{"name":"database_gateway_execute_query","arguments":{"database":"logic_db","sql":"SELECT
* FROM orders","max_rows":100}}}
+{"jsonrpc":"2.0","id":"query-1","method":"tools/call","params":{"name":"database_gateway_execute_query","arguments":{"database":"logic_db","sql":"SELECT
* FROM sample_table LIMIT 100","max_rows":100}}}
```
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/client-integration.en.md
b/docs/document/content/user-manual/shardingsphere-mcp/client-integration.en.md
index 8d4f424289b..6aa03521cdb 100644
---
a/docs/document/content/user-manual/shardingsphere-mcp/client-integration.en.md
+++
b/docs/document/content/user-manual/shardingsphere-mcp/client-integration.en.md
@@ -4,9 +4,9 @@ weight = 3
+++
MCP clients can connect to ShardingSphere-MCP through Streamable HTTP or STDIO.
-Clients should use official MCP discovery methods first, then call tools,
resources, prompts, or completions for the target task.
+Clients should use official MCP capability discovery methods first, then call
tools, resources, prompts, or completions for the target task.
-## HTTP configuration shape
+## HTTP configuration
```json
{
@@ -26,7 +26,7 @@ An HTTP client must call `initialize` first and keep these
response headers:
Later requests must include both headers.
After the session is closed, the session id cannot be reused.
-## STDIO configuration shape
+## STDIO configuration
```json
{
@@ -48,7 +48,7 @@ In STDIO mode:
- Diagnostics are written to stderr or `logs/mcp.log`.
- `command` and `args` in the client configuration should point to the
packaged startup script and STDIO config file.
-## Discovery order
+## Capability discovery order
Recommended client discovery order:
@@ -77,11 +77,11 @@ Read the capability catalog:
Search metadata:
```json
-{"jsonrpc":"2.0","id":"search-1","method":"tools/call","params":{"name":"database_gateway_search_metadata","arguments":{"database":"logic_db","query":"orders","object_types":["table"]}}}
+{"jsonrpc":"2.0","id":"search-1","method":"tools/call","params":{"name":"database_gateway_search_metadata","arguments":{"database":"logic_db","query":"sample","object_types":["table"]}}}
```
Execute read-only SQL:
```json
-{"jsonrpc":"2.0","id":"query-1","method":"tools/call","params":{"name":"database_gateway_execute_query","arguments":{"database":"logic_db","sql":"SELECT
* FROM orders","max_rows":100}}}
+{"jsonrpc":"2.0","id":"query-1","method":"tools/call","params":{"name":"database_gateway_execute_query","arguments":{"database":"logic_db","sql":"SELECT
* FROM sample_table LIMIT 100","max_rows":100}}}
```
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/configuration.cn.md
b/docs/document/content/user-manual/shardingsphere-mcp/configuration.cn.md
index 22241c5b421..243fa6312bb 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/configuration.cn.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/configuration.cn.md
@@ -3,12 +3,12 @@ title = "配置说明"
weight = 2
+++
-ShardingSphere-MCP 使用 YAML 文件配置 transport 和运行时逻辑库。
+ShardingSphere-MCP 使用 YAML 文件配置传输方式和 MCP Server 可以连接的数据库。
发行包默认读取 `conf/mcp-http.yaml`，也内置 `conf/mcp-stdio.yaml`。
-## Transport 配置
+## 传输方式
-每个 MCP runtime 进程必须且只能选择一种 transport。
+每个 MCP Server 进程必须且只能选择一种传输方式。
HTTP 示例：
@@ -36,10 +36,10 @@ transport:
- `127.0.0.1`、`localhost`、`::1` 只面向本机。
- `0.0.0.0` 或指定内网 IP 会面向对应网络接口。
-## Runtime Databases
+## 数据库配置
-`runtimeDatabases` 定义 MCP runtime 可见的 ShardingSphere 逻辑库。
-每个条目的 key 是 MCP 对外暴露的逻辑库名称。
+`runtimeDatabases` 定义 MCP Server 可以连接并对外暴露的数据库。
+每个条目的 key 是 MCP 调用中使用的数据库名称，通常对应 ShardingSphere-Proxy 暴露的逻辑库。
```yaml
runtimeDatabases:
@@ -53,23 +53,23 @@ runtimeDatabases:
字段说明：
-- `databaseType`：必填，声明数据库类型，例如 `MySQL`、`PostgreSQL`、`H2`。
-- `jdbcUrl`：必填，MCP runtime 连接逻辑库的 JDBC URL。
+- `databaseType`：必填，声明数据库类型，例如 `MySQL` 或 `PostgreSQL`。
+- `jdbcUrl`：必填，MCP Server 连接数据库的 JDBC URL。
- `username`：必填字段；无用户名时写空字符串 `""`。
- `password`：必填字段；无密码时写空字符串 `""`。
- `driverClassName`：必填字段；如果 JDBC 4 驱动可自动注册且不需要显式覆盖，写空字符串 `""`。
注意事项：
-- MCP resources 暴露的是 ShardingSphere 逻辑库，不是底层物理存储单元。
-- 加密和脱敏插件的 workflow 应连接 ShardingSphere-Proxy 暴露的逻辑库。
-- Schema、table、view、index 和 sequence metadata 依赖目标 JDBC metadata。
-- 非 H2 数据库通常需要把目标 JDBC driver jar 放入 `plugins/`。
+- MCP 资源暴露的是 ShardingSphere 逻辑库，不是底层物理存储单元。
+- 加密和脱敏插件的工作流应连接 ShardingSphere-Proxy 暴露的逻辑库。
+- Schema、table、view、index 和 sequence 等元数据依赖目标数据库的 JDBC 元数据。
+- 如果目标 JDBC 驱动没有随发行包提供，请把驱动 jar 放入 `plugins/`。
## 插件目录
-发行包默认把官方 MCP 基线 jar 放入 `lib/`，包括 Encrypt 和 Mask feature。
-如果目标数据库驱动或额外 MCP feature jar 没有随发行包提供，请放入发行包根目录下的 `plugins/`，再启动 runtime。
+发行包默认把 MCP Server 依赖和官方功能插件 jar 放入 `lib/`，包括 Encrypt 和 Mask 插件。
+如果目标数据库驱动或额外 MCP 功能插件 jar 没有随发行包提供，请放入发行包根目录下的 `plugins/`，再启动 MCP Server。
## 自定义配置文件
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/configuration.en.md
b/docs/document/content/user-manual/shardingsphere-mcp/configuration.en.md
index 2909e56d294..2b3abd3a58a 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/configuration.en.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/configuration.en.md
@@ -3,12 +3,12 @@ title = "Configuration"
weight = 2
+++
-ShardingSphere-MCP uses YAML files to configure the transport and runtime
logical databases.
+ShardingSphere-MCP uses YAML files to configure the transport and the
databases that the MCP Server can connect to.
The packaged distribution reads `conf/mcp-http.yaml` by default and also ships
`conf/mcp-stdio.yaml`.
## Transport configuration
-Each MCP runtime process must select exactly one transport.
+Each MCP Server process must select exactly one transport.
HTTP example:
@@ -36,10 +36,10 @@ Notes:
- `127.0.0.1`, `localhost`, and `::1` are local-only bindings.
- `0.0.0.0` or a specific intranet IP exposes the matching network interface.
-## Runtime Databases
+## Database configuration
-`runtimeDatabases` defines the ShardingSphere logical databases visible to the
MCP runtime.
-Each entry key is the logical database name exposed through MCP.
+`runtimeDatabases` defines the databases that the MCP Server can connect to
and expose through MCP.
+Each entry key is the database name used in MCP calls. It usually maps to a
logical database exposed by ShardingSphere-Proxy.
```yaml
runtimeDatabases:
@@ -53,8 +53,8 @@ runtimeDatabases:
Fields:
-- `databaseType`: required database type, such as `MySQL`, `PostgreSQL`, or
`H2`.
-- `jdbcUrl`: required JDBC URL used by the MCP runtime to connect to the
logical database.
+- `databaseType`: required database type, such as `MySQL` or `PostgreSQL`.
+- `jdbcUrl`: required JDBC URL used by the MCP Server to connect to the
database.
- `username`: required field; use an empty string `""` when no username is
needed.
- `password`: required field; use an empty string `""` when no password is
needed.
- `driverClassName`: required field; use an empty string `""` when a JDBC 4
driver auto-registers and no explicit override is needed.
@@ -64,12 +64,12 @@ Notes:
- MCP resources expose ShardingSphere logical databases, not physical storage
units.
- Encrypt and Mask plugin workflows should connect to logical databases
exposed by ShardingSphere-Proxy.
- Schema, table, view, index, and sequence metadata depends on target JDBC
metadata.
-- Non-H2 databases usually require the target JDBC driver jar under `plugins/`.
+- If the target JDBC driver is not packaged, copy the driver jar under
`plugins/`.
## Plugin directory
-The packaged distribution keeps the official MCP baseline jars under `lib/`,
including Encrypt and Mask features.
-If your target database driver or an extra MCP feature jar is not packaged,
copy it under the distribution `plugins/` directory before starting the runtime.
+The packaged distribution keeps MCP Server dependencies and official feature
plugin jars under `lib/`, including Encrypt and Mask plugins.
+If your target database driver or an extra MCP feature plugin jar is not
packaged, copy it under the distribution `plugins/` directory before starting
the MCP Server.
## Custom configuration file
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/deployment.cn.md
b/docs/document/content/user-manual/shardingsphere-mcp/deployment.cn.md
index 51df90f0de3..771b8763e36 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/deployment.cn.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/deployment.cn.md
@@ -16,11 +16,10 @@ ShardingSphere-MCP 可以通过源码构建的独立发行包运行，也可以
发行包目录包含：
- `bin/`：启动脚本。
-- `conf/`：默认配置、日志配置和 demo SQL。
-- `lib/`：官方运行时依赖和内置 MCP feature。
-- `plugins/`：外部 JDBC driver 或额外 MCP feature jar。
+- `conf/`：默认配置和日志配置。
+- `lib/`：MCP Server 依赖和内置 MCP 功能插件。
+- `plugins/`：外部 JDBC 驱动或额外 MCP 功能插件 jar。
- `logs/`：运行日志。
-- `data/`：demo runtime 使用的数据目录。
## OCI 镜像
@@ -56,9 +55,11 @@ docker run --rm -p 18088:18088 \
ghcr.io/apache/shardingsphere-mcp:${latest.release.version}
```
+配置文件中的 `runtimeDatabases` 需要指向用户已准备好的 ShardingSphere-Proxy 逻辑库。
+
## 安全部署建议
-内置 HTTP runtime 不提供认证和授权。
+内置 HTTP Server 不提供认证和授权。
如果需要远程访问，应放在受信网络、反向代理或网关后面，由外层组件处理：
- TLS 终止。
@@ -71,7 +72,7 @@ HTTP 绑定建议：
- 本地调试使用 `127.0.0.1`。
- 容器或内网部署使用受控网络接口。
-- 面向远程 client 暴露时，避免直接裸露 MCP runtime。
+- 面向远程客户端暴露时，避免直接裸露 MCP Server。
## 日志
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/deployment.en.md
b/docs/document/content/user-manual/shardingsphere-mcp/deployment.en.md
index 5e5588ce53c..4440fc64bf0 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/deployment.en.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/deployment.en.md
@@ -16,11 +16,10 @@ Build the distribution:
The distribution directory contains:
- `bin/`: startup scripts.
-- `conf/`: default configuration, logging configuration, and demo SQL.
-- `lib/`: official runtime dependencies and built-in MCP features.
-- `plugins/`: external JDBC drivers or extra MCP feature jars.
+- `conf/`: default configuration and logging configuration.
+- `lib/`: MCP Server dependencies and built-in MCP feature plugins.
+- `plugins/`: external JDBC drivers or extra MCP feature plugin jars.
- `logs/`: runtime logs.
-- `data/`: data directory used by the demo runtime.
## OCI image
@@ -56,9 +55,11 @@ docker run --rm -p 18088:18088 \
ghcr.io/apache/shardingsphere-mcp:${latest.release.version}
```
+`runtimeDatabases` in the configuration file must point to a
ShardingSphere-Proxy logical database prepared by the user.
+
## Secure deployment
-The built-in HTTP runtime does not provide authentication or authorization.
+The built-in HTTP Server does not provide authentication or authorization.
For remote access, place it in a trusted network or behind a reverse proxy or
gateway that handles:
- TLS termination.
@@ -71,7 +72,7 @@ HTTP binding recommendations:
- Use `127.0.0.1` for local debugging.
- Use a controlled network interface for container or intranet deployments.
-- Avoid exposing the MCP runtime directly to remote clients.
+- Avoid exposing the MCP Server directly to remote clients.
## Logs
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/features/_index.cn.md
b/docs/document/content/user-manual/shardingsphere-mcp/features/_index.cn.md
index 349d5845f4e..d843dd5d7b1 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/features/_index.cn.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/features/_index.cn.md
@@ -1,16 +1,16 @@
+++
-title = "Feature Plugins"
+title = "功能插件"
weight = 7
chapter = true
+++
-ShardingSphere-MCP 通过 feature plugin 扩展领域能力。
-MCP runtime 负责 transport、session、descriptor discovery、metadata 和 workflow
基础设施；feature plugin 负责提供具体 tools、resources 和业务语义。
+ShardingSphere-MCP 通过功能插件扩展领域能力。
+MCP Server 负责传输方式、会话、描述符发现、元数据和工作流基础设施；功能插件负责提供具体工具、资源和业务语义。
-发行包默认包含以下官方 MCP feature plugin：
+发行包默认包含以下官方 MCP 功能插件：
- Encrypt：规划、执行和校验数据加密规则。
- Mask：规划、执行和校验数据脱敏规则。
-新增或第三方 feature plugin 可以通过 `plugins/` 目录加入运行时 classpath。
-如果 feature plugin 未随发行包提供，启动前需要同时准备它依赖的 ShardingSphere 模块和第三方 jar。
+新增或第三方功能插件可以通过 `plugins/` 目录加入运行时类路径。
+如果功能插件未随发行包提供，启动前需要同时准备它依赖的 ShardingSphere 模块和第三方 jar。
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/features/_index.en.md
b/docs/document/content/user-manual/shardingsphere-mcp/features/_index.en.md
index c86aa3377fa..b43815f369a 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/features/_index.en.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/features/_index.en.md
@@ -5,7 +5,7 @@ chapter = true
+++
ShardingSphere-MCP extends domain capabilities through feature plugins.
-The MCP runtime provides transport, sessions, descriptor discovery, metadata,
and workflow infrastructure. Feature plugins provide concrete tools, resources,
and business semantics.
+The MCP Server provides transport, sessions, descriptor discovery, metadata,
and workflow infrastructure. Feature plugins provide concrete tools, resources,
and business semantics.
The packaged distribution includes these official MCP feature plugins:
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/features/encrypt.cn.md
b/docs/document/content/user-manual/shardingsphere-mcp/features/encrypt.cn.md
index 392fb2969f0..fe7fa99c57d 100644
---
a/docs/document/content/user-manual/shardingsphere-mcp/features/encrypt.cn.md
+++
b/docs/document/content/user-manual/shardingsphere-mcp/features/encrypt.cn.md
@@ -3,28 +3,28 @@ title = "Encrypt"
weight = 1
+++
-Encrypt MCP feature 帮助 MCP client 把加密需求规划成 ShardingSphere-Proxy 可执行的
DDL、DistSQL、索引计划和校验步骤。
-它不在 MCP runtime 内实现加密算法，而是面向 ShardingSphere 逻辑库生成和执行加密规则变更。
+Encrypt MCP 功能插件帮助 MCP 客户端把加密需求规划成 ShardingSphere-Proxy 可执行的
DDL、DistSQL、索引计划和校验步骤。
+它不在 MCP Server 内实现加密算法，而是面向 ShardingSphere 逻辑库生成和执行加密规则变更。
## 前置条件
- 当前版本只支持连接 ShardingSphere-Proxy 暴露的逻辑库。
- `runtimeDatabases` 应指向 Proxy 逻辑库，而不是底层物理存储库。
-- 目标逻辑表和逻辑列应能通过 JDBC metadata 发现。
-- 当前 feature 不处理存量数据迁移或回填。
+- 目标逻辑表和逻辑列应能通过 JDBC 元数据发现。
+- 当前功能插件不处理存量数据迁移或回填。
-## Public Surface
+## 可调用能力
-Planning tool：
+规划工具：
- `database_gateway_plan_encrypt_rule`
-通用 workflow tools：
+通用工作流工具：
- `database_gateway_apply_workflow`
- `database_gateway_validate_workflow`
-Resources：
+资源：
- `shardingsphere://features/encrypt/algorithms`
- `shardingsphere://features/encrypt/databases/{database}/rules`
@@ -82,7 +82,7 @@ Resources：
- `index_plan` 可能包含辅助查询索引。
如果返回 `clarifying`，继续使用同一个 `plan_id` 补齐缺失字段。
-敏感字段不会明文回显，应通过 secret manager、受保护环境变量或运维控制通道取得后再继续。
+敏感字段不会明文回显，应通过密钥管理系统、受保护环境变量或运维控制通道取得后再继续。
## 派生列规则
@@ -105,7 +105,7 @@ Resources：
}
```
-确认 artifacts 后执行：
+确认变更产物后执行：
```json
{
@@ -154,7 +154,7 @@ Resources：
}
```
-如果同一张表仍有其他加密列，MCP 会生成保留 sibling rules 的 `ALTER ENCRYPT RULE`。
+如果同一张表仍有其他加密列，MCP 会生成保留同表其他规则的 `ALTER ENCRYPT RULE`。
只有目标表不再剩余任何 encrypt 列时，才会生成 `DROP ENCRYPT RULE`。
## 限制
@@ -164,4 +164,4 @@ Resources：
- `drop` 只删除规则，不自动清理物理派生列和索引。
- 不处理存量数据迁移或回填。
- 不提供自动回滚能力。
-- 规划输入只接受标准未加引号的逻辑 identifier。
+- 规划输入只接受标准未加引号的逻辑标识符。
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/features/encrypt.en.md
b/docs/document/content/user-manual/shardingsphere-mcp/features/encrypt.en.md
index 96461dce296..6a74863f277 100644
---
a/docs/document/content/user-manual/shardingsphere-mcp/features/encrypt.en.md
+++
b/docs/document/content/user-manual/shardingsphere-mcp/features/encrypt.en.md
@@ -4,7 +4,7 @@ weight = 1
+++
The Encrypt MCP feature helps MCP clients plan encryption requirements into
DDL, DistSQL, index plans, and validation steps executable through
ShardingSphere-Proxy.
-It does not implement encryption algorithms inside the MCP runtime. It
generates and applies encryption rule changes for ShardingSphere logical
databases.
+It does not implement encryption algorithms inside the MCP Server. It
generates and applies encryption rule changes for ShardingSphere logical
databases.
## Prerequisites
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/features/mask.cn.md
b/docs/document/content/user-manual/shardingsphere-mcp/features/mask.cn.md
index 5b37fe7743e..378257a3c07 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/features/mask.cn.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/features/mask.cn.md
@@ -3,27 +3,27 @@ title = "Mask"
weight = 2
+++
-Mask MCP feature 帮助 MCP client 把脱敏需求规划成 ShardingSphere-Proxy 可执行的 DistSQL
和校验步骤。
-脱敏规则直接作用于逻辑列，不生成加密 feature 使用的物理派生列。
+Mask MCP 功能插件帮助 MCP 客户端把脱敏需求规划成 ShardingSphere-Proxy 可执行的 DistSQL 和校验步骤。
+脱敏规则直接作用于逻辑列，不生成加密功能使用的物理派生列。
## 前置条件
- 当前版本只支持连接 ShardingSphere-Proxy 暴露的逻辑库。
- `runtimeDatabases` 应指向 Proxy 逻辑库，而不是底层物理存储库。
-- 目标逻辑表和逻辑列应能通过 JDBC metadata 发现。
+- 目标逻辑表和逻辑列应能通过 JDBC 元数据发现。
-## Public Surface
+## 可调用能力
-Planning tool：
+规划工具：
- `database_gateway_plan_mask_rule`
-通用 workflow tools：
+通用工作流工具：
- `database_gateway_apply_workflow`
- `database_gateway_validate_workflow`
-Resources：
+资源：
- `shardingsphere://features/mask/algorithms`
- `shardingsphere://features/mask/databases/{database}/rules`
@@ -98,7 +98,7 @@ Resources：
}
```
-确认 artifacts 后执行：
+确认变更产物后执行：
```json
{
@@ -146,7 +146,7 @@ Resources：
}
```
-如果同一张表仍有其他脱敏列，MCP 会生成保留 sibling rules 的 `ALTER MASK RULE`。
+如果同一张表仍有其他脱敏列，MCP 会生成保留同表其他规则的 `ALTER MASK RULE`。
只有目标表不再剩余任何 mask 列时，才会生成 `DROP MASK RULE`。
## 限制
@@ -155,4 +155,4 @@ Resources：
- 支持 `create`、`alter`、`drop`。
- 不生成物理派生列。
- 不提供自动回滚能力。
-- 规划输入只接受标准未加引号的逻辑 identifier。
+- 规划输入只接受标准未加引号的逻辑标识符。
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/quick-start.cn.md
b/docs/document/content/user-manual/shardingsphere-mcp/quick-start.cn.md
index 2dbbc0cd79e..84754c43d6a 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/quick-start.cn.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/quick-start.cn.md
@@ -3,74 +3,83 @@ title = "快速开始"
weight = 1
+++
-本节使用发行包内置的 H2 demo runtime 验证 ShardingSphere-MCP 的 HTTP transport、metadata
discovery 和只读 SQL 查询。
+本页演示如何从源码构建 ShardingSphere-MCP，连接一个用户已准备好的 ShardingSphere-Proxy 逻辑库，并通过 HTTP
验证元数据读取和只读 SQL 查询。
+文中的 `logic_db`、`sample_table`、用户名和密码都是占位符；运行前请替换为自己的逻辑库、表和账号。
## 前置条件
- `JAVA_HOME` 或 `PATH` 中可用的 JDK 21。
-- 仓库根目录下的 Maven Wrapper。
-- 类 Unix Shell，并包含 `curl`、`find`、`mktemp`、`sed` 和 `tr`。
+- 一个可通过 JDBC 访问的 ShardingSphere-Proxy 逻辑库。
+- `curl`，用于发送 HTTP 请求。
+- 支持 sh/bash 语法的终端。
## 构建发行包
+在仓库根目录执行：
+
```bash
./mvnw -pl distribution/mcp -am -DskipTests package
```
-解析发行包目录：
+进入发行包目录：
```bash
-DIST_DIR=$(find distribution/mcp/target -maxdepth 1 -type d -name
'apache-shardingsphere-mcp-*' | sed -n '1p')
-echo "${DIST_DIR}"
+cd distribution/mcp/target/apache-shardingsphere-mcp-*
```
预期结果：
-- 命令打印一个非空发行包目录。
-- 该目录包含 `bin/`、`conf/`、`lib/`。
+- 当前目录包含 `bin/`、`conf/`、`lib/`。
-## 启动 HTTP runtime
+## 配置数据库
-```bash
-cd "${DIST_DIR}"
-bin/start.sh
+编辑 `conf/mcp-http.yaml`，将 `runtimeDatabases` 指向已有的 ShardingSphere-Proxy 逻辑库：
+
+```yaml
+runtimeDatabases:
+ logic_db:
+ databaseType: MySQL
+ jdbcUrl:
"jdbc:mysql://127.0.0.1:3307/logic_db?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC"
+ username: "proxy_user"
+ password: "proxy_password"
+ driverClassName: "com.mysql.cj.jdbc.Driver"
```
-Windows 使用：
+如果目标数据库驱动没有随发行包提供，请在启动前把对应 JDBC 驱动 jar 放入 `plugins/`。
-```bat
-cd /d "%DIST_DIR%"
-bin\start.bat
+## 启动 HTTP MCP Server
+
+```bash
+bin/start.sh > logs/mcp-http.log 2>&1 &
+MCP_PID=$!
```
默认配置文件是 `conf/mcp-http.yaml`，默认端点是 `http://127.0.0.1:18088/mcp`。
-进程以前台方式运行，日志写入 `logs/` 目录。
-请保持当前终端不退出，并在第二个终端执行后续 `curl` 命令。
+上面的命令会在当前终端后台启动 MCP Server，并把进程号保存到 `MCP_PID`，方便最后停止服务。
-发行包内置 demo runtime 暴露两个逻辑库：`orders` 和 `billing`。
-它们使用发行包自带 H2 驱动和 `data/` 下的种子数据。
-
-## 初始化 MCP session
+## 初始化 MCP 会话
```bash
-INIT_HEADERS=$(mktemp)
-curl -sS -D "${INIT_HEADERS}" -o /dev/null http://127.0.0.1:18088/mcp \
+curl -i -sS http://127.0.0.1:18088/mcp \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
- --data
'{"jsonrpc":"2.0","id":"init-1","method":"initialize","params":{"capabilities":{},"clientInfo":{"name":"curl-demo","version":"1.0.0"}}}'
-SESSION_ID=$(sed -n 's/^[Mm][Cc][Pp]-[Ss]ession-[Ii][Dd]: //p'
"${INIT_HEADERS}" | tr -d '\r')
-PROTOCOL_VERSION=$(sed -n 's/^[Mm][Cc][Pp]-[Pp]rotocol-[Vv]ersion: //p'
"${INIT_HEADERS}" | tr -d '\r')
-rm -f "${INIT_HEADERS}"
-printf 'SESSION_ID=%s\nPROTOCOL_VERSION=%s\n' "${SESSION_ID}"
"${PROTOCOL_VERSION}"
+ --data
'{"jsonrpc":"2.0","id":"init-1","method":"initialize","params":{"capabilities":{},"clientInfo":{"name":"curl-client","version":"1.0.0"}}}'
```
预期结果：
-- `SESSION_ID` 非空。
-- `PROTOCOL_VERSION` 非空。
-- 后续 HTTP 请求必须携带这两个 header。
+- 响应头包含 `MCP-Session-Id`。
+- 响应头包含 `MCP-Protocol-Version`。
+- 后续 HTTP 请求必须携带这两个响应头。
+
+从响应头复制取值，并在当前终端设置变量：
+
+```bash
+export SESSION_ID="<MCP-Session-Id value>"
+export PROTOCOL_VERSION="<MCP-Protocol-Version value>"
+```
-## 读取 metadata resource
+## 读取元数据资源
```bash
curl -sS http://127.0.0.1:18088/mcp \
@@ -78,16 +87,16 @@ curl -sS http://127.0.0.1:18088/mcp \
-H 'Accept: application/json, text/event-stream' \
-H "MCP-Session-Id: ${SESSION_ID}" \
-H "MCP-Protocol-Version: ${PROTOCOL_VERSION}" \
- --data
'{"jsonrpc":"2.0","id":"resource-1","method":"resources/read","params":{"uri":"shardingsphere://databases/orders/schemas/public/tables"}}'
+ --data
'{"jsonrpc":"2.0","id":"resource-1","method":"resources/read","params":{"uri":"shardingsphere://databases"}}'
```
预期结果：
- 响应类型是 `text/event-stream`。
-- JSON payload 位于 `data:` 行。
-- 返回内容包含 `orders`、`order_items`、`active_orders`。
+- JSON 负载位于 `data:` 行。
+- 返回内容包含 `logic_db`。
-## 搜索 metadata
+## 搜索元数据
```bash
curl -sS http://127.0.0.1:18088/mcp \
@@ -95,13 +104,13 @@ curl -sS http://127.0.0.1:18088/mcp \
-H 'Accept: application/json, text/event-stream' \
-H "MCP-Session-Id: ${SESSION_ID}" \
-H "MCP-Protocol-Version: ${PROTOCOL_VERSION}" \
- --data
'{"jsonrpc":"2.0","id":"tool-1","method":"tools/call","params":{"name":"database_gateway_search_metadata","arguments":{"database":"orders","query":"order","object_types":["table","view"]}}}'
+ --data
'{"jsonrpc":"2.0","id":"tool-1","method":"tools/call","params":{"name":"database_gateway_search_metadata","arguments":{"database":"logic_db","query":"sample","object_types":["table","view"]}}}'
```
预期结果：
-- JSON payload 包含匹配到的表或视图。
-- 结果项会携带可继续读取的 resource hint。
+- JSON 负载包含匹配到的表或视图。
+- 结果项可包含后续读取用的资源提示。
## 执行只读查询
@@ -118,9 +127,8 @@ curl -sS http://127.0.0.1:18088/mcp \
"params":{
"name":"database_gateway_execute_query",
"arguments":{
- "database":"orders",
- "schema":"public",
- "sql":"SELECT status FROM orders ORDER BY order_id",
+ "database":"logic_db",
+ "sql":"SELECT * FROM sample_table LIMIT 10",
"max_rows":10
}
}
@@ -131,15 +139,16 @@ curl -sS http://127.0.0.1:18088/mcp \
- `result_kind` 为 `result_set`。
- `statement_class` 为 `query`。
-- payload 包含 `columns`、`rows` 或 `row_objects`。
+- 负载包含 `columns`、`rows` 或 `row_objects`。
-## 关闭 session
+## 关闭会话并停止服务
```bash
curl -sS -D - -o /dev/null \
-X DELETE http://127.0.0.1:18088/mcp \
-H "MCP-Session-Id: ${SESSION_ID}" \
-H "MCP-Protocol-Version: ${PROTOCOL_VERSION}"
+kill "${MCP_PID}"
```
预期结果：
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/quick-start.en.md
b/docs/document/content/user-manual/shardingsphere-mcp/quick-start.en.md
index 8ee24ecd8c3..b7a13b81313 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/quick-start.en.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/quick-start.en.md
@@ -3,72 +3,81 @@ title = "Quick Start"
weight = 1
+++
-This section uses the packaged H2 demo runtime to verify the
ShardingSphere-MCP HTTP transport, metadata discovery, and read-only SQL query
behavior.
+This page shows how to build ShardingSphere-MCP from source, connect to a
ShardingSphere-Proxy logical database prepared by the user, and verify metadata
reads and read-only SQL queries over HTTP.
+`logic_db`, `sample_table`, username, and password are placeholders. Replace
them with your own logical database, table, and account before running the
commands.
## Prerequisites
- JDK 21 available from `JAVA_HOME` or `PATH`.
-- Maven Wrapper from the repository root.
-- A Unix-like shell with `curl`, `find`, `mktemp`, `sed`, and `tr`.
+- A ShardingSphere-Proxy logical database reachable through JDBC.
+- `curl` for HTTP requests.
+- A terminal that supports sh/bash syntax.
## Build the distribution
+Run from the repository root:
+
```bash
./mvnw -pl distribution/mcp -am -DskipTests package
```
-Resolve the distribution directory:
+Enter the distribution directory:
```bash
-DIST_DIR=$(find distribution/mcp/target -maxdepth 1 -type d -name
'apache-shardingsphere-mcp-*' | sed -n '1p')
-echo "${DIST_DIR}"
+cd distribution/mcp/target/apache-shardingsphere-mcp-*
```
Expected result:
-- The command prints a non-empty distribution directory.
-- The directory contains `bin/`, `conf/`, and `lib/`.
+- The current directory contains `bin/`, `conf/`, and `lib/`.
-## Start the HTTP runtime
+## Configure the database
-```bash
-cd "${DIST_DIR}"
-bin/start.sh
+Edit `conf/mcp-http.yaml` and point `runtimeDatabases` to an existing
ShardingSphere-Proxy logical database:
+
+```yaml
+runtimeDatabases:
+ logic_db:
+ databaseType: MySQL
+ jdbcUrl:
"jdbc:mysql://127.0.0.1:3307/logic_db?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC"
+ username: "proxy_user"
+ password: "proxy_password"
+ driverClassName: "com.mysql.cj.jdbc.Driver"
```
-On Windows:
+If the target database driver is not packaged, copy the corresponding JDBC
driver jar to `plugins/` before startup.
-```bat
-cd /d "%DIST_DIR%"
-bin\start.bat
+## Start the HTTP MCP Server
+
+```bash
+bin/start.sh > logs/mcp-http.log 2>&1 &
+MCP_PID=$!
```
The default configuration file is `conf/mcp-http.yaml`, and the default
endpoint is `http://127.0.0.1:18088/mcp`.
-The process runs in the foreground and writes logs under `logs/`.
-Keep this terminal open, and run the following `curl` commands in a second
terminal.
-
-The packaged demo runtime exposes two logical databases: `orders` and
`billing`.
-They use the packaged H2 driver and seed data under `data/`.
+The command above starts the MCP Server in the background and stores the
process id in `MCP_PID` so it can be stopped at the end.
## Initialize an MCP session
```bash
-INIT_HEADERS=$(mktemp)
-curl -sS -D "${INIT_HEADERS}" -o /dev/null http://127.0.0.1:18088/mcp \
+curl -i -sS http://127.0.0.1:18088/mcp \
-H 'Content-Type: application/json' \
-H 'Accept: application/json, text/event-stream' \
- --data
'{"jsonrpc":"2.0","id":"init-1","method":"initialize","params":{"capabilities":{},"clientInfo":{"name":"curl-demo","version":"1.0.0"}}}'
-SESSION_ID=$(sed -n 's/^[Mm][Cc][Pp]-[Ss]ession-[Ii][Dd]: //p'
"${INIT_HEADERS}" | tr -d '\r')
-PROTOCOL_VERSION=$(sed -n 's/^[Mm][Cc][Pp]-[Pp]rotocol-[Vv]ersion: //p'
"${INIT_HEADERS}" | tr -d '\r')
-rm -f "${INIT_HEADERS}"
-printf 'SESSION_ID=%s\nPROTOCOL_VERSION=%s\n' "${SESSION_ID}"
"${PROTOCOL_VERSION}"
+ --data
'{"jsonrpc":"2.0","id":"init-1","method":"initialize","params":{"capabilities":{},"clientInfo":{"name":"curl-client","version":"1.0.0"}}}'
```
Expected result:
-- `SESSION_ID` is not empty.
-- `PROTOCOL_VERSION` is not empty.
-- Later HTTP requests must include both headers.
+- The response headers include `MCP-Session-Id`.
+- The response headers include `MCP-Protocol-Version`.
+- Later HTTP requests must include both response headers.
+
+Copy the values from the response headers and set them in the current terminal:
+
+```bash
+export SESSION_ID="<MCP-Session-Id value>"
+export PROTOCOL_VERSION="<MCP-Protocol-Version value>"
+```
## Read a metadata resource
@@ -78,14 +87,14 @@ curl -sS http://127.0.0.1:18088/mcp \
-H 'Accept: application/json, text/event-stream' \
-H "MCP-Session-Id: ${SESSION_ID}" \
-H "MCP-Protocol-Version: ${PROTOCOL_VERSION}" \
- --data
'{"jsonrpc":"2.0","id":"resource-1","method":"resources/read","params":{"uri":"shardingsphere://databases/orders/schemas/public/tables"}}'
+ --data
'{"jsonrpc":"2.0","id":"resource-1","method":"resources/read","params":{"uri":"shardingsphere://databases"}}'
```
Expected result:
- The response type is `text/event-stream`.
- The JSON payload is in the `data:` line.
-- The payload contains `orders`, `order_items`, and `active_orders`.
+- The payload contains `logic_db`.
## Search metadata
@@ -95,7 +104,7 @@ curl -sS http://127.0.0.1:18088/mcp \
-H 'Accept: application/json, text/event-stream' \
-H "MCP-Session-Id: ${SESSION_ID}" \
-H "MCP-Protocol-Version: ${PROTOCOL_VERSION}" \
- --data
'{"jsonrpc":"2.0","id":"tool-1","method":"tools/call","params":{"name":"database_gateway_search_metadata","arguments":{"database":"orders","query":"order","object_types":["table","view"]}}}'
+ --data
'{"jsonrpc":"2.0","id":"tool-1","method":"tools/call","params":{"name":"database_gateway_search_metadata","arguments":{"database":"logic_db","query":"sample","object_types":["table","view"]}}}'
```
Expected result:
@@ -118,9 +127,8 @@ curl -sS http://127.0.0.1:18088/mcp \
"params":{
"name":"database_gateway_execute_query",
"arguments":{
- "database":"orders",
- "schema":"public",
- "sql":"SELECT status FROM orders ORDER BY order_id",
+ "database":"logic_db",
+ "sql":"SELECT * FROM sample_table LIMIT 10",
"max_rows":10
}
}
@@ -133,13 +141,14 @@ Expected result:
- `statement_class` is `query`.
- The payload contains `columns`, `rows`, or `row_objects`.
-## Close the session
+## Close the session and stop the server
```bash
curl -sS -D - -o /dev/null \
-X DELETE http://127.0.0.1:18088/mcp \
-H "MCP-Session-Id: ${SESSION_ID}" \
-H "MCP-Protocol-Version: ${PROTOCOL_VERSION}"
+kill "${MCP_PID}"
```
Expected result:
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/troubleshooting.cn.md
b/docs/document/content/user-manual/shardingsphere-mcp/troubleshooting.cn.md
index 71f7969e0dc..ec000a43142 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/troubleshooting.cn.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/troubleshooting.cn.md
@@ -3,8 +3,8 @@ title = "常见问题"
weight = 6
+++
-本节只覆盖 MCP runtime、transport、session、SQL tool 和 workflow 机制的通用问题。
-插件业务问题请查看对应 feature plugin 文档。
+这里汇总 MCP Server、传输方式、会话、SQL 工具和工作流机制的常见问题。
+插件业务问题请查看对应功能插件文档。
## 启动失败
@@ -14,7 +14,6 @@ weight = 6
- 配置文件路径是否正确。
- `conf/mcp-http.yaml` 或 `conf/mcp-stdio.yaml` 是否存在。
- YAML 是否包含不受支持字段。
-- `runtimeDatabases` 是否缺失或为空。
- `username`、`password`、`driverClassName` 是否显式写出；不需要值时写空字符串 `""`。
启动失败时，先查看终端错误和 `logs/mcp.log`。
@@ -26,7 +25,7 @@ weight = 6
- 默认端点是否为 `http://127.0.0.1:18088/mcp`。
- 端口是否被占用。
- `transport.type` 是否为 `STREAMABLE_HTTP`。
-- `transport.http.endpointPath` 是否和 client URL 一致。
+- `transport.http.endpointPath` 是否和客户端 URL 一致。
- 绑定 `127.0.0.1` 时，远程机器无法直接访问。
- 绑定 `0.0.0.0` 时，应由外层网关处理鉴权和网络访问控制。
@@ -34,34 +33,34 @@ weight = 6
Origin 校验规则：
-- loopback 绑定下，如果请求带 `Origin`，该 Origin 也必须是 loopback。
-- 非 loopback 绑定下，缺失 `Origin` 的非浏览器请求会被接受。
-- 非 loopback 绑定下，任何显式 `Origin` 都会被拒绝。
+- 回环地址绑定下，如果请求带 `Origin`，该 Origin 也必须是回环地址。
+- 非回环地址绑定下，缺失 `Origin` 的非浏览器请求会被接受。
+- 非回环地址绑定下，任何显式 `Origin` 都会被拒绝。
可选处理方式：
-- 调整 client 的 Origin 策略。
-- 使用本机 loopback 访问。
+- 调整客户端的 Origin 策略。
+- 使用本机回环地址访问。
- 通过受控网关转发请求。
-## Session 或协议头问题
+## 会话或协议头问题
-HTTP client 调用 `initialize` 后，必须保存：
+HTTP 客户端调用 `initialize` 后，必须保存：
- `MCP-Session-Id`
- `MCP-Protocol-Version`
-后续请求都要携带这两个 header。
-session 关闭后不能继续复用。
-Workflow 的 `plan_id` 也只在当前 session 内有效。
+后续请求都要携带这两个响应头。
+会话关闭后不能继续复用。
+工作流的 `plan_id` 也只在当前会话内有效。
## STDIO 模式没有响应
-STDIO 是给 MCP client 拉起子进程使用的，不是人工交互 shell。
+STDIO 是给 MCP 客户端拉起子进程使用的，不是人工交互 shell。
检查：
-- client 配置里的 `command` 是否指向 `bin/start.sh` 或 `bin\start.bat`。
+- 客户端配置里的 `command` 是否指向 `bin/start.sh` 或 `bin\start.bat`。
- `args` 是否包含 `conf/mcp-stdio.yaml`。
- stdout 是否被日志污染。
- 诊断信息应查看 stderr 或 `logs/mcp.log`。
@@ -73,20 +72,20 @@ STDIO 是给 MCP client 拉起子进程使用的，不是人工交互 shell。
- `runtimeDatabases` 是否配置了目标逻辑库。
- MCP 暴露的是 ShardingSphere 逻辑库，不是底层物理存储单元。
- `databaseType` 和 `jdbcUrl` 是否匹配目标逻辑库。
-- 目标 JDBC driver jar 是否位于 `plugins/`。
-- 连接用户是否有读取 JDBC metadata 的权限。
+- 目标 JDBC 驱动 jar 是否位于 `plugins/`。
+- 连接用户是否有读取 JDBC 元数据的权限。
-## JDBC driver 错误
+## JDBC 驱动错误
-发行包只内置有限的 JDBC driver。
-如果目标数据库 driver 缺失，请把对应 jar 放入 `plugins/`。
+发行包只内置有限的 JDBC 驱动。
+如果目标数据库驱动缺失，请把对应 jar 放入 `plugins/`。
-如果以嵌入方式使用 `shardingsphere-mcp-bootstrap`，需要把 driver 加到运行时 classpath。
+如果以嵌入方式使用 `shardingsphere-mcp-bootstrap`，需要把驱动加到运行时类路径。
`driverClassName` 字段必须显式存在。
-当 driver 可自动注册且不需要显式覆盖时，写 `""`。
+当驱动可自动注册且不需要显式覆盖时，写 `""`。
-## SQL tool 调用失败
+## SQL 工具调用失败
`database_gateway_execute_query` 只用于：
@@ -113,15 +112,15 @@ DML、DDL、DCL、事务控制、savepoint 和其他有副作用 SQL 应使用 `
- `max_rows` 范围是 `0..5000`。
- `timeout_ms` 范围是 `0..300000`。
-## Workflow 通用问题
+## 工作流通用问题
检查：
- 是否丢失 `plan_id`。
-- 是否换了 `MCP-Session-Id` 后继续 apply 或 validate。
+- 是否换了 `MCP-Session-Id` 后继续执行或校验。
- `database_gateway_apply_workflow` 是否传入 `execution_mode`。
- 使用 `manual-only` 后，是否已经人工执行返回的 SQL 或 DistSQL。
-- `approved_steps` 是否来自 preview 返回的 `preview_artifacts[].approval_step`。
+- `approved_steps` 是否来自预览结果返回的 `preview_artifacts[].approval_step`。
## 收集诊断信息
@@ -129,8 +128,8 @@ DML、DDL、DCL、事务控制、savepoint 和其他有副作用 SQL 应使用 `
- 启动命令。
- MCP 配置文件，注意移除密码和密钥。
-- transport 类型和 endpoint。
-- `MCP-Session-Id` 是否已初始化，注意不要公开真实敏感 header。
-- tool 或 resource 请求体。
-- JSON-RPC error payload。
+- 传输方式和端点。
+- `MCP-Session-Id` 是否已初始化，注意不要公开真实敏感响应头。
+- 工具或资源请求体。
+- JSON-RPC 错误负载。
- `logs/mcp.log` 中相关错误。
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/troubleshooting.en.md
b/docs/document/content/user-manual/shardingsphere-mcp/troubleshooting.en.md
index b030b4f3948..333fc66dc8c 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/troubleshooting.en.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/troubleshooting.en.md
@@ -3,7 +3,7 @@ title = "Troubleshooting"
weight = 6
+++
-This section covers common MCP runtime, transport, session, SQL tool, and
workflow mechanism issues.
+This page covers common MCP Server, transport, session, SQL tool, and workflow
mechanism issues.
For plugin-specific business issues, see the corresponding feature plugin
documentation.
## Startup failure
@@ -14,7 +14,6 @@ Check:
- The configuration file path is correct.
- `conf/mcp-http.yaml` or `conf/mcp-stdio.yaml` exists.
- The YAML file does not contain unsupported fields.
-- `runtimeDatabases` is present and not empty.
- `username`, `password`, and `driverClassName` are explicitly declared; use
an empty string `""` when no value is needed.
When startup fails, inspect the terminal error and `logs/mcp.log` first.
@@ -27,7 +26,7 @@ Check:
- The port is not occupied.
- `transport.type` is `STREAMABLE_HTTP`.
- `transport.http.endpointPath` matches the client URL.
-- Remote machines cannot access a runtime bound to `127.0.0.1` directly.
+- Remote machines cannot access an MCP Server bound to `127.0.0.1` directly.
- When binding to `0.0.0.0`, authentication and network access control should
be handled by an upstream gateway.
## HTTP 403 response
@@ -57,7 +56,7 @@ Workflow `plan_id` values are valid only in the current
session.
## No response in STDIO mode
-STDIO is for MCP clients that launch the runtime as a child process. It is not
an interactive shell.
+STDIO is for MCP clients that launch the MCP Server as a child process. It is
not an interactive shell.
Check:
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/workflow-basics.cn.md
b/docs/document/content/user-manual/shardingsphere-mcp/workflow-basics.cn.md
index fadb5fc3e42..715c8069bdc 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/workflow-basics.cn.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/workflow-basics.cn.md
@@ -1,63 +1,63 @@
+++
-title = "Workflow 基础"
+title = "工作流基础"
weight = 4
+++
-ShardingSphere-MCP 的 feature plugin 可以通过共享 workflow 机制实现复杂治理任务。
-Workflow 基础机制由 MCP runtime 提供，具体业务语义由插件提供。
+ShardingSphere-MCP 的功能插件可以通过共享工作流机制实现复杂治理任务。
+MCP Server 提供通用工作流机制，插件提供具体业务语义。
## 基本阶段
-一个典型 workflow 包含：
+一个典型工作流包含：
-1. 调用插件自己的 planning tool，生成计划并返回 `plan_id`。
+1. 调用插件自己的规划工具，生成计划并返回 `plan_id`。
2. 如果返回 `status = clarifying`，按 `clarification_questions` 补齐缺失输入。
-3. 如果返回 `status = planned`，审查生成的 artifacts。
+3. 如果返回 `status = planned`，审查生成的变更产物。
4. 调用 `database_gateway_apply_workflow` 并先使用 `execution_mode=preview`。
-5. 审查 preview 后，使用 `execution_mode=review-then-execute` 执行，或使用 `manual-only`
导出人工执行包。
+5. 审查预览结果后，使用 `execution_mode=review-then-execute` 执行，或使用 `manual-only`
导出人工执行包。
6. 调用 `database_gateway_validate_workflow` 校验最终状态。
-## Session 与 plan_id
+## 会话与 plan_id
-- `plan_id` 是当前 workflow 的句柄。
-- `plan_id` 只在当前 MCP session 内有效。
+- `plan_id` 是当前工作流的句柄。
+- `plan_id` 只在当前 MCP 会话内有效。
- `plan`、`apply`、`validate` 必须使用同一个 `MCP-Session-Id`。
-- 第一次 planning 调用不需要传 `plan_id`。
+- 第一次规划调用不需要传 `plan_id`。
- 后续补问、执行和校验必须继续传同一个 `plan_id`。
## 常见状态
- `clarifying`：信息不足，需要补齐参数。
-- `planned`：计划已生成，可以 review artifacts。
-- `completed`：apply 已执行完成。
-- `awaiting-manual-execution`：选择了 `manual-only`，需要人工执行返回的 artifacts。
-- `validated`：validate 已通过。
+- `planned`：计划已生成，可以审查变更产物。
+- `completed`：已执行完成。
+- `awaiting-manual-execution`：选择了 `manual-only`，需要人工执行返回的变更产物。
+- `validated`：校验已通过。
- `failed`：当前阶段失败，应查看 `issues`、`mismatches` 和 `recovery_guidance`。
## 执行模式
`database_gateway_apply_workflow` 必须显式传入 `execution_mode`：
-- `preview`：只预览 artifacts 和副作用范围，不修改 runtime。
-- `review-then-execute`：在 review 后执行 artifacts。
+- `preview`：只预览变更产物和副作用范围，不修改服务状态。
+- `review-then-execute`：在审查后执行变更产物。
- `manual-only`：不自动执行，返回人工执行包。
-如果使用 `approved_steps` 分步执行，只能使用 preview 返回的
`preview_artifacts[].approval_step` 值。
-未知 step 会被拒绝。
+如果使用 `approved_steps` 分步执行，只能使用预览结果返回的 `preview_artifacts[].approval_step` 值。
+未知步骤会被拒绝。
## 敏感输入
-插件可能要求补充 secret 字段，例如密钥或凭证。
+插件可能要求补充敏感字段，例如密钥或凭证。
带有 `secret: true`、`input_type: "secret"`，或字段名包含
password、token、key、secret、credential 的补问，不应通过普通表单明文回传。
推荐处理方式：
- 保留 `plan_id`。
-- 通过 secret manager、受保护环境变量或运维控制通道取得值。
-- 用同一个 `plan_id` 再次调用原 planning tool。
+- 通过密钥管理系统、受保护环境变量或运维控制通道取得值。
+- 用同一个 `plan_id` 再次调用原规划工具。
## 通用工具
-`database_gateway_apply_workflow` 和 `database_gateway_validate_workflow` 是通用
workflow 工具。
-它们不决定业务语义，只处理当前 session 中已存在的 workflow plan。
-具体 planning tool 由 feature plugin 提供。
+`database_gateway_apply_workflow` 和 `database_gateway_validate_workflow`
是通用工作流工具。
+它们不决定业务语义，只处理当前会话中已存在的工作流计划。
+具体规划工具由功能插件提供。
diff --git
a/docs/document/content/user-manual/shardingsphere-mcp/workflow-basics.en.md
b/docs/document/content/user-manual/shardingsphere-mcp/workflow-basics.en.md
index 31fd4579a24..7f58ea2b988 100644
--- a/docs/document/content/user-manual/shardingsphere-mcp/workflow-basics.en.md
+++ b/docs/document/content/user-manual/shardingsphere-mcp/workflow-basics.en.md
@@ -4,7 +4,7 @@ weight = 4
+++
ShardingSphere-MCP feature plugins can use the shared workflow mechanism to
implement complex governance tasks.
-The MCP runtime provides the common workflow mechanism, while each plugin
provides its own business semantics.
+The MCP Server provides the common workflow mechanism, while each plugin
provides its own business semantics.
## Basic phases
@@ -12,9 +12,9 @@ A typical workflow contains:
1. Call the plugin planning tool to create a plan and return `plan_id`.
2. If the response returns `status = clarifying`, provide the missing inputs
from `clarification_questions`.
-3. If the response returns `status = planned`, review the generated artifacts.
+3. If the response returns `status = planned`, review the generated change
artifacts.
4. Call `database_gateway_apply_workflow` with `execution_mode=preview` first.
-5. After reviewing the preview, call with
`execution_mode=review-then-execute`, or use `manual-only` to export an
artifact package.
+5. After reviewing the preview, call with
`execution_mode=review-then-execute`, or use `manual-only` to export a manual
execution package.
6. Call `database_gateway_validate_workflow` to validate the final state.
## Session and plan_id
@@ -28,9 +28,9 @@ A typical workflow contains:
## Common statuses
- `clarifying`: more input is required.
-- `planned`: the plan is ready and artifacts should be reviewed.
+- `planned`: the plan is ready and change artifacts should be reviewed.
- `completed`: apply has completed.
-- `awaiting-manual-execution`: `manual-only` was selected; execute the
returned artifacts manually.
+- `awaiting-manual-execution`: `manual-only` was selected; execute the
returned change artifacts manually.
- `validated`: validation passed.
- `failed`: the current phase failed; inspect `issues`, `mismatches`, and
`recovery_guidance`.
@@ -38,8 +38,8 @@ A typical workflow contains:
`database_gateway_apply_workflow` requires an explicit `execution_mode`:
-- `preview`: preview artifacts and side-effect scope without changing runtime
state.
-- `review-then-execute`: execute artifacts after review.
+- `preview`: preview change artifacts and side-effect scope without changing
server state.
+- `review-then-execute`: execute change artifacts after review.
- `manual-only`: export a manual artifact package without automatic execution.
When using `approved_steps` for partial execution, pass only values returned
by `preview_artifacts[].approval_step`.
diff --git
a/mcp/bootstrap/src/main/java/org/apache/shardingsphere/mcp/bootstrap/MCPRuntimeLauncher.java
b/mcp/bootstrap/src/main/java/org/apache/shardingsphere/mcp/bootstrap/MCPRuntimeLauncher.java
index 71a6d03221e..2384d02cd9d 100644
---
a/mcp/bootstrap/src/main/java/org/apache/shardingsphere/mcp/bootstrap/MCPRuntimeLauncher.java
+++
b/mcp/bootstrap/src/main/java/org/apache/shardingsphere/mcp/bootstrap/MCPRuntimeLauncher.java
@@ -34,7 +34,7 @@ import java.io.IOException;
import java.util.List;
/**
- * MCP runtime launcher.
+ * MCP Server launcher.
*/
@RequiredArgsConstructor
@Slf4j
@@ -48,7 +48,7 @@ public final class MCPRuntimeLauncher {
* Launch.
*
* @param config launch configuration
- * @return MCP runtime server
+ * @return MCP Server
* @throws IOException when the active server startup fails
*/
public MCPRuntimeServer launch(final MCPLaunchConfiguration config) throws
IOException {
@@ -74,12 +74,12 @@ public final class MCPRuntimeLauncher {
int port = server instanceof StreamableHttpMCPServer ?
((StreamableHttpMCPServer) server).getLocalPort() :
config.getHttpTransport().getPort();
String endpoint = String.format("http://%s:%d%s";,
config.getHttpTransport().getBindHost(), port,
config.getHttpTransport().getEndpointPath());
SessionAttributionResolver sessionAttributionResolver = new
SessionAttributionResolver(config.getHttpTransport().getSessionAttributionSource());
- return List.of(String.format("ShardingSphere MCP runtime started,
transport=http, config=%s, databases=%d, endpoint=%s, session_attribution=%s,
logs=%s.",
+ return List.of(String.format("ShardingSphere MCP Server started,
transport=http, config=%s, databases=%d, endpoint=%s, session_attribution=%s,
logs=%s.",
configPath, config.getDatabases().size(), endpoint,
sessionAttributionResolver.getSummary(), LOG_PATH));
}
private List<String> createStdioStartupLogMessages(final
MCPLaunchConfiguration config) {
- return List.of(String.format("ShardingSphere MCP runtime started,
transport=stdio, config=%s, databases=%d, logs=%s. Stdout is reserved for MCP
protocol frames.",
+ return List.of(String.format("ShardingSphere MCP Server started,
transport=stdio, config=%s, databases=%d, logs=%s. Stdout is reserved for MCP
protocol frames.",
configPath, config.getDatabases().size(), LOG_PATH));
}
diff --git
a/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/MCPLaunchConfigurationTest.java
b/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/MCPLaunchConfigurationTest.java
index 037aecb8286..a9c695960e0 100644
---
a/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/MCPLaunchConfigurationTest.java
+++
b/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/MCPLaunchConfigurationTest.java
@@ -134,8 +134,8 @@ class MCPLaunchConfigurationTest {
private Map<String, Map<String, Object>> createRuntimeDatabases() {
return Collections.singletonMap("logic_db", Map.of(
- "databaseType", "H2",
- "jdbcUrl", "jdbc:h2:mem:logic",
+ "databaseType", "MySQL",
+ "jdbcUrl", "jdbc:mysql://localhost:3306/logic_db",
"username", "",
"password", "",
"driverClassName", ""));
diff --git
a/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/loader/MCPConfigurationLoaderTest.java
b/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/loader/MCPConfigurationLoaderTest.java
index e6d5669723b..c2217a874b3 100644
---
a/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/loader/MCPConfigurationLoaderTest.java
+++
b/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/loader/MCPConfigurationLoaderTest.java
@@ -47,11 +47,11 @@ class MCPConfigurationLoaderTest {
endpointPath: /gateway
runtimeDatabases:
logic_db:
- databaseType: H2
- jdbcUrl: jdbc:h2:mem:logic
+ databaseType: MySQL
+ jdbcUrl: jdbc:mysql://localhost:3306/logic_db
username: ''
password: ''
- driverClassName: org.h2.Driver
+ driverClassName: com.mysql.cj.jdbc.Driver
""";
private static final String RUNTIME_DATABASE_CONFIGURATION_YAML = """
@@ -59,11 +59,11 @@ class MCPConfigurationLoaderTest {
type: STDIO
runtimeDatabases:
logic_db:
- databaseType: H2
- jdbcUrl: jdbc:h2:mem:logic
+ databaseType: MySQL
+ jdbcUrl: jdbc:mysql://localhost:3306/logic_db
username: ''
password: ''
- driverClassName: org.h2.Driver
+ driverClassName: com.mysql.cj.jdbc.Driver
""";
@TempDir
@@ -75,8 +75,8 @@ class MCPConfigurationLoaderTest {
MCPLaunchConfiguration actual =
MCPConfigurationLoader.load(configFile.toString());
assertThat(actual.getTransportType(), is(MCPTransportType.STDIO));
assertThat(actual.getDatabases().size(), is(1));
- assertThat(actual.getDatabases().get("logic_db").getDatabaseType(),
is("H2"));
- assertThat(actual.getDatabases().get("logic_db").getJdbcUrl(),
is("jdbc:h2:mem:logic"));
+ assertThat(actual.getDatabases().get("logic_db").getDatabaseType(),
is("MySQL"));
+ assertThat(actual.getDatabases().get("logic_db").getJdbcUrl(),
is("jdbc:mysql://localhost:3306/logic_db"));
}
@ParameterizedTest(name = "{0}")
diff --git
a/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlMCPLaunchConfigurationSwapperTest.java
b/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlMCPLaunchConfigurationSwapperTest.java
index 6bf14dab5d6..50627e1ce41 100644
---
a/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlMCPLaunchConfigurationSwapperTest.java
+++
b/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlMCPLaunchConfigurationSwapperTest.java
@@ -50,17 +50,17 @@ class YamlMCPLaunchConfigurationSwapperTest {
+ " endpointPath: /gateway\n"
+ "runtimeDatabases:\n"
+ " logic_db:\n"
- + " databaseType: H2\n"
- + " jdbcUrl: jdbc:h2:mem:logic\n"
+ + " databaseType: MySQL\n"
+ + " jdbcUrl: jdbc:mysql://localhost:3306/logic_db\n"
+ " username: demo\n"
+ " password: secret\n"
- + " driverClassName: org.h2.Driver\n";
+ + " driverClassName: com.mysql.cj.jdbc.Driver\n";
MCPLaunchConfiguration actual =
swapper.swapToObject(YamlEngine.unmarshal(yamlContent,
YamlMCPLaunchConfiguration.class));
assertThat(actual.getTransportType(),
is(MCPTransportType.STREAMABLE_HTTP));
assertThat(actual.getHttpTransport().getBindHost(), is("127.0.0.1"));
assertThat(actual.getHttpTransport().getPort(), is(9090));
assertThat(actual.getHttpTransport().getEndpointPath(),
is("/gateway"));
- assertThat(actual.getDatabases().get("logic_db").getDatabaseType(),
is("H2"));
+ assertThat(actual.getDatabases().get("logic_db").getDatabaseType(),
is("MySQL"));
assertThat(actual.getDatabases().get("logic_db").getUsername(),
is("demo"));
}
@@ -80,11 +80,11 @@ class YamlMCPLaunchConfigurationSwapperTest {
void assertSwapToObjectWithMissingTransportSection() {
IllegalArgumentException actual =
assertThrows(IllegalArgumentException.class, () ->
swapper.swapToObject(YamlEngine.unmarshal("runtimeDatabases:\n"
+ " logic_db:\n"
- + " databaseType: H2\n"
- + " jdbcUrl: jdbc:h2:mem:logic\n"
+ + " databaseType: MySQL\n"
+ + " jdbcUrl: jdbc:mysql://localhost:3306/logic_db\n"
+ " username: ''\n"
+ " password: ''\n"
- + " driverClassName: org.h2.Driver\n",
YamlMCPLaunchConfiguration.class)));
+ + " driverClassName: com.mysql.cj.jdbc.Driver\n",
YamlMCPLaunchConfiguration.class)));
assertThat(actual.getMessage(), is("MCP launch configuration property
`transport` is required."));
}
@@ -139,13 +139,13 @@ class YamlMCPLaunchConfigurationSwapperTest {
+ " type: STDIO\n"
+ "runtimeDatabases:\n"
+ " 1:\n"
- + " databaseType: H2\n"
- + " jdbcUrl: jdbc:h2:mem:logic\n"
+ + " databaseType: MySQL\n"
+ + " jdbcUrl: jdbc:mysql://localhost:3306/logic_db\n"
+ " username: ''\n"
+ " password: ''\n"
- + " driverClassName: org.h2.Driver\n";
+ + " driverClassName: com.mysql.cj.jdbc.Driver\n";
MCPLaunchConfiguration actual =
swapper.swapToObject(YamlEngine.unmarshal(yamlContent,
YamlMCPLaunchConfiguration.class));
- assertThat(actual.getDatabases().get("1").getDatabaseType(), is("H2"));
+ assertThat(actual.getDatabases().get("1").getDatabaseType(),
is("MySQL"));
}
@Test
@@ -154,11 +154,11 @@ class YamlMCPLaunchConfigurationSwapperTest {
+ " type: STDIO\n"
+ "runtimeDatabases:\n"
+ " '':\n"
- + " databaseType: H2\n"
- + " jdbcUrl: jdbc:h2:mem:logic\n"
+ + " databaseType: MySQL\n"
+ + " jdbcUrl: jdbc:mysql://localhost:3306/logic_db\n"
+ " username: ''\n"
+ " password: ''\n"
- + " driverClassName: org.h2.Driver\n";
+ + " driverClassName: com.mysql.cj.jdbc.Driver\n";
ConstructorException actual = assertThrows(ConstructorException.class,
() -> swapper.swapToObject(YamlEngine.unmarshal(yamlContent,
YamlMCPLaunchConfiguration.class)));
assertThat(actual.getMessage(), containsString("YAML map key cannot be
blank."));
}
@@ -169,11 +169,11 @@ class YamlMCPLaunchConfigurationSwapperTest {
+ " type: STDIO\n"
+ "runtimeDatabases:\n"
+ " null:\n"
- + " databaseType: H2\n"
- + " jdbcUrl: jdbc:h2:mem:logic\n"
+ + " databaseType: MySQL\n"
+ + " jdbcUrl: jdbc:mysql://localhost:3306/logic_db\n"
+ " username: ''\n"
+ " password: ''\n"
- + " driverClassName: org.h2.Driver\n";
+ + " driverClassName: com.mysql.cj.jdbc.Driver\n";
ConstructorException actual = assertThrows(ConstructorException.class,
() -> swapper.swapToObject(YamlEngine.unmarshal(yamlContent,
YamlMCPLaunchConfiguration.class)));
assertThat(actual.getMessage(), containsString("YAML map key cannot be
null."));
}
@@ -194,11 +194,11 @@ class YamlMCPLaunchConfigurationSwapperTest {
+ " type: STDIO\n"
+ "runtimeDatabases:\n"
+ " logic_db:\n"
- + " databaseType: H2\n"
- + " jdbcUrl: jdbc:h2:mem:logic\n"
+ + " databaseType: MySQL\n"
+ + " jdbcUrl: jdbc:mysql://localhost:3306/logic_db\n"
+ " username: ''\n"
+ " password: ''\n"
- + " driverClassName: org.h2.Driver\n"
+ + " driverClassName: com.mysql.cj.jdbc.Driver\n"
+ " unsupported: true\n";
IllegalArgumentException actual =
assertThrows(IllegalArgumentException.class, () ->
swapper.swapToObject(YamlEngine.unmarshal(yamlContent,
YamlMCPLaunchConfiguration.class)));
assertThat(actual.getMessage(), is("MCP launch configuration property
`runtimeDatabases` contains unsupported property `unsupported` for database
`logic_db`."));
@@ -207,10 +207,10 @@ class YamlMCPLaunchConfigurationSwapperTest {
@Test
void assertSwapToYamlConfigurationWithRuntimeDatabases() {
Map<String, RuntimeDatabaseConfiguration> databases = new
LinkedHashMap<>(1, 1F);
- databases.put("logic_db", new RuntimeDatabaseConfiguration("H2",
"jdbc:h2:mem:logic", "", "", "org.h2.Driver"));
+ databases.put("logic_db", new RuntimeDatabaseConfiguration("MySQL",
"jdbc:mysql://localhost:3306/logic_db", "", "", "com.mysql.cj.jdbc.Driver"));
MCPLaunchConfiguration launchConfig = new
MCPLaunchConfiguration(MCPTransportType.STREAMABLE_HTTP, new
HttpTransportConfiguration("127.0.0.1", 18088, "/mcp"), databases);
YamlMCPLaunchConfiguration actual =
swapper.swapToYamlConfiguration(launchConfig);
-
assertThat(String.valueOf(actual.getRuntimeDatabases().get("logic_db").get("databaseType")),
is("H2"));
+
assertThat(String.valueOf(actual.getRuntimeDatabases().get("logic_db").get("databaseType")),
is("MySQL"));
assertThat(String.valueOf(actual.getRuntimeDatabases().get("logic_db").get("username")),
is(""));
assertThat(actual.getTransport().getType(),
is(MCPTransportType.STREAMABLE_HTTP));
assertThat(actual.getTransport().getHttp().getBindHost(),
is("127.0.0.1"));
@@ -227,10 +227,10 @@ class YamlMCPLaunchConfigurationSwapperTest {
private String createRuntimeDatabasesYaml() {
return "runtimeDatabases:\n"
+ " logic_db:\n"
- + " databaseType: H2\n"
- + " jdbcUrl: jdbc:h2:mem:logic\n"
+ + " databaseType: MySQL\n"
+ + " jdbcUrl: jdbc:mysql://localhost:3306/logic_db\n"
+ " username: ''\n"
+ " password: ''\n"
- + " driverClassName: org.h2.Driver\n";
+ + " driverClassName: com.mysql.cj.jdbc.Driver\n";
}
}
diff --git
a/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlMCPTransportConfigurationSwapperTest.java
b/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlMCPTransportConfigurationSwapperTest.java
index 7ff29ff9119..d35eab71bb5 100644
---
a/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlMCPTransportConfigurationSwapperTest.java
+++
b/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlMCPTransportConfigurationSwapperTest.java
@@ -88,11 +88,11 @@ class YamlMCPTransportConfigurationSwapperTest {
YamlMCPLaunchConfiguration result = new YamlMCPLaunchConfiguration();
result.setTransport(transport);
result.setRuntimeDatabases(Map.of("logic_db", Map.of(
- "databaseType", "H2",
- "jdbcUrl", "jdbc:h2:mem:logic",
+ "databaseType", "MySQL",
+ "jdbcUrl", "jdbc:mysql://localhost:3306/logic_db",
"username", "",
"password", "",
- "driverClassName", "org.h2.Driver")));
+ "driverClassName", "com.mysql.cj.jdbc.Driver")));
return result;
}
}
diff --git
a/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlRuntimeDatabaseConfigurationSwapperTest.java
b/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlRuntimeDatabaseConfigurationSwapperTest.java
index daf12f83cc9..53b97a4d71f 100644
---
a/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlRuntimeDatabaseConfigurationSwapperTest.java
+++
b/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlRuntimeDatabaseConfigurationSwapperTest.java
@@ -32,11 +32,11 @@ class YamlRuntimeDatabaseConfigurationSwapperTest {
@Test
void assertSwapToObject() {
RuntimeDatabaseConfiguration actual =
swapper.swapToObject(createYamlConfig());
- assertThat(actual.getDatabaseType(), is("H2"));
- assertThat(actual.getJdbcUrl(), is("jdbc:h2:mem:logic"));
+ assertThat(actual.getDatabaseType(), is("MySQL"));
+ assertThat(actual.getJdbcUrl(),
is("jdbc:mysql://localhost:3306/logic_db"));
assertThat(actual.getUsername(), is(" demo "));
assertThat(actual.getPassword(), is(" secret "));
- assertThat(actual.getDriverClassName(), is(" org.h2.Driver "));
+ assertThat(actual.getDriverClassName(), is(" com.mysql.cj.jdbc.Driver
"));
}
@Test
@@ -104,21 +104,21 @@ class YamlRuntimeDatabaseConfigurationSwapperTest {
@Test
void assertSwapToYamlConfiguration() {
YamlRuntimeDatabaseConfiguration actual =
swapper.swapToYamlConfiguration(
- new RuntimeDatabaseConfiguration("H2", "jdbc:h2:mem:logic",
"", "", "org.h2.Driver"));
- assertThat(actual.getDatabaseType(), is("H2"));
- assertThat(actual.getJdbcUrl(), is("jdbc:h2:mem:logic"));
+ new RuntimeDatabaseConfiguration("MySQL",
"jdbc:mysql://localhost:3306/logic_db", "", "", "com.mysql.cj.jdbc.Driver"));
+ assertThat(actual.getDatabaseType(), is("MySQL"));
+ assertThat(actual.getJdbcUrl(),
is("jdbc:mysql://localhost:3306/logic_db"));
assertThat(actual.getUsername(), is(""));
assertThat(actual.getPassword(), is(""));
- assertThat(actual.getDriverClassName(), is("org.h2.Driver"));
+ assertThat(actual.getDriverClassName(),
is("com.mysql.cj.jdbc.Driver"));
}
private YamlRuntimeDatabaseConfiguration createYamlConfig() {
YamlRuntimeDatabaseConfiguration result = new
YamlRuntimeDatabaseConfiguration();
- result.setDatabaseType("H2");
- result.setJdbcUrl("jdbc:h2:mem:logic");
+ result.setDatabaseType("MySQL");
+ result.setJdbcUrl("jdbc:mysql://localhost:3306/logic_db");
result.setUsername(" demo ");
result.setPassword(" secret ");
- result.setDriverClassName(" org.h2.Driver ");
+ result.setDriverClassName(" com.mysql.cj.jdbc.Driver ");
return result;
}
}
diff --git
a/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlRuntimeDatabaseConfigurationsSwapperTest.java
b/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlRuntimeDatabaseConfigurationsSwapperTest.java
index 1e49168b331..14ab73da099 100644
---
a/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlRuntimeDatabaseConfigurationsSwapperTest.java
+++
b/mcp/bootstrap/src/test/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/swapper/YamlRuntimeDatabaseConfigurationsSwapperTest.java
@@ -35,14 +35,14 @@ class YamlRuntimeDatabaseConfigurationsSwapperTest {
@Test
void assertSwapToObject() {
Map<String, RuntimeDatabaseConfiguration> actual =
swapper.swapToObject(Map.of("logic_db", Map.of(
- "databaseType", "H2",
- "jdbcUrl", "jdbc:h2:mem:logic",
+ "databaseType", "MySQL",
+ "jdbcUrl", "jdbc:mysql://localhost:3306/logic_db",
"username", "",
"password", "",
- "driverClassName", "org.h2.Driver")));
+ "driverClassName", "com.mysql.cj.jdbc.Driver")));
- assertThat(actual.get("logic_db").getDatabaseType(), is("H2"));
- assertThat(actual.get("logic_db").getJdbcUrl(),
is("jdbc:h2:mem:logic"));
+ assertThat(actual.get("logic_db").getDatabaseType(), is("MySQL"));
+ assertThat(actual.get("logic_db").getJdbcUrl(),
is("jdbc:mysql://localhost:3306/logic_db"));
}
@Test
@@ -65,11 +65,11 @@ class YamlRuntimeDatabaseConfigurationsSwapperTest {
@Test
void assertSwapToObjectWithUnsupportedRuntimeDatabaseProperty() {
IllegalArgumentException actual =
assertThrows(IllegalArgumentException.class, () ->
swapper.swapToObject(Map.of("logic_db", Map.of(
- "databaseType", "H2",
- "jdbcUrl", "jdbc:h2:mem:logic",
+ "databaseType", "MySQL",
+ "jdbcUrl", "jdbc:mysql://localhost:3306/logic_db",
"username", "",
"password", "",
- "driverClassName", "org.h2.Driver",
+ "driverClassName", "com.mysql.cj.jdbc.Driver",
"unsupported", true))));
assertThat(actual.getMessage(), is("Unsupported runtime database
property `unsupported`."));
@@ -78,10 +78,10 @@ class YamlRuntimeDatabaseConfigurationsSwapperTest {
@Test
void assertSwapToYamlConfiguration() {
Map<String, Map<String, Object>> actual =
swapper.swapToYamlConfiguration(Map.of(
- "logic_db", new RuntimeDatabaseConfiguration("H2",
"jdbc:h2:mem:logic", "", "", "org.h2.Driver")));
+ "logic_db", new RuntimeDatabaseConfiguration("MySQL",
"jdbc:mysql://localhost:3306/logic_db", "", "", "com.mysql.cj.jdbc.Driver")));
- assertThat(String.valueOf(actual.get("logic_db").get("databaseType")),
is("H2"));
-
assertThat(String.valueOf(actual.get("logic_db").get("driverClassName")),
is("org.h2.Driver"));
+ assertThat(String.valueOf(actual.get("logic_db").get("databaseType")),
is("MySQL"));
+
assertThat(String.valueOf(actual.get("logic_db").get("driverClassName")),
is("com.mysql.cj.jdbc.Driver"));
}
@Test
diff --git
a/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/resource/ResourceTestDataFactory.java
b/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/resource/ResourceTestDataFactory.java
index aa5f7ed6b35..42e45a66318 100644
---
a/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/resource/ResourceTestDataFactory.java
+++
b/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/resource/ResourceTestDataFactory.java
@@ -71,7 +71,7 @@ public final class ResourceTestDataFactory {
List.of(new MCPViewMetadata("logic_db",
"public", "orders_view",
List.of(new
MCPColumnMetadata("logic_db", "public", "", "orders_view", "order_id")))),
List.of()))),
- new MCPDatabaseMetadata("runtime_db", "H2", "", List.of(
+ new MCPDatabaseMetadata("runtime_db", "PostgreSQL", "",
List.of(
new MCPSchemaMetadata("runtime_db", "public",
List.of(), List.of(), List.of(new MCPSequenceMetadata("runtime_db", "public",
"order_seq"))))),
new MCPDatabaseMetadata("warehouse", "Hive", "", List.of(
new MCPSchemaMetadata("warehouse", "warehouse",
List.of(new MCPTableMetadata("warehouse", "warehouse", "facts", List.of(),
List.of())), List.of(), List.of()))));
diff --git
a/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPJdbcStatementExecutorTest.java
b/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPJdbcStatementExecutorTest.java
index 0ffe9ebe68c..b9789eb0b75 100644
---
a/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPJdbcStatementExecutorTest.java
+++
b/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPJdbcStatementExecutorTest.java
@@ -79,7 +79,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcTransactionResourceManager transactionResourceManager =
mock(MCPJdbcTransactionResourceManager.class);
when(transactionResourceManager.findTransactionConnection(anyString(),
anyString())).thenReturn(Optional.empty());
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Map.of("logic_db", runtimeDatabaseConfig),
transactionResourceManager);
- SQLExecutionResponse actual =
statementExecutor.execute(executionRequest, classificationResult,
createDatabaseCapability("H2"));
+ SQLExecutionResponse actual =
statementExecutor.execute(executionRequest, classificationResult,
createDatabaseCapability("MySQL"));
assertThat(actual.getResultKind(), is(expectedResultKind));
assertThat(actual.getStatementClass(),
is(classificationResult.getStatementClass()));
assertThat(actual.getStatementType(), is(expectedStatementType));
@@ -101,7 +101,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Collections.emptyMap(), transactionResourceManager);
SQLExecutionResponse actual = statementExecutor.execute(new
SQLExecutionRequest("session-1",
"logic_db", "public", "UPDATE orders SET status = 'DONE'", 10,
1000),
- new ClassificationResult(SupportedMCPStatement.DML, "UPDATE",
"UPDATE orders SET status = 'DONE'", "", ""), createDatabaseCapability("H2"));
+ new ClassificationResult(SupportedMCPStatement.DML, "UPDATE",
"UPDATE orders SET status = 'DONE'", "", ""),
createDatabaseCapability("MySQL"));
assertThat(actual.getAffectedRows(), is(2));
verify(connection, never()).close();
}
@@ -122,7 +122,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Map.of("logic_db", databaseConfig),
transactionResourceManager);
SQLExecutionResponse actual = statementExecutor.execute(new
SQLExecutionRequest("session-1",
"logic_db", "public", "SELECT status FROM orders", 10, 1000,
true),
- new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""), createDatabaseCapability("H2"));
+ new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("MySQL"));
assertThat(actual.getRows().size(), is(1));
verify(connection).setReadOnly(true);
verify(connection).setAutoCommit(false);
@@ -140,7 +140,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Collections.emptyMap(), transactionResourceManager);
SQLExecutionResponse actual = statementExecutor.execute(new
SQLExecutionRequest("session-1",
"logic_db", "public", "SELECT status FROM orders", 10, 1000,
true),
- new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""), createDatabaseCapability("H2"));
+ new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("MySQL"));
assertThat(actual.getRows().size(), is(1));
verify(connection, never()).setReadOnly(true);
verify(connection, never()).rollback();
@@ -163,7 +163,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Map.of("logic_db", databaseConfig),
transactionResourceManager);
SQLExecutionResponse actual = statementExecutor.execute(new
SQLExecutionRequest("session-1",
"logic_db", " ", "SELECT status FROM orders", 0, 0),
- new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""), createDatabaseCapability("H2"));
+ new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("MySQL"));
assertThat(actual.getRows().size(), is(2));
assertFalse(actual.isTruncated());
verify(connection, never()).setSchema(anyString());
@@ -185,7 +185,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Map.of("logic_db", databaseConfig),
transactionResourceManager);
SQLExecutionResponse actual = statementExecutor.execute(new
SQLExecutionRequest("session-1",
"logic_db", "public", "SELECT status FROM orders",
Integer.MAX_VALUE, 1000),
- new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""), createDatabaseCapability("H2"));
+ new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("MySQL"));
assertThat(actual.getRows().size(), is(0));
assertFalse(actual.isTruncated());
verify(statement).setMaxRows(Integer.MAX_VALUE);
@@ -207,7 +207,7 @@ class MCPJdbcStatementExecutorTest {
"logic_db", "public", "WITH updated_orders AS (UPDATE orders
SET status = 'DONE' RETURNING *) SELECT * FROM updated_orders", 10, 1000),
new ClassificationResult(SupportedMCPStatement.DML, "SELECT",
"WITH updated_orders AS (UPDATE orders SET status =
'DONE' RETURNING *) SELECT * FROM updated_orders", "", ""),
- createDatabaseCapability("H2"));
+ createDatabaseCapability("MySQL"));
assertThat(actual.getResultKind(),
is(ExecuteQueryResultKind.RESULT_SET));
assertThat(actual.getStatementClass(), is(SupportedMCPStatement.DML));
assertThat(actual.getStatementType(), is("SELECT"));
@@ -240,7 +240,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Map.of("logic_db", databaseConfig),
transactionResourceManager);
MCPUnsupportedException actual =
assertThrows(MCPUnsupportedException.class, () -> statementExecutor.execute(new
SQLExecutionRequest("session-1",
"logic_db", "public", "UPDATE orders SET status = 'DONE'", 10,
1000),
- new ClassificationResult(SupportedMCPStatement.DML, "UPDATE",
"UPDATE orders SET status = 'DONE'", "", ""), createDatabaseCapability("H2")));
+ new ClassificationResult(SupportedMCPStatement.DML, "UPDATE",
"UPDATE orders SET status = 'DONE'", "", ""),
createDatabaseCapability("PostgreSQL")));
assertThat(actual.getMessage(), is("schema"));
verify(connection).setSchema("public");
verify(connection, never()).createStatement();
@@ -257,7 +257,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Map.of("logic_db", databaseConfig),
transactionResourceManager);
QueryDidNotReturnResultSetException actual =
assertThrows(QueryDidNotReturnResultSetException.class, () ->
statementExecutor.execute(new SQLExecutionRequest("session-1",
"logic_db", "public", "SELECT status FROM orders", 10, 1000),
- new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("H2")));
+ new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("MySQL")));
assertThat(actual.getMessage(), is("Query did not return a result
set."));
}
@@ -271,7 +271,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Map.of("logic_db", databaseConfig),
transactionResourceManager);
StatementClassNotSupportedException actual =
assertThrows(StatementClassNotSupportedException.class, () ->
statementExecutor.execute(new SQLExecutionRequest("session-1",
"logic_db", "public", "BEGIN", 10, 1000),
- new
ClassificationResult(SupportedMCPStatement.TRANSACTION_CONTROL, "BEGIN",
"BEGIN", "", ""), createDatabaseCapability("H2")));
+ new
ClassificationResult(SupportedMCPStatement.TRANSACTION_CONTROL, "BEGIN",
"BEGIN", "", ""), createDatabaseCapability("MySQL")));
assertThat(actual.getMessage(), is("Statement class is not
supported."));
}
@@ -290,7 +290,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Map.of("logic_db", databaseConfig),
transactionResourceManager);
ShardingSphereMCPException actual =
assertThrows(expectedExceptionClass, () -> statementExecutor.execute(new
SQLExecutionRequest("session-1",
"logic_db", "public", "SELECT status FROM orders", 10, 1000),
- new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("H2")));
+ new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("MySQL")));
assertThat(actual.getClass(), is(expectedExceptionClass));
assertThat(actual.getMessage(), is(expectedMessage));
assertThat(actual.getCause(), is(sqlException));
@@ -304,7 +304,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Collections.emptyMap(), transactionResourceManager);
MCPTransactionStateException actual =
assertThrows(MCPTransactionStateException.class, () ->
statementExecutor.execute(new SQLExecutionRequest("session-1",
"logic_db", "public", "SELECT status FROM orders", 10, 1000),
- new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("H2")));
+ new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("MySQL")));
assertThat(actual.getMessage(), is("Transaction already active."));
assertThat(actual.getCause(), is(cause));
}
@@ -316,7 +316,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Collections.emptyMap(), transactionResourceManager);
MCPUnavailableException actual =
assertThrows(MCPUnavailableException.class, () -> statementExecutor.execute(new
SQLExecutionRequest("session-1",
"missing_db", "public", "SELECT status FROM orders", 10, 1000),
- new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("H2")));
+ new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("MySQL")));
assertThat(actual.getMessage(), is("Database `missing_db` is not
configured."));
}
@@ -334,7 +334,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Map.of("logic_db", databaseConfig),
transactionResourceManager);
MCPQueryFailedException actual =
assertThrows(MCPQueryFailedException.class, () -> statementExecutor.execute(new
SQLExecutionRequest("session-1", "logic_db",
"public", "UPDATE orders SET status = 'DONE'", 10, 1000),
- new ClassificationResult(SupportedMCPStatement.DML, "UPDATE",
"UPDATE orders SET status = 'DONE'", "", ""), createDatabaseCapability("H2")));
+ new ClassificationResult(SupportedMCPStatement.DML, "UPDATE",
"UPDATE orders SET status = 'DONE'", "", ""),
createDatabaseCapability("MySQL")));
assertThat(actual.getMessage(), is("statement close failed"));
}
@@ -349,7 +349,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Map.of("logic_db", databaseConfig),
transactionResourceManager);
SQLExecutionResponse actual = statementExecutor.execute(new
SQLExecutionRequest("session-1",
"logic_db", "public", "UPDATE orders SET status = 'DONE'", 10,
1000),
- new ClassificationResult(SupportedMCPStatement.DML, "UPDATE",
"UPDATE orders SET status = 'DONE'", "", ""), createDatabaseCapability("H2"));
+ new ClassificationResult(SupportedMCPStatement.DML, "UPDATE",
"UPDATE orders SET status = 'DONE'", "", ""),
createDatabaseCapability("MySQL"));
assertThat(actual.getAffectedRows(), is(1));
verify(connection).close();
}
@@ -363,7 +363,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Map.of("logic_db", databaseConfig),
transactionResourceManager);
assertThrows(NullPointerException.class, () ->
statementExecutor.execute(new SQLExecutionRequest("session-1",
"logic_db", "", "SELECT status FROM orders", 0, 0),
- new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("H2")));
+ new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("MySQL")));
}
@Test
@@ -377,7 +377,7 @@ class MCPJdbcStatementExecutorTest {
MCPJdbcStatementExecutor statementExecutor = new
MCPJdbcStatementExecutor(Map.of("logic_db", databaseConfig),
transactionResourceManager);
assertThrows(NullPointerException.class, () ->
statementExecutor.execute(new SQLExecutionRequest("session-1",
"logic_db", "", "SELECT status FROM orders", 0, 0),
- new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("H2")));
+ new ClassificationResult(SupportedMCPStatement.QUERY,
"SELECT", "SELECT status FROM orders", "", ""),
createDatabaseCapability("MySQL")));
}
private static MCPDatabaseCapability createDatabaseCapability(final String
databaseType) {
diff --git
a/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPSQLExecutionFacadeConcurrencyTest.java
b/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPSQLExecutionFacadeConcurrencyTest.java
index 651246d2d39..23fa71163cb 100644
---
a/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPSQLExecutionFacadeConcurrencyTest.java
+++
b/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/execute/MCPSQLExecutionFacadeConcurrencyTest.java
@@ -181,12 +181,12 @@ class MCPSQLExecutionFacadeConcurrencyTest {
Connection connection = mock(Connection.class);
DatabaseMetaData databaseMetaData = mock(DatabaseMetaData.class);
try {
- when(result.getDatabaseType()).thenReturn("H2");
+ when(result.getDatabaseType()).thenReturn("MySQL");
when(result.openConnection("logic_db")).thenReturn(connection);
when(connection.getMetaData()).thenReturn(databaseMetaData);
- when(databaseMetaData.getDatabaseProductName()).thenReturn("H2");
+
when(databaseMetaData.getDatabaseProductName()).thenReturn("MySQL");
when(databaseMetaData.getDatabaseProductVersion()).thenReturn("");
-
when(databaseMetaData.getURL()).thenReturn("jdbc:h2:mem:facade-concurrency");
+
when(databaseMetaData.getURL()).thenReturn("jdbc:mysql://localhost:3306/facade_concurrency");
} catch (final SQLException ex) {
throw new IllegalStateException(ex);
}
diff --git
a/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/metadata/SearchMetadataToolServiceTest.java
b/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/metadata/SearchMetadataToolServiceTest.java
index 0f4ef5ed210..ba2f358178f 100644
---
a/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/metadata/SearchMetadataToolServiceTest.java
+++
b/mcp/core/src/test/java/org/apache/shardingsphere/mcp/core/tool/handler/metadata/SearchMetadataToolServiceTest.java
@@ -299,13 +299,13 @@ class SearchMetadataToolServiceTest {
new MCPTableMetadata("warehouse", "warehouse", "facts",
List.of(new MCPColumnMetadata("warehouse",
"warehouse", "facts", "", "fact_id")), List.of())),
List.of(), List.of()))));
- result.add(new MCPDatabaseMetadata("runtime_db", "H2", "", List.of(
+ result.add(new MCPDatabaseMetadata("runtime_db", "PostgreSQL", "",
List.of(
new MCPSchemaMetadata("runtime_db", "public", List.of(),
List.of(), List.of(new MCPSequenceMetadata("runtime_db", "public",
"order_seq"))))));
return result;
}
private List<MCPDatabaseMetadata> createDatabaseMetadataWithEmptySchema() {
- return List.of(new MCPDatabaseMetadata("schema_less_db", "H2", "",
+ return List.of(new MCPDatabaseMetadata("schema_less_db", "PostgreSQL",
"",
List.of(new MCPSchemaMetadata("schema_less_db", "",
List.of(new MCPTableMetadata("schema_less_db", "", "schema_less_orders",
List.of(), List.of())), List.of(), List.of()))));
}
@@ -316,7 +316,7 @@ class SearchMetadataToolServiceTest {
}
private List<MCPDatabaseMetadata>
createDatabaseMetadataWithNullViewColumn() {
- return List.of(new MCPDatabaseMetadata("null_view_db", "H2", "",
+ return List.of(new MCPDatabaseMetadata("null_view_db", "MySQL", "",
List.of(new MCPSchemaMetadata("null_view_db", "public",
List.of(),
List.of(new MCPViewMetadata("null_view_db", "public",
"active_view", List.of(new MCPColumnMetadata("null_view_db", "public", "",
null, "status")))), List.of()))));
}
diff --git
a/mcp/registry/src/test/java/org/apache/shardingsphere/mcp/registry/MCPRegistryMetadataCommandTest.java
b/mcp/registry/src/test/java/org/apache/shardingsphere/mcp/registry/MCPRegistryMetadataCommandTest.java
index 6c0f3962090..17d3fa039a0 100644
---
a/mcp/registry/src/test/java/org/apache/shardingsphere/mcp/registry/MCPRegistryMetadataCommandTest.java
+++
b/mcp/registry/src/test/java/org/apache/shardingsphere/mcp/registry/MCPRegistryMetadataCommandTest.java
@@ -259,7 +259,7 @@ class MCPRegistryMetadataCommandTest {
result.put("$schema",
"https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json";);
result.put("name", "io.github.apache/shardingsphere-mcp");
result.put("title", "Apache ShardingSphere MCP");
- result.put("description", "MCP runtime for Apache ShardingSphere
metadata discovery, SQL preview, and rule workflows");
+ result.put("description", "MCP Server for Apache ShardingSphere
metadata discovery, SQL preview, and rule workflows");
result.put("version", "5.5.4-SNAPSHOT");
result.put("packages", List.of(createPackage("stdio", ""),
createPackage("streamable-http", "http://127.0.0.1:18088/mcp";)));
return result;
diff --git a/mcp/server.json b/mcp/server.json
index cb0fe44815b..3680276dd8e 100644
--- a/mcp/server.json
+++ b/mcp/server.json
@@ -2,7 +2,7 @@
"$schema":
"https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json";,
"name": "io.github.apache/shardingsphere-mcp",
"title": "Apache ShardingSphere MCP",
- "description": "Apache ShardingSphere MCP runtime for metadata discovery,
SQL preview, and encrypt/mask workflows",
+ "description": "Apache ShardingSphere MCP Server for metadata discovery, SQL
preview, and encrypt/mask workflows",
"websiteUrl":
"https://shardingsphere.apache.org/document/current/en/user-manual/shardingsphere-mcp/";,
"repository": {
"url": "https://github.com/apache/shardingsphere";,
diff --git
a/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/database/capability/dialect/H2MCPDatabaseCapabilityOption.java
b/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/database/capability/dialect/H2MCPDatabaseCapabilityOption.java
deleted file mode 100644
index b05acb89316..00000000000
---
a/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/database/capability/dialect/H2MCPDatabaseCapabilityOption.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.shardingsphere.mcp.support.database.capability.dialect;
-
-import
org.apache.shardingsphere.mcp.support.database.capability.SchemaExecutionSemantics;
-import
org.apache.shardingsphere.mcp.support.database.capability.SchemaSemantics;
-import
org.apache.shardingsphere.mcp.support.database.capability.TransactionCapability;
-
-/**
- * MCP database capability option for H2.
- */
-public final class H2MCPDatabaseCapabilityOption extends
AbstractMCPDatabaseCapabilityOption {
-
- public H2MCPDatabaseCapabilityOption() {
- super("H2", TransactionCapability.LOCAL_WITH_SAVEPOINT, true,
SchemaSemantics.NATIVE_SCHEMA, SchemaExecutionSemantics.BEST_EFFORT, true,
true);
- }
-
- @Override
- public boolean isExplainAnalyzeSupported(final String databaseVersion) {
- return true;
- }
-}
diff --git
a/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/MCPJdbcDatabaseProfileLoader.java
b/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/MCPJdbcDatabaseProfileLoader.java
index 1614e930477..0bb33387c71 100644
---
a/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/MCPJdbcDatabaseProfileLoader.java
+++
b/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/MCPJdbcDatabaseProfileLoader.java
@@ -132,9 +132,6 @@ public final class MCPJdbcDatabaseProfileLoader {
if (productName.toUpperCase(Locale.ENGLISH).contains("FIREBIRD")) {
return Optional.of("Firebird");
}
- if (productName.toUpperCase(Locale.ENGLISH).contains("H2")) {
- return Optional.of("H2");
- }
}
return TypedSPILoader.findService(MCPDatabaseCapabilityOption.class,
productName).map(MCPDatabaseCapabilityOption::getType);
}
@@ -162,9 +159,6 @@ public final class MCPJdbcDatabaseProfileLoader {
if (actualJdbcUrl.startsWith("jdbc:firebirdsql:")) {
return Optional.of("Firebird");
}
- if (actualJdbcUrl.startsWith("jdbc:h2:")) {
- return Optional.of("H2");
- }
return Optional.empty();
}
diff --git
a/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/MCPJdbcMetadataLoader.java
b/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/MCPJdbcMetadataLoader.java
index 7ab3a8b54e5..9761adc8163 100644
---
a/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/MCPJdbcMetadataLoader.java
+++
b/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/MCPJdbcMetadataLoader.java
@@ -177,8 +177,6 @@ public final class MCPJdbcMetadataLoader {
return Optional.of(MARIADB_SEQUENCE_QUERY);
case "FIREBIRD":
return Optional.of(FIREBIRD_SEQUENCE_QUERY);
- case "H2":
- return Optional.of("SELECT SEQUENCE_SCHEMA, SEQUENCE_NAME FROM
INFORMATION_SCHEMA.SEQUENCES");
default:
return Optional.empty();
}
diff --git
a/mcp/support/src/main/resources/META-INF/services/org.apache.shardingsphere.mcp.support.database.capability.MCPDatabaseCapabilityOption
b/mcp/support/src/main/resources/META-INF/services/org.apache.shardingsphere.mcp.support.database.capability.MCPDatabaseCapabilityOption
index ee13049a115..f62d0d77ca1 100644
---
a/mcp/support/src/main/resources/META-INF/services/org.apache.shardingsphere.mcp.support.database.capability.MCPDatabaseCapabilityOption
+++
b/mcp/support/src/main/resources/META-INF/services/org.apache.shardingsphere.mcp.support.database.capability.MCPDatabaseCapabilityOption
@@ -26,4 +26,3 @@
org.apache.shardingsphere.mcp.support.database.capability.dialect.DorisMCPDataba
org.apache.shardingsphere.mcp.support.database.capability.dialect.HiveMCPDatabaseCapabilityOption
org.apache.shardingsphere.mcp.support.database.capability.dialect.PrestoMCPDatabaseCapabilityOption
org.apache.shardingsphere.mcp.support.database.capability.dialect.FirebirdMCPDatabaseCapabilityOption
-org.apache.shardingsphere.mcp.support.database.capability.dialect.H2MCPDatabaseCapabilityOption
diff --git
a/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/capability/MCPDatabaseCapabilityProviderTest.java
b/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/capability/MCPDatabaseCapabilityProviderTest.java
index 1ac7c63a15c..bd05307a32d 100644
---
a/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/capability/MCPDatabaseCapabilityProviderTest.java
+++
b/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/capability/MCPDatabaseCapabilityProviderTest.java
@@ -156,7 +156,6 @@ class MCPDatabaseCapabilityProviderTest {
Arguments.of("doris", "Doris", true, false, true, false,
SchemaExecutionSemantics.FIXED_TO_DATABASE),
Arguments.of("hive", "Hive", false, false, false, false,
SchemaExecutionSemantics.FIXED_TO_DATABASE),
Arguments.of("presto", "Presto", true, false, false, false,
SchemaExecutionSemantics.BEST_EFFORT),
- Arguments.of("firebird", "Firebird", true, true, true, true,
SchemaExecutionSemantics.BEST_EFFORT),
- Arguments.of("h2", "H2", true, true, true, true,
SchemaExecutionSemantics.BEST_EFFORT));
+ Arguments.of("firebird", "Firebird", true, true, true, true,
SchemaExecutionSemantics.BEST_EFFORT));
}
}
diff --git
a/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/MCPJdbcMetadataLoaderTest.java
b/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/MCPJdbcMetadataLoaderTest.java
index 5cef21160de..e48730a71f5 100644
---
a/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/MCPJdbcMetadataLoaderTest.java
+++
b/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/MCPJdbcMetadataLoaderTest.java
@@ -69,23 +69,23 @@ class MCPJdbcMetadataLoaderTest {
@Test
void assertLoad() throws SQLException {
- LoadedMetadataCatalog actual = load(Map.of("logic_db",
createMockRuntimeDatabaseConfiguration("H2",
createStandardH2MetadataConnection())));
-
assertThat(actual.findMetadata("logic_db").map(MCPDatabaseMetadata::getDatabaseType).orElseThrow(),
is("H2"));
-
assertThat(actual.findMetadata("logic_db").orElseThrow().getDatabaseVersion(),
is("2.2.224"));
+ LoadedMetadataCatalog actual = load(Map.of("logic_db",
createMockRuntimeDatabaseConfiguration("PostgreSQL",
createStandardPostgreSQLMetadataConnection())));
+
assertThat(actual.findMetadata("logic_db").map(MCPDatabaseMetadata::getDatabaseType).orElseThrow(),
is("PostgreSQL"));
+
assertThat(actual.findMetadata("logic_db").orElseThrow().getDatabaseVersion(),
is("16.2"));
}
@ParameterizedTest(name = "{0}")
@MethodSource("loadTypedMetadataArguments")
void assertLoadWithTypedMetadata(final String name, final
SupportedMCPMetadataObjectType objectType, final String objectName) throws
SQLException {
- LoadedMetadataCatalog actual = load(Map.of("logic_db",
createMockRuntimeDatabaseConfiguration("H2",
createStandardH2MetadataConnection())));
+ LoadedMetadataCatalog actual = load(Map.of("logic_db",
createMockRuntimeDatabaseConfiguration("PostgreSQL",
createStandardPostgreSQLMetadataConnection())));
assertTrue(containsMetadata(actual.findMetadata("logic_db").orElseThrow(),
objectType, objectName));
}
@Test
void assertLoadWithMultipleLogicalDatabases() throws SQLException {
Map<String, RuntimeDatabaseConfiguration> connectionConfigs = Map.of(
- "logic_db", createMockRuntimeDatabaseConfiguration("H2",
createStandardH2MetadataConnection()),
- "analytics_db", createMockRuntimeDatabaseConfiguration("H2",
createStandardH2MetadataConnection()));
+ "logic_db",
createMockRuntimeDatabaseConfiguration("PostgreSQL",
createStandardPostgreSQLMetadataConnection()),
+ "analytics_db",
createMockRuntimeDatabaseConfiguration("PostgreSQL",
createStandardPostgreSQLMetadataConnection()));
LoadedMetadataCatalog actual = load(connectionConfigs);
assertThat(actual.getDatabaseMetadataMap().size(), is(2));
assertTrue(actual.findMetadata("analytics_db").isPresent());
@@ -164,7 +164,7 @@ class MCPJdbcMetadataLoaderTest {
@Test
void assertLoadWithSchemaRegisteredOnce() throws SQLException {
- LoadedMetadataCatalog actual = load(Map.of("logic_db",
createMockRuntimeDatabaseConfiguration("H2",
createStandardH2MetadataConnection())));
+ LoadedMetadataCatalog actual = load(Map.of("logic_db",
createMockRuntimeDatabaseConfiguration("PostgreSQL",
createStandardPostgreSQLMetadataConnection())));
MCPDatabaseMetadata databaseMetadata =
actual.findMetadata("logic_db").orElseThrow();
assertTrue(containsMetadata(databaseMetadata,
SupportedMCPMetadataObjectType.TABLE, "orders"));
assertTrue(containsMetadata(databaseMetadata,
SupportedMCPMetadataObjectType.VIEW, "active_orders"));
@@ -187,7 +187,7 @@ class MCPJdbcMetadataLoaderTest {
when(runtimeDatabaseConfiguration.openConnection("logic_db")).thenThrow(expected);
MCPJdbcMetadataLoader metadataLoader = new MCPJdbcMetadataLoader();
IllegalStateException actual =
assertThrows(IllegalStateException.class,
- () -> metadataLoader.load("logic_db",
runtimeDatabaseConfiguration, new RuntimeDatabaseProfile("logic_db", "H2",
"")));
+ () -> metadataLoader.load("logic_db",
runtimeDatabaseConfiguration, new RuntimeDatabaseProfile("logic_db",
"PostgreSQL", "")));
assertThat(actual.getMessage(), is("Failed to load metadata for
database `logic_db`."));
assertThat(actual.getCause(), is(expected));
}
@@ -200,7 +200,7 @@ class MCPJdbcMetadataLoaderTest {
Map.of("orders", List.of("order_id")),
Map.of(),
List.of());
- RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("H2", connection);
+ RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("PostgreSQL", connection);
MCPDatabaseMetadata actual = load(Map.of("logic_db",
runtimeDatabaseConfiguration)).findMetadata("logic_db").orElseThrow();
assertTrue(containsMetadata(actual,
SupportedMCPMetadataObjectType.TABLE, "orders"));
assertFalse(containsMetadata(actual,
SupportedMCPMetadataObjectType.TABLE, ""));
@@ -214,7 +214,7 @@ class MCPJdbcMetadataLoaderTest {
Map.of("active_orders", List.of("order_id")),
Map.of(),
List.of());
- RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("H2", connection);
+ RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("PostgreSQL", connection);
MCPDatabaseMetadata actual = load(Map.of("logic_db",
runtimeDatabaseConfiguration)).findMetadata("logic_db").orElseThrow();
assertTrue(containsMetadata(actual,
SupportedMCPMetadataObjectType.VIEW, "active_orders"));
assertFalse(containsMetadata(actual,
SupportedMCPMetadataObjectType.VIEW, ""));
@@ -228,7 +228,7 @@ class MCPJdbcMetadataLoaderTest {
Map.of("orders", List.of("", "order_id")),
Map.of(),
List.of());
- RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("H2", connection);
+ RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("PostgreSQL", connection);
MCPDatabaseMetadata actual = load(Map.of("logic_db",
runtimeDatabaseConfiguration)).findMetadata("logic_db").orElseThrow();
assertTrue(containsMetadata(actual,
SupportedMCPMetadataObjectType.COLUMN, "order_id"));
assertFalse(containsMetadata(actual,
SupportedMCPMetadataObjectType.COLUMN, ""));
@@ -242,7 +242,7 @@ class MCPJdbcMetadataLoaderTest {
Map.of("orders", List.of("order_id")),
Map.of("orders", List.of("", "idx_orders_status",
"idx_orders_status")),
List.of());
- RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("H2", connection);
+ RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("PostgreSQL", connection);
MCPDatabaseMetadata actual = load(Map.of("logic_db",
runtimeDatabaseConfiguration)).findMetadata("logic_db").orElseThrow();
assertTrue(containsMetadata(actual,
SupportedMCPMetadataObjectType.INDEX, "idx_orders_status"));
assertThat(countMetadata(actual, SupportedMCPMetadataObjectType.INDEX,
"idx_orders_status"), is(1));
@@ -282,7 +282,7 @@ class MCPJdbcMetadataLoaderTest {
Map.of("orders", List.of("order_id")),
Map.of(),
List.of());
- RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("H2", connection);
+ RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("PostgreSQL", connection);
MCPDatabaseMetadata actual = load(Map.of("logic_db",
runtimeDatabaseConfiguration)).findMetadata("logic_db").orElseThrow();
assertThat(countMetadata(actual, SupportedMCPMetadataObjectType.TABLE,
"orders"), is(1));
}
@@ -295,7 +295,7 @@ class MCPJdbcMetadataLoaderTest {
Map.of("active_orders", List.of("order_id")),
Map.of(),
List.of());
- RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("H2", connection);
+ RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("PostgreSQL", connection);
MCPDatabaseMetadata actual = load(Map.of("logic_db",
runtimeDatabaseConfiguration)).findMetadata("logic_db").orElseThrow();
assertThat(countMetadata(actual, SupportedMCPMetadataObjectType.VIEW,
"active_orders"), is(1));
}
@@ -316,11 +316,11 @@ class MCPJdbcMetadataLoaderTest {
@Test
void assertLoadWithMismatchedDatabaseType() throws SQLException {
- RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("MySQL",
createConnectionWithoutSchema("H2"));
+ RuntimeDatabaseConfiguration runtimeDatabaseConfiguration =
createMockRuntimeDatabaseConfiguration("MySQL",
createConnectionWithoutSchema("PostgreSQL"));
RuntimeDatabaseConnectionException actual =
assertThrows(RuntimeDatabaseConnectionException.class, () ->
load(Map.of("logic_db", runtimeDatabaseConfiguration)));
assertThat(actual.getMessage(), is("Runtime database `logic_db`
connection failed: invalid_configuration."));
assertThat(actual.getCategory(),
is(RuntimeDatabaseConnectionException.CATEGORY_INVALID_CONFIGURATION));
- assertThat(actual.getCause().getMessage(), is("Configured databaseType
`MySQL` does not match actual database type `H2` for database `logic_db`."));
+ assertThat(actual.getCause().getMessage(), is("Configured databaseType
`MySQL` does not match actual database type `PostgreSQL` for database
`logic_db`."));
}
@ParameterizedTest(name = "{0}")
@@ -394,9 +394,7 @@ class MCPJdbcMetadataLoaderTest {
Arguments.of("mariadb", "MariaDB", "logic_db", "order_seq",
"SELECT TABLE_SCHEMA AS SEQUENCE_SCHEMA, TABLE_NAME AS
SEQUENCE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'SEQUENCE'"),
Arguments.of("firebird", "Firebird", "", "ORDER_SEQ",
- "SELECT '' AS SEQUENCE_SCHEMA,
TRIM(RDB$GENERATOR_NAME) AS SEQUENCE_NAME FROM RDB$GENERATORS WHERE
COALESCE(RDB$SYSTEM_FLAG, 0) = 0"),
- Arguments.of("h2", "H2", "PUBLIC", "ORDER_SEQ",
- "SELECT SEQUENCE_SCHEMA, SEQUENCE_NAME FROM
INFORMATION_SCHEMA.SEQUENCES"));
+ "SELECT '' AS SEQUENCE_SCHEMA,
TRIM(RDB$GENERATOR_NAME) AS SEQUENCE_NAME FROM RDB$GENERATORS WHERE
COALESCE(RDB$SYSTEM_FLAG, 0) = 0"));
}
private static Stream<Arguments> loadWithoutSequenceQueryArguments() {
@@ -492,7 +490,7 @@ class MCPJdbcMetadataLoaderTest {
return result;
}
- private Connection createStandardH2MetadataConnection() throws
SQLException {
+ private Connection createStandardPostgreSQLMetadataConnection() throws
SQLException {
Connection result = createConnectionWithMetadata(
List.of(
Map.of("TABLE_SCHEM", "PUBLIC", "TABLE_NAME",
"orders"),
@@ -508,8 +506,8 @@ class MCPJdbcMetadataLoaderTest {
List.of(Map.of("SEQUENCE_SCHEMA", "PUBLIC", "SEQUENCE_NAME",
"order_seq")));
DatabaseMetaData databaseMetaData = result.getMetaData();
when(databaseMetaData.getDatabaseProductName()).thenReturn("");
-
when(databaseMetaData.getDatabaseProductVersion()).thenReturn("2.2.224");
-
when(databaseMetaData.getURL()).thenReturn("jdbc:h2:mem:metadata-loader");
+ when(databaseMetaData.getDatabaseProductVersion()).thenReturn("16.2");
+
when(databaseMetaData.getURL()).thenReturn("jdbc:postgresql://metadata-loader/test");
return result;
}
@@ -522,7 +520,7 @@ class MCPJdbcMetadataLoaderTest {
private Connection createConnectionWithMetadata(final List<Map<String,
String>> tableRows, final List<Map<String, String>> viewRows, final Map<String,
List<String>> columns,
final Map<String,
List<String>> indexes, final List<Map<String, String>> sequenceRows) throws
SQLException {
- return createConnectionWithMetadata("H2", tableRows, viewRows,
columns, indexes, sequenceRows);
+ return createConnectionWithMetadata("PostgreSQL", tableRows, viewRows,
columns, indexes, sequenceRows);
}
private Connection createConnectionWithMetadata(final String databaseType,
final List<Map<String, String>> tableRows, final List<Map<String, String>>
viewRows,
@@ -566,8 +564,6 @@ class MCPJdbcMetadataLoaderTest {
return "SELECT TABLE_SCHEMA AS SEQUENCE_SCHEMA, TABLE_NAME AS
SEQUENCE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'SEQUENCE'";
case "Firebird":
return "SELECT '' AS SEQUENCE_SCHEMA, TRIM(RDB$GENERATOR_NAME)
AS SEQUENCE_NAME FROM RDB$GENERATORS WHERE COALESCE(RDB$SYSTEM_FLAG, 0) = 0";
- case "H2":
- return "SELECT SEQUENCE_SCHEMA, SEQUENCE_NAME FROM
INFORMATION_SCHEMA.SEQUENCES";
default:
return "";
}
@@ -634,7 +630,7 @@ class MCPJdbcMetadataLoaderTest {
if ("Firebird".equals(databaseType)) {
return "jdbc:firebirdsql://metadata-loader/test";
}
- return "jdbc:h2:mem:metadata-loader";
+ return "jdbc:postgresql://metadata-loader/test";
}
private int countMetadata(final MCPDatabaseMetadata databaseMetadata,
final SupportedMCPMetadataObjectType objectType, final String objectName) {
diff --git
a/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/RuntimeDatabaseConfigurationTest.java
b/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/RuntimeDatabaseConfigurationTest.java
index d1ed8d8f302..e17c9fe3bb1 100644
---
a/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/RuntimeDatabaseConfigurationTest.java
+++
b/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/metadata/jdbc/RuntimeDatabaseConfigurationTest.java
@@ -39,7 +39,7 @@ class RuntimeDatabaseConfigurationTest {
@Test
void assertOpenConnectionWithoutDriverClassName() throws SQLException {
RecordingDriver.reset();
- try (Connection actual = new RuntimeDatabaseConfiguration("H2",
RecordingDriver.JDBC_URL, "", "", "").openConnection("logic_db")) {
+ try (Connection actual = new RuntimeDatabaseConfiguration("MySQL",
RecordingDriver.JDBC_URL, "", "", "").openConnection("logic_db")) {
assertThat(actual, is(RecordingDriver.CONNECTION));
assertThat(RecordingDriver.lastUrl, is(RecordingDriver.JDBC_URL));
assertTrue(RecordingDriver.lastProperties.isEmpty());
@@ -49,7 +49,7 @@ class RuntimeDatabaseConfigurationTest {
@Test
void assertOpenConnectionWithDriverClassNameAndCredentials() throws
SQLException {
RecordingDriver.reset();
- try (Connection actual = new RuntimeDatabaseConfiguration("H2",
RecordingDriver.JDBC_URL, "sa", "pwd",
RecordingDriver.class.getName()).openConnection("logic_db")) {
+ try (Connection actual = new RuntimeDatabaseConfiguration("MySQL",
RecordingDriver.JDBC_URL, "sa", "pwd",
RecordingDriver.class.getName()).openConnection("logic_db")) {
assertThat(actual, is(RecordingDriver.CONNECTION));
assertThat(RecordingDriver.lastProperties.getProperty("user"),
is("sa"));
assertThat(RecordingDriver.lastProperties.getProperty("password"),
is("pwd"));
@@ -60,7 +60,7 @@ class RuntimeDatabaseConfigurationTest {
@Test
void assertOpenConnectionWithUnavailableDriverClassName() {
RuntimeDatabaseConnectionException actual =
assertThrows(RuntimeDatabaseConnectionException.class,
- () -> new RuntimeDatabaseConfiguration("H2",
"jdbc:test:missing-driver", "", "",
"org.example.MissingDriver").openConnection("logic_db"));
+ () -> new RuntimeDatabaseConfiguration("MySQL",
"jdbc:test:missing-driver", "", "",
"org.example.MissingDriver").openConnection("logic_db"));
assertThat(actual.getMessage(), is("Runtime database `logic_db`
connection failed: missing_jdbc_driver."));
assertThat(actual.getCategory(), is("missing_jdbc_driver"));
}
diff --git
a/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/metadata/query/DatabaseTestDataFactory.java
b/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/metadata/query/DatabaseTestDataFactory.java
index 62370bff672..aecffc1c751 100644
---
a/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/metadata/query/DatabaseTestDataFactory.java
+++
b/mcp/support/src/test/java/org/apache/shardingsphere/mcp/support/database/metadata/query/DatabaseTestDataFactory.java
@@ -62,7 +62,7 @@ final class DatabaseTestDataFactory {
List.of(new MCPViewMetadata("logic_db",
"public", "orders_view",
List.of(new
MCPColumnMetadata("logic_db", "public", "", "orders_view", "order_id")))),
List.of()))),
- new MCPDatabaseMetadata("runtime_db", "H2", "", List.of(
+ new MCPDatabaseMetadata("runtime_db", "PostgreSQL", "",
List.of(
new MCPSchemaMetadata("runtime_db", "public",
List.of(), List.of(), List.of(new MCPSequenceMetadata("runtime_db", "public",
"order_seq"))))),
new MCPDatabaseMetadata("warehouse", "Hive", "", List.of(
new MCPSchemaMetadata("warehouse", "warehouse",
List.of(new MCPTableMetadata("warehouse", "warehouse", "facts", List.of(),
List.of())), List.of(), List.of()))));
