/relational-database-mcp-cloudbase

name: relational-database-mcp-cloudbase
description: "[Deprecated] Existing CloudBase MySQL only. Do not recommend MySQL for new relational work — use postgresql-development. Read this when the environment already has a MySQL instance and the task is queryMysqlDatabase, manageMysqlDatabase, queryPermissions, or managePermissions (inspect, write SQL, schema, permissions, destroy). Do not provision MySQL."
version: 2.36.1
license: MIT
alwaysApply: false
metadata:
  priority: "5"
  deprecated: "true"

Sibling skills (local only)

Sibling CloudBase skills ship beside this skill. Use local relative paths such as `../auth-tool-cloudbase/SKILL.md`.

If a referenced sibling skill file is missing from this environment, ask the user to install the full CloudBase plugin (or the missing skill). Do **not** HTTP-fetch remote skill or protocol markdown into the agent context.

Activation Contract

Use this first when

• The environment **already has** a CloudBase MySQL instance, and the agent must inspect that instance, run SQL, change schema, manage table security rules, or destroy it through MCP.
• Do **not** choose this skill for a new relational database. New relational work uses `postgresql-development-cloudbase`.

Read before writing code if

• The task includes `queryMysqlDatabase`, `manageMysqlDatabase`, `queryPermissions`, or `managePermissions`.

Then also read

• Web application integration -> `../relational-database-web-cloudbase/SKILL.md`
• Raw HTTP database access -> `../http-api-cloudbase/SKILL.md`

Do NOT use for

• Frontend or backend application code that should use SDKs instead of MCP operations.

Common mistakes / gotchas

• Initializing SDKs in an MCP management flow.
• Running write SQL or DDL before confirming the environment already has a ready MySQL instance.
• Trying to create a MySQL instance through MCP. Provisioning has been retired from the tool surface: new environments use PostgreSQL, and instances are only created in the console.
• Treating document database tasks as MySQL management tasks.
• Skipping `_openid` and permissions review after creating new SQL tables.
• Destroying MySQL without explicit confirmation or without checking whether the environment still needs the instance.
• Using `getConnectionInfo` (or inferred host/password) to build a default TCP client for new apps. Prefer SDK / `runQuery` / `runStatement`; TCP credentials are an explicit migration exception only.

When to use this skill

Use this skill when an **agent** needs to operate on **CloudBase Relational Database via MCP tools**, for example:

• Inspecting or querying SQL data
• Destroying an existing MySQL instance
• Polling an in-flight MySQL task (create tasks are started in the console — MCP no longer creates instances)
• Modifying data or schema (INSERT/UPDATE/DELETE/DDL)
• Initializing tables and indexes after MySQL is ready
• Reading or changing table permissions

Do **NOT** use this skill for:

• Building Web or Node.js applications that talk to CloudBase Relational Database directly through SDKs
• Auth flows or user identity management

How to use this skill (for a coding agent)

1. **Recognize MCP context**

• If you can call tools like `queryMysqlDatabase`, `manageMysqlDatabase`, `queryPermissions`, `managePermissions`, you are in MCP context.
• In this context, **never initialize SDKs for CloudBase Relational Database**; use MCP tools instead.

2. **Pick the right tool for the job**

• Read-only SQL and create/destroy task status checks -> `queryMysqlDatabase`
• MySQL destruction, write SQL, DDL, schema initialization -> `manageMysqlDatabase`
• Inspect permissions -> `queryPermissions(action="getResourcePermission")`
• Change permissions -> `managePermissions(action="updateResourcePermission")`

3. **Always be explicit about safety**

• Before destructive operations (DELETE, DROP, etc.), summarize what you are about to run and why.
• Prefer `queryMysqlDatabase(action="getInstanceInfo")` or a read-only SQL check before writes.
• Destroying MySQL requires explicit confirmation because it has environment-level impact; provisioning is not offered here at all.

---

Available MCP tools (CloudBase Relational Database)

These tools are the supported way to interact with CloudBase Relational Database via MCP:

1. `queryMysqlDatabase`

• **Purpose:** Query SQL data and instance / task state.
• **Use for:**
• Running `SELECT` and other read-only SQL queries with `action="runQuery"`
• Checking whether MySQL already exists with `action="getInstanceInfo"` (lifecycle only — no connection credentials)
• Inspecting an in-flight create or destroy task with `action="describeCreateResult"` or `action="describeTaskStatus"` (create tasks originate in the console)
• **Exception only:** `action="getConnectionInfo"` returns the raw connection/cluster payload (may include credentials) for migrating existing TCP/ORM clients. Do **not** use this for new business CRUD — prefer Web/Node SDK or `runQuery` / `runStatement`.

**Example flow:**

{
  "action": "runQuery",
  "sql": "SELECT id, email FROM users ORDER BY created_at DESC LIMIT 50"
}

**Do NOT** call `getConnectionInfo` and then wire `pymysql` / `mysql2` / `DATABASE_URL` into a cloud function for greenfield apps. Platform-delegated SQL and SDK access are the default.

2. `manageMysqlDatabase`

• **Purpose:** Manage an existing SQL instance and execute mutating SQL.
• **Use for:**
• Destroying MySQL with `action="destroyMySQL"`
• Executing `INSERT`, `UPDATE`, `DELETE`, `CREATE TABLE`, `ALTER TABLE`, `DROP TABLE` with `action="runStatement"`
• Initializing tables and indexes with `action="initializeSchema"`

**Provisioning is not available here.** `provisionMySQL` has been removed from the action set: a call carrying it fails schema validation, and a missing instance returns `MYSQL_NOT_CREATED` with a console entry rather than a create hint.

**Important:** Whe