@bytebase/dbhub 0.23.0 → 1.0.0

package/dist/index.js

@@ -15,7 +15,13 @@ import {
   resolveSourceConfigs,
   resolveTomlConfigPath,
   resolveTransport
-} from "./chunk-COEDRFSK.js";
+} from "./chunk-MQR6VX5F.js";
+import {
+  allowedKeywords,
+  isReadOnlySQL,
+  sqlServerDynamicSqlPattern,
+  sqlServerPassThroughPattern
+} from "./chunk-JO7YQPBQ.js";
 import {
   loadConnectors
 } from "./chunk-WVVMH6FJ.js";
@@ -32,9 +38,9 @@ import {
 } from "./chunk-JEZZN2YZ.js";
 
 // src/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer, createMcpHandler } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { toNodeHandler } from "@modelcontextprotocol/node";
 import express from "express";
 import http from "http";
 import path from "path";
@@ -95,100 +101,50 @@ function createToolSuccessResponse(data, meta = {}) {
   };
 }
 
-// src/utils/allowed-keywords.ts
-var allowedKeywords = {
-  postgres: ["select", "with", "explain", "show"],
-  mysql: ["select", "with", "explain", "show", "describe", "desc"],
-  mariadb: ["select", "with", "explain", "show", "describe", "desc"],
-  sqlite: ["select", "with", "explain", "pragma"],
-  // SQL Server has no native EXPLAIN statement; the connector translates a
-  // leading `EXPLAIN` into a SET SHOWPLAN_XML request (see SQLServerConnector).
-  sqlserver: ["select", "with", "explain"]
-};
-var mutatingKeywords = [
-  "insert",
-  "update",
-  "delete",
-  "drop",
-  "alter",
-  "create",
-  "truncate",
-  "merge",
-  "grant",
-  "revoke",
-  "rename"
-];
-var mutatingPattern = new RegExp(
-  `\\b(?:${mutatingKeywords.join("|")})\\b`,
-  "i"
-);
-var mutatingPatternWithReplace = new RegExp(
-  `\\b(?:${mutatingKeywords.join("|")}|replace\\s+(?:(?:low_priority|delayed)\\s+)?into)\\b`,
-  "i"
-);
-var mutatingPatternSqlServer = new RegExp(
-  `\\b(?:${[...mutatingKeywords, "execute", "exec", "sp_executesql", "xp_cmdshell"].join("|")})\\b`,
-  "i"
-);
-var mutatingPatterns = {
-  postgres: mutatingPattern,
-  mysql: mutatingPatternWithReplace,
-  mariadb: mutatingPatternWithReplace,
-  sqlite: mutatingPatternWithReplace,
-  sqlserver: mutatingPatternSqlServer
+// src/utils/sql-access-policy.ts
+var CLASS_SEVERITY = {
+  read: 0,
+  dml: 1,
+  ddl: 2,
+  admin: 3,
+  unknown: 4
 };
-var selectIntoPattern = /\bselect\b[\s\S]+\binto\b/i;
-var sqliteReadOnlyArgPragmas = /* @__PURE__ */ new Set([
-  "table_info",
-  "index_info",
-  "index_list",
-  "foreign_key_list"
-]);
-var sqlitePragmaParenPattern = /^pragma\s+(?:[a-z0-9_]+\.)?([a-z0-9_]+)\s*\(/;
-var explainAnalyzePattern = /^explain\s+(?:\([^)]*\banalyze\b(?!\s*(?:=\s*)?(?:false|off|0)\b)[^)]*\)|\banalyze\b(?!\s*(?:=\s*)?(?:false|off|0)\b)(?:\s+verbose\b)?)/i;
-function isReadOnlySQL(sql, connectorType) {
-  return checkReadOnly(
-    stripCommentsAndStrings(sql, connectorType).trim().toLowerCase(),
-    connectorType
-  );
+var ddlPattern = /\b(?:create|alter|drop|truncate|rename)\b/i;
+var dmlPattern = /\b(?:insert|update|delete|merge|replace\s+(?:(?:low_priority|delayed)\s+)?into)\b/i;
+var grantRevokePattern = /\b(?:grant|revoke)\b/i;
+function isAdminStatement(stripped, connectorType) {
+  if (grantRevokePattern.test(stripped)) return true;
+  return connectorType === "sqlserver" && (sqlServerDynamicSqlPattern.test(stripped) || sqlServerPassThroughPattern.test(stripped));
 }
-function checkReadOnly(cleanedSQL, connectorType) {
-  if (!cleanedSQL) {
-    return false;
-  }
-  const firstWord = cleanedSQL.match(/\S+/)?.[0] ?? "";
-  const keywordList = allowedKeywords[connectorType] || [];
-  if (!keywordList.includes(firstWord)) {
-    return false;
-  }
-  if (firstWord === "with") {
-    const pattern = mutatingPatterns[connectorType] ?? mutatingPattern;
-    if (pattern.test(cleanedSQL)) {
-      return false;
-    }
-  }
-  if (firstWord === "pragma" && connectorType === "sqlite") {
-    if (cleanedSQL.includes("=")) {
-      return false;
-    }
-    const parenMatch = cleanedSQL.match(sqlitePragmaParenPattern);
-    if (parenMatch && !sqliteReadOnlyArgPragmas.has(parenMatch[1])) {
-      return false;
-    }
-  }
-  if ((firstWord === "select" || firstWord === "with") && selectIntoPattern.test(cleanedSQL)) {
-    return false;
-  }
-  if (firstWord === "explain") {
-    const m = explainAnalyzePattern.exec(cleanedSQL);
-    if (m) {
-      const afterExplain = cleanedSQL.slice(m[0].length).trim();
-      if (afterExplain && !checkReadOnly(afterExplain, connectorType)) {
-        return false;
-      }
+function policyFromReadonly(readonly) {
+  const write = readonly === true ? "deny" : "allow";
+  return { read: "allow", dml: write, ddl: write, admin: write, unknown: write };
+}
+function isReadOnlyPolicy(policy) {
+  return policy.dml === "deny" && policy.ddl === "deny" && policy.admin === "deny" && policy.unknown === "deny";
+}
+function classifyStatement(sql, connectorType) {
+  if (isReadOnlySQL(sql, connectorType)) {
+    return "read";
+  }
+  const stripped = stripCommentsAndStrings(sql, connectorType);
+  if (isAdminStatement(stripped, connectorType)) return "admin";
+  if (ddlPattern.test(stripped)) return "ddl";
+  if (dmlPattern.test(stripped)) return "dml";
+  return "unknown";
+}
+function classifySQL(sql, connectorType) {
+  let strictest = "read";
+  for (const statement of splitSQLStatements(sql, connectorType)) {
+    const cls = classifyStatement(statement, connectorType);
+    if (CLASS_SEVERITY[cls] > CLASS_SEVERITY[strictest]) {
+      strictest = cls;
     }
   }
-  return true;
+  return strictest;
+}
+function sqlVerdict(policy, sql, connectorType) {
+  return policy[classifySQL(sql, connectorType)];
 }
 
 // src/requests/store.ts
@@ -242,8 +198,8 @@ var RequestStore = class {
 var requestStore = new RequestStore();
 
 // src/utils/client-identifier.ts
-function getClientIdentifier(extra) {
-  const userAgent = extra?.requestInfo?.headers?.["user-agent"];
+function getClientIdentifier(ctx) {
+  const userAgent = ctx?.http?.req?.headers.get("user-agent");
   if (userAgent) {
     return userAgent;
   }
@@ -289,10 +245,7 @@ function tryClassifyConnectionError(error, rawSourceId, displaySourceId) {
 var executeSqlSchema = {
   sql: z.string().describe("SQL to execute (multiple statements separated by ;)")
 };
-function areAllStatementsReadOnly(sql, connectorType) {
-  const statements = splitSQLStatements(sql, connectorType);
-  return statements.every((statement) => isReadOnlySQL(statement, connectorType));
-}
+var executeSqlInputSchema = z.object(executeSqlSchema);
 function createExecuteSqlToolHandler(sourceId) {
   return async (args, extra) => {
     const { sql } = args;
@@ -307,14 +260,14 @@ function createExecuteSqlToolHandler(sourceId) {
       const actualSourceId = connector.getId();
       const registry = getToolRegistry();
       const toolConfig = registry.getBuiltinToolConfig(BUILTIN_TOOL_EXECUTE_SQL, actualSourceId);
-      const isReadonly = toolConfig?.readonly === true;
-      if (isReadonly && !areAllStatementsReadOnly(sql, connector.id)) {
+      const policy = policyFromReadonly(toolConfig?.readonly);
+      if (sqlVerdict(policy, sql, connector.id) === "deny") {
         errorMessage = `Read-only mode is enabled. Only the following SQL operations are allowed: ${allowedKeywords[connector.id]?.join(", ") || "none"}`;
         success = false;
         return createToolErrorResponse(errorMessage, "READONLY_VIOLATION");
       }
       const executeOptions = {
-        readonly: toolConfig?.readonly,
+        readonly: isReadOnlyPolicy(policy),
         maxRows: toolConfig?.max_rows
       };
       result = await connector.executeSQL(sql, executeOptions);
@@ -357,6 +310,7 @@ var searchDatabaseObjectsSchema = {
   detail_level: z2.enum(["names", "summary", "full"]).default("names").describe("Detail: names (minimal), summary (metadata), full (all)"),
   limit: z2.number().int().positive().max(1e3).default(100).describe("Max results")
 };
+var searchDatabaseObjectsInputSchema = z2.object(searchDatabaseObjectsSchema);
 function likePatternToRegex(pattern) {
   const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".");
   return new RegExp(`^${escaped}$`, "i");
@@ -377,7 +331,7 @@ async function getTableRowCount(connector, tableName, schemaName) {
     }
     const qualifiedTable = quoteQualifiedIdentifier(tableName, schemaName, connector.id);
     const countQuery = `SELECT COUNT(*) as count FROM ${qualifiedTable}`;
-    const result = await connector.executeSQL(countQuery, { maxRows: 1 });
+    const result = await connector.executeSQL(countQuery, { maxRows: 1, readonly: true });
     if (result.rows && result.rows.length > 0) {
       return Number(result.rows[0].count || result.rows[0].COUNT || 0);
     }
@@ -510,7 +464,7 @@ async function searchViews(connector, pattern, schemaFilter, detailLevel, limit)
   if (schemaFilter) {
     schemasToSearch = [schemaFilter];
   } else {
-    schemasToSearch = await connector.getSchemas();
+    schemasToSearch = await resolveDefaultSchemas(connector);
   }
   for (const schemaName of schemasToSearch) {
     if (results.length >= limit) break;
@@ -888,7 +842,7 @@ function getExecuteSqlMetadata(sourceId) {
   const readonlyNote = executeOptions.readonly ? " [READ-ONLY MODE]" : "";
   const maxRowsNote = executeOptions.maxRows ? ` (limited to ${executeOptions.maxRows} rows)` : "";
   const description = isSingleSource ? `${userDescPrefix}Execute SQL queries on the ${dbType} database${readonlyNote}${maxRowsNote}` : `${userDescPrefix}Execute SQL queries on the '${sourceId}' ${dbType} database${readonlyNote}${maxRowsNote}`;
-  const isReadonly = executeOptions.readonly === true;
+  const isReadonly = isReadOnlyPolicy(policyFromReadonly(executeOptions.readonly));
   const annotations = {
     title,
     readOnlyHint: isReadonly,
@@ -1064,9 +1018,17 @@ function buildZodSchemaFromParameters(parameters) {
   }
   return schemaShape;
 }
+var customToolInputSchemas = /* @__PURE__ */ new WeakMap();
+function getCustomToolInputSchema(toolConfig) {
+  let schema = customToolInputSchemas.get(toolConfig);
+  if (!schema) {
+    schema = z4.object(buildZodSchemaFromParameters(toolConfig.parameters));
+    customToolInputSchemas.set(toolConfig, schema);
+  }
+  return schema;
+}
 function createCustomToolHandler(toolConfig) {
-  const zodSchemaShape = buildZodSchemaFromParameters(toolConfig.parameters);
-  const zodSchema = z4.object(zodSchemaShape);
+  const zodSchema = getCustomToolInputSchema(toolConfig);
   return async (args, extra) => {
     const startTime = Date.now();
     let success = true;
@@ -1076,12 +1038,12 @@ function createCustomToolHandler(toolConfig) {
       const validatedArgs = zodSchema.parse(args);
       await ConnectorManager.ensureConnected(toolConfig.source);
       const connector = ConnectorManager.getCurrentConnector(toolConfig.source);
+      const policy = policyFromReadonly(toolConfig.readonly);
       const executeOptions = {
-        readonly: toolConfig.readonly,
+        readonly: isReadOnlyPolicy(policy),
         maxRows: toolConfig.max_rows
       };
-      const isReadonly = executeOptions.readonly === true;
-      if (isReadonly && !isReadOnlySQL(toolConfig.statement, connector.id)) {
+      if (sqlVerdict(policy, toolConfig.statement, connector.id) === "deny") {
         errorMessage = createReadonlyViolationMessage(toolConfig.name, toolConfig.source, connector.id);
         success = false;
         return createToolErrorResponse(errorMessage, "READONLY_VIOLATION");
@@ -1158,7 +1120,7 @@ function registerExecuteSqlTool(server, sourceId) {
     metadata.name,
     {
       description: metadata.description,
-      inputSchema: metadata.schema,
+      inputSchema: executeSqlInputSchema,
       annotations: metadata.annotations
     },
     createExecuteSqlToolHandler(sourceId)
@@ -1170,7 +1132,7 @@ function registerSearchObjectsTool(server, sourceId) {
     metadata.name,
     {
       description: metadata.description,
-      inputSchema: searchDatabaseObjectsSchema,
+      inputSchema: searchDatabaseObjectsInputSchema,
       annotations: {
         title: metadata.title,
         readOnlyHint: true,
@@ -1185,13 +1147,12 @@ function registerSearchObjectsTool(server, sourceId) {
 function registerCustomTool(server, sourceId, toolConfig) {
   const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
   const dbType = sourceConfig.type;
-  const isReadOnly = isReadOnlySQL(toolConfig.statement, dbType);
-  const zodSchema = buildZodSchemaFromParameters(toolConfig.parameters);
+  const isReadOnly = classifySQL(toolConfig.statement, dbType) === "read";
   server.registerTool(
     toolConfig.name,
     {
       description: toolConfig.description,
-      inputSchema: zodSchema,
+      inputSchema: getCustomToolInputSchema(toolConfig),
       annotations: {
         title: `${toolConfig.name} (${dbType})`,
         readOnlyHint: isReadOnly,
@@ -1631,6 +1592,8 @@ var packageJsonPath = path.join(__dirname, "..", "package.json");
 var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
 var SERVER_NAME = "DBHub MCP Server";
 var SERVER_VERSION = packageJson.version;
+var TOOLS_LIST_CACHE_TTL_MS = 3e5;
+var logMcpError = (scope) => (error) => console.error(`MCP ${scope} error:`, error);
 function generateBanner(version, modes = []) {
   const modeText = modes.length > 0 ? ` [${modes.join(" | ")}]` : "";
   return `
@@ -1676,7 +1639,7 @@ See documentation for more details on configuring database connections.
     const sources = sourceConfigsData.sources;
     console.error(`Configuration source: ${sourceConfigsData.source}`);
     await connectorManager.connectWithSources(sources);
-    const { initializeToolRegistry: initializeToolRegistry2 } = await import("./registry-ZME64VB2.js");
+    const { initializeToolRegistry: initializeToolRegistry2 } = await import("./registry-ZU6ZFNQ2.js");
     initializeToolRegistry2({
       sources: sourceConfigsData.sources,
       tools: sourceConfigsData.tools
@@ -1687,10 +1650,18 @@ See documentation for more details on configuring database connections.
       initialTools: sourceConfigsData.tools
     });
     const createServer = () => {
-      const server = new McpServer({
-        name: SERVER_NAME,
-        version: SERVER_VERSION
-      });
+      const server = new McpServer(
+        {
+          name: SERVER_NAME,
+          version: SERVER_VERSION
+        },
+        {
+          // `private` keeps caching client-side (no shared/proxy caches).
+          cacheHints: {
+            "tools/list": { ttlMs: TOOLS_LIST_CACHE_TTL_MS, cacheScope: "private" }
+          }
+        }
+      );
       registerTools(server);
       return server;
     };
@@ -1732,7 +1703,7 @@ See documentation for more details on configuring database connections.
         }
         res.header("Access-Control-Allow-Origin", origin || "http://localhost");
         res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-        res.header("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id");
+        res.header("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id, MCP-Protocol-Version, Mcp-Method, Mcp-Name");
         res.header("Access-Control-Allow-Credentials", "true");
         if (req.method === "OPTIONS") {
           return res.sendStatus(200);
@@ -1747,29 +1718,10 @@ See documentation for more details on configuring database connections.
       app.get("/api/sources", listSources);
       app.get("/api/sources/:sourceId", getSource);
       app.get("/api/requests", listRequests);
-      app.get("/mcp", (req, res) => {
-        res.status(405).json({
-          error: "Method Not Allowed",
-          message: "SSE streaming is not supported in stateless mode. Use POST requests with JSON responses."
-        });
-      });
-      app.post("/mcp", async (req, res) => {
-        try {
-          const transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: void 0,
-            // Disable session management for stateless mode
-            enableJsonResponse: true
-            // Use JSON responses (SSE not supported in stateless mode)
-          });
-          const server = createServer();
-          await server.connect(transport);
-          await transport.handleRequest(req, res, req.body);
-        } catch (error) {
-          console.error("Error handling request:", error);
-          if (!res.headersSent) {
-            res.status(500).json({ error: "Internal server error" });
-          }
-        }
+      const mcpHandler = createMcpHandler(createServer, { onerror: logMcpError("handler") });
+      const mcpNodeHandler = toNodeHandler(mcpHandler, { onerror: logMcpError("adapter") });
+      app.all("/mcp", (req, res) => {
+        void mcpNodeHandler(req, res, req.body);
       });
       if (process.env.NODE_ENV !== "development") {
         app.get("*", (req, res) => {
@@ -1805,16 +1757,14 @@ See documentation for more details on configuring database connections.
         console.error(`MCP server endpoint at http://${userHost}:${boundPort}/mcp`);
       });
     } else {
-      const server = createServer();
-      const transport = new StdioServerTransport();
-      await server.connect(transport);
+      const stdioHandle = serveStdio(createServer, { onerror: logMcpError("stdio") });
       console.error("MCP server running on stdio");
       let isShuttingDown = false;
       const shutdown = async () => {
         if (isShuttingDown) return;
         isShuttingDown = true;
         console.error("Shutting down...");
-        await transport.close();
+        await stdioHandle.close();
         await connectorManager.disconnect();
         process.exit(0);
       };
@@ -1830,11 +1780,11 @@ See documentation for more details on configuring database connections.
 
 // src/index.ts
 var connectorModules = [
-  { load: () => import("./postgres-BKBCGDZS.js"), name: "PostgreSQL", driver: "pg" },
-  { load: () => import("./sqlserver-65AGCEJX.js"), name: "SQL Server", driver: "mssql" },
-  { load: () => import("./sqlite-CQ4LCBB6.js"), name: "SQLite", driver: "node:sqlite" },
-  { load: () => import("./mysql-MZWCPISB.js"), name: "MySQL", driver: "mysql2" },
-  { load: () => import("./mariadb-SPFBL46R.js"), name: "MariaDB", driver: "mariadb" }
+  { load: () => import("./postgres-YAYHDXVD.js"), name: "PostgreSQL", driver: "pg" },
+  { load: () => import("./sqlserver-COKW7RIK.js"), name: "SQL Server", driver: "mssql" },
+  { load: () => import("./sqlite-5M7SDAQZ.js"), name: "SQLite", driver: "node:sqlite" },
+  { load: () => import("./mysql-CDUKJMNN.js"), name: "MySQL", driver: "mysql2" },
+  { load: () => import("./mariadb-72C2BNCG.js"), name: "MariaDB", driver: "mariadb" }
 ];
 loadConnectors(connectorModules).then(() => main()).catch((error) => {
   console.error("Fatal error:", error);

package/dist/{mariadb-SPFBL46R.js → mariadb-72C2BNCG.js}

@@ -1,13 +1,18 @@
 import {
+  MissingDatabaseError,
   extractAffectedRows,
-  parseQueryResults
-} from "./chunk-RTB262PR.js";
+  isTiDBVersion,
+  parseQueryResults,
+  requireDatabaseInDSN,
+  withReadOnlyTransaction
+} from "./chunk-DUCNPMNW.js";
 import {
   quoteIdentifier
 } from "./chunk-JFWX35TB.js";
 import {
-  SQLRowLimiter
-} from "./chunk-BXXHWEQS.js";
+  SQLRowLimiter,
+  closeQuietly
+} from "./chunk-S2V6RZ3C.js";
 import {
   ConnectorRegistry,
   SafeURL,
@@ -32,11 +37,12 @@ Expected: ${expectedFormat}`
     }
     try {
       const url = new SafeURL(dsn);
+      const database = url.pathname ? url.pathname.substring(1) : "";
+      requireDatabaseInDSN(database, dsn, "MariaDB");
       const connectionConfig = {
         host: url.hostname,
         port: url.port ? parseInt(url.port) : 3306,
-        database: url.pathname ? url.pathname.substring(1) : "",
-        // Remove leading '/' if exists
+        database,
         user: url.username,
         password: url.password,
         multipleStatements: true,
@@ -77,6 +83,9 @@ Expected: ${expectedFormat}`
       }
       return connectionConfig;
     } catch (error) {
+      if (error instanceof MissingDatabaseError) {
+        throw error;
+      }
       throw new Error(
         `Failed to parse MariaDB DSN: ${error instanceof Error ? error.message : String(error)}`
       );
@@ -101,6 +110,9 @@ var MariaDBConnector = class _MariaDBConnector {
     this.pool = null;
     // Source ID is set by ConnectorManager after cloning
     this.sourceId = "default";
+    // TiDB speaks the MySQL protocol but rejects `START TRANSACTION READ ONLY`
+    // unless tidb_enable_noop_functions is on. Detected once at connect time.
+    this.supportsReadOnlyTransaction = true;
   }
   getId() {
     return this.sourceId;
@@ -112,8 +124,14 @@ var MariaDBConnector = class _MariaDBConnector {
     try {
       const connectionConfig = await this.dsnParser.parse(dsn, config);
       this.pool = mariadb.createPool(connectionConfig);
-      await this.pool.query("SELECT 1");
+      const rows = await this.pool.query("SELECT VERSION() AS version");
+      this.supportsReadOnlyTransaction = !isTiDBVersion(rows?.[0]?.version);
     } catch (err) {
+      if (this.pool) {
+        const pool = this.pool;
+        this.pool = null;
+        await closeQuietly(() => pool.end());
+      }
       console.error("Failed to connect to MariaDB database:", err);
       throw err;
     }
@@ -473,48 +491,33 @@ var MariaDBConnector = class _MariaDBConnector {
     }
     const conn = await this.pool.getConnection();
     try {
-      if (options.readonly) {
-        await conn.query("START TRANSACTION READ ONLY");
-      }
-      let processedSQL = sql;
-      if (options.maxRows) {
-        const statements = splitSQLStatements(sql, "mariadb");
-        const processedStatements = statements.map(
-          (statement) => SQLRowLimiter.applyMaxRows(statement, options.maxRows)
-        );
-        processedSQL = processedStatements.join("; ");
-        if (sql.trim().endsWith(";")) {
-          processedSQL += ";";
-        }
-      }
-      let results;
-      if (parameters && parameters.length > 0) {
-        try {
-          results = await conn.query(processedSQL, parameters);
-        } catch (error) {
-          console.error(`[MariaDB executeSQL] ERROR: ${error.message}`);
-          console.error(`[MariaDB executeSQL] SQL: ${processedSQL}`);
-          console.error(`[MariaDB executeSQL] Parameters: ${JSON.stringify(parameters)}`);
-          throw error;
-        }
-      } else {
-        results = await conn.query(processedSQL);
-      }
-      const rows = parseQueryResults(results);
-      const rowCount = extractAffectedRows(results);
-      if (options.readonly) {
-        await conn.query("COMMIT");
-      }
-      return { rows, rowCount };
-    } catch (error) {
-      if (options.readonly) {
-        try {
-          await conn.query("ROLLBACK");
-        } catch {
+      return await withReadOnlyTransaction(
+        conn,
+        options.readonly,
+        this.supportsReadOnlyTransaction,
+        async () => {
+          let processedSQL = sql;
+          if (options.maxRows) {
+            const statements = splitSQLStatements(sql, "mariadb");
+            const processedStatements = statements.map(
+              (statement) => SQLRowLimiter.applyMaxRows(statement, options.maxRows)
+            );
+            processedSQL = processedStatements.join("; ");
+            if (sql.trim().endsWith(";")) {
+              processedSQL += ";";
+            }
+          }
+          let results;
+          if (parameters && parameters.length > 0) {
+            results = await conn.query(processedSQL, parameters);
+          } else {
+            results = await conn.query(processedSQL);
+          }
+          const rows = parseQueryResults(results);
+          const rowCount = extractAffectedRows(results);
+          return { rows, rowCount };
         }
-      }
-      console.error("Error executing query:", error);
-      throw error;
+      );
     } finally {
       conn.release();
     }