@squadbase/vite-server 0.1.9-dev.a57a0ac → 0.1.9-dev.a70dcaa

package/dist/connectors/jdbc.js

@@ -20307,6 +20307,12 @@ var NOOP_TUNNEL = (connectionUrl) => ({
   close: async () => {
   }
 });
+var NOOP_TUNNEL_HOSTPORT = (host, port) => ({
+  host,
+  port,
+  close: async () => {
+  }
+});
 function connectionParamsToRecord(connection2) {
   const out = {};
   for (const p of connection2.parameters) {
@@ -20314,9 +20320,9 @@ function connectionParamsToRecord(connection2) {
   }
   return out;
 }
-async function maybeOpenSshTunnel(params, connectionUrl, defaultDbPort) {
+async function maybeOpenSshTunnelHostPort(params, dbHost, dbPort) {
   const sshHost = params[sshTunnelParameters.sshHost.slug];
-  if (!sshHost) return NOOP_TUNNEL(connectionUrl);
+  if (!sshHost) return NOOP_TUNNEL_HOSTPORT(dbHost, dbPort);
   const sshUsername = params[sshTunnelParameters.sshUsername.slug];
   const sshPrivateKeyBase64 = params[sshTunnelParameters.sshPrivateKeyBase64.slug];
   if (!sshUsername || !sshPrivateKeyBase64) {
@@ -20326,9 +20332,6 @@ async function maybeOpenSshTunnel(params, connectionUrl, defaultDbPort) {
   }
   const sshPort = Number(params[sshTunnelParameters.sshPort.slug] || "22") || 22;
   const sshPassphrase = params[sshTunnelParameters.sshPassphrase.slug];
-  const url = new URL(connectionUrl);
-  const dbHost = url.hostname;
-  const dbPort = url.port ? Number(url.port) : defaultDbPort;
   const [{ Client }, net] = await Promise.all([
     Promise.resolve().then(() => __toESM(require_lib3(), 1)),
     import("net")
@@ -20371,16 +20374,297 @@ async function maybeOpenSshTunnel(params, connectionUrl, defaultDbPort) {
     sshClient.end();
     throw new Error("Failed to allocate local port for SSH tunnel.");
   }
-  url.hostname = "127.0.0.1";
-  url.port = String(address.port);
   return {
-    connectionUrl: url.toString(),
+    host: "127.0.0.1",
+    port: address.port,
     close: async () => {
       await new Promise((resolve) => server.close(() => resolve()));
       sshClient.end();
     }
   };
 }
+async function maybeOpenSshTunnel(params, connectionUrl, defaultDbPort) {
+  const sshHost = params[sshTunnelParameters.sshHost.slug];
+  if (!sshHost) return NOOP_TUNNEL(connectionUrl);
+  const url = new URL(connectionUrl);
+  const dbHost = url.hostname;
+  const dbPort = url.port ? Number(url.port) : defaultDbPort;
+  const tunnel = await maybeOpenSshTunnelHostPort(params, dbHost, dbPort);
+  url.hostname = tunnel.host;
+  url.port = String(tunnel.port);
+  return {
+    connectionUrl: url.toString(),
+    close: tunnel.close
+  };
+}
+
+// ../connectors/src/connectors/sqlserver/utils.ts
+var SQLSERVER_PREFIX_RE = /^(?:jdbc:)?sqlserver:\/\//i;
+var TRUE_VALUES = /* @__PURE__ */ new Set(["true", "1", "yes"]);
+var FALSE_VALUES = /* @__PURE__ */ new Set(["false", "0", "no"]);
+function parseBoolean(value) {
+  if (value == null) return void 0;
+  const lower = value.toLowerCase();
+  if (TRUE_VALUES.has(lower)) return true;
+  if (FALSE_VALUES.has(lower)) return false;
+  return void 0;
+}
+function parseSqlServerJdbcUrl(jdbcUrl, options = {}) {
+  const trimmed = jdbcUrl.trim();
+  if (!SQLSERVER_PREFIX_RE.test(trimmed)) {
+    throw new Error(
+      `Unsupported SQL Server URL "${redactSqlServerUrl(trimmed)}". Expected prefix: jdbc:sqlserver:// or sqlserver://.`
+    );
+  }
+  const withoutPrefix = trimmed.replace(SQLSERVER_PREFIX_RE, "");
+  const [hostAndPath, ...propertySegments] = withoutPrefix.split(";");
+  const props = {};
+  for (const segment of propertySegments) {
+    if (!segment) continue;
+    const eqIdx = segment.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = segment.slice(0, eqIdx).trim().toLowerCase();
+    const value = segment.slice(eqIdx + 1).trim();
+    if (key) props[key] = value;
+  }
+  const url = new URL(`mssql://${hostAndPath}`);
+  for (const [key, value] of url.searchParams.entries()) {
+    if (!(key.toLowerCase() in props)) {
+      props[key.toLowerCase()] = value;
+    }
+  }
+  const server = url.hostname;
+  const port = url.port ? Number(url.port) : 1433;
+  const pathname = url.pathname.replace(/^\//, "");
+  const database = pathname || props["database"] || props["databasename"];
+  const user = props["user"] || props["username"] || props["userid"] || options.username;
+  const password = props["password"] || options.password;
+  return {
+    server,
+    port,
+    database,
+    user,
+    password,
+    options: props
+  };
+}
+function toMssqlConfig(parsed, defaults = {}) {
+  const encrypt = parseBoolean(parsed.options["encrypt"]) ?? defaults.encrypt ?? false;
+  const trustServerCertificate = parseBoolean(parsed.options["trustservercertificate"]) ?? !encrypt;
+  return {
+    server: parsed.server,
+    port: parsed.port,
+    database: parsed.database,
+    user: parsed.user,
+    password: parsed.password,
+    connectionTimeout: 1e4,
+    requestTimeout: 6e4,
+    options: {
+      encrypt,
+      trustServerCertificate
+    }
+  };
+}
+function redactSqlServerUrl(jdbcUrl) {
+  return jdbcUrl.replace(/(:\/\/)([^@/;]+)@/, "$1***@").replace(/(password\s*=\s*)([^;]+)/gi, "$1***");
+}
+
+// ../connectors/src/lib/mssql-runner.ts
+async function importMssql() {
+  const mod = await import("mssql");
+  return mod.default ?? mod;
+}
+async function runMssqlQuery(parsed, sql, options = {}) {
+  const sqlMod = await importMssql();
+  const tunnel = options.tunnelParams ? await maybeOpenSshTunnelHostPort(
+    options.tunnelParams,
+    parsed.server,
+    parsed.port
+  ) : null;
+  try {
+    const tunneled = tunnel ? { ...parsed, server: tunnel.host, port: tunnel.port } : parsed;
+    const config = toMssqlConfig(tunneled, {
+      encrypt: options.forceEncrypt
+    });
+    const pool = new sqlMod.ConnectionPool(config);
+    await pool.connect();
+    try {
+      const result = await pool.request().query(sql);
+      const recordset = result.recordset ?? [];
+      return { rows: recordset };
+    } finally {
+      await pool.close();
+    }
+  } finally {
+    await tunnel?.close();
+  }
+}
+async function checkMssqlConnection(url, credentials, options = {}) {
+  let parsed;
+  try {
+    parsed = parseSqlServerJdbcUrl(url, credentials);
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  try {
+    await runMssqlQuery(parsed, "SELECT 1 AS one", options);
+    return { success: true };
+  } catch (err) {
+    let msg = err instanceof Error ? err.message : String(err);
+    msg = msg.replaceAll(url, redactSqlServerUrl(url));
+    return { success: false, error: msg };
+  }
+}
+
+// ../connectors/src/connectors/oracle/utils.ts
+var JDBC_THIN_PREFIX_RE = /^jdbc:oracle:thin:/i;
+var JDBC_OCI_PREFIX_RE = /^jdbc:oracle:oci/i;
+var URL_PREFIX_RE = /^oracle:\/\//i;
+function parseOracleJdbcUrl(jdbcUrl, options = {}) {
+  const trimmed = jdbcUrl.trim();
+  if (JDBC_OCI_PREFIX_RE.test(trimmed)) {
+    throw new Error(
+      "Oracle OCI driver URLs are not supported. Use the thin driver form: jdbc:oracle:thin:@host:port/service"
+    );
+  }
+  if (URL_PREFIX_RE.test(trimmed)) {
+    const url = new URL(trimmed);
+    const path2 = url.pathname.replace(/^\//, "");
+    if (!url.hostname || !path2) {
+      throw new Error(
+        `Invalid Oracle URL "${redactOracleUrl(trimmed)}". Expected oracle://[user:password@]host:port/service`
+      );
+    }
+    const port = url.port || "1521";
+    return {
+      connectString: `${url.hostname}:${port}/${path2}`,
+      user: url.username ? decodeURIComponent(url.username) : options.username,
+      password: url.password ? decodeURIComponent(url.password) : options.password
+    };
+  }
+  if (!JDBC_THIN_PREFIX_RE.test(trimmed)) {
+    throw new Error(
+      `Unsupported Oracle URL "${redactOracleUrl(trimmed)}". Expected prefix: jdbc:oracle:thin:@ or oracle://`
+    );
+  }
+  const afterPrefix = trimmed.replace(JDBC_THIN_PREFIX_RE, "");
+  const atIdx = afterPrefix.indexOf("@");
+  if (atIdx === -1) {
+    throw new Error(
+      `Invalid Oracle JDBC URL "${redactOracleUrl(trimmed)}". Expected '@' separator before host.`
+    );
+  }
+  const credentialsPart = afterPrefix.slice(0, atIdx);
+  const target = afterPrefix.slice(atIdx + 1).replace(/^\/\//, "");
+  let user = options.username;
+  let password = options.password;
+  if (credentialsPart) {
+    const slashIdx = credentialsPart.indexOf("/");
+    if (slashIdx === -1) {
+      user = credentialsPart || user;
+    } else {
+      user = credentialsPart.slice(0, slashIdx) || user;
+      password = credentialsPart.slice(slashIdx + 1) || password;
+    }
+  }
+  if (!target) {
+    throw new Error(
+      `Invalid Oracle JDBC URL "${redactOracleUrl(trimmed)}". Missing host portion after '@'.`
+    );
+  }
+  return {
+    connectString: target,
+    user,
+    password
+  };
+}
+function redactOracleUrl(jdbcUrl) {
+  return jdbcUrl.replace(/(:\/\/)([^@/]+)@/, "$1***@").replace(/(thin:)([^@]+)@/i, "$1***@");
+}
+function parseOracleConnectStringHostPort(connectString) {
+  const m = /^([^:/]+):(\d+)(.*)$/.exec(connectString);
+  if (!m) return null;
+  return { host: m[1], port: Number(m[2]), trailing: m[3] };
+}
+function rewriteOracleConnectStringHostPort(connectString, host, port) {
+  const parts = parseOracleConnectStringHostPort(connectString);
+  if (!parts) return connectString;
+  return `${host}:${port}${parts.trailing}`;
+}
+
+// ../connectors/src/lib/oracle-runner.ts
+async function importOracleDb() {
+  const mod = await import("oracledb");
+  return mod.default ?? mod;
+}
+async function runOracleQuery(parsed, sql, options = {}) {
+  const oracledb = await importOracleDb();
+  let tunnel = null;
+  if (options.tunnelParams) {
+    const hostPort = parseOracleConnectStringHostPort(parsed.connectString);
+    if (hostPort) {
+      tunnel = await maybeOpenSshTunnelHostPort(
+        options.tunnelParams,
+        hostPort.host,
+        hostPort.port
+      );
+    }
+  }
+  try {
+    const connectString = tunnel ? rewriteOracleConnectStringHostPort(
+      parsed.connectString,
+      tunnel.host,
+      tunnel.port
+    ) : parsed.connectString;
+    const connection2 = await oracledb.getConnection({
+      user: parsed.user,
+      password: parsed.password,
+      connectString
+    });
+    try {
+      const result = await connection2.execute(
+        sql,
+        [],
+        {
+          outFormat: oracledb.OUT_FORMAT_OBJECT,
+          // Bound by the connector's own row cap, but keep the driver from
+          // streaming arbitrarily large result sets.
+          maxRows: 5e3
+        }
+      );
+      return { rows: result.rows ?? [] };
+    } finally {
+      try {
+        await connection2.close();
+      } catch {
+      }
+    }
+  } finally {
+    await tunnel?.close();
+  }
+}
+async function checkOracleConnection(url, credentials, options = {}) {
+  let parsed;
+  try {
+    parsed = parseOracleJdbcUrl(url, credentials);
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  try {
+    await runOracleQuery(parsed, "SELECT 1 FROM DUAL", options);
+    return { success: true };
+  } catch (err) {
+    let msg = err instanceof Error ? err.message : String(err);
+    msg = msg.replaceAll(url, redactOracleUrl(url));
+    return { success: false, error: msg };
+  }
+}
 
 // ../connectors/src/connectors/jdbc/parameters.ts
 var parameters = {
@@ -20415,20 +20699,82 @@ var parameters = {
 };
 
 // ../connectors/src/connectors/jdbc/utils.ts
-var JDBC_PREFIX_RE = /^jdbc:(postgresql|postgres|mysql|mariadb):\/\//i;
+var POSTGRES_PREFIX_RE = /^jdbc:(postgresql|postgres):\/\//i;
+var MYSQL_PREFIX_RE = /^jdbc:(mysql|mariadb):\/\//i;
+var REDSHIFT_PREFIX_RE = /^jdbc:redshift:\/\//i;
+var SQLSERVER_PREFIX_RE2 = /^jdbc:sqlserver:\/\//i;
+var ORACLE_PREFIX_RE = /^jdbc:oracle:thin:/i;
+var KNOWN_UNSUPPORTED = [
+  {
+    prefix: /^jdbc:snowflake:\/\//i,
+    message: "Snowflake JDBC URLs are not routable through the generic `jdbc` connector. Use the dedicated `snowflake` connector."
+  },
+  {
+    prefix: /^jdbc:bigquery:\/\//i,
+    message: "BigQuery JDBC URLs are not routable through the generic `jdbc` connector. Use the dedicated `bigquery` connector."
+  },
+  {
+    prefix: /^jdbc:databricks:\/\//i,
+    message: "Databricks JDBC URLs are not routable through the generic `jdbc` connector. Use the dedicated `databricks` connector."
+  },
+  {
+    prefix: /^jdbc:(trino|presto):\/\//i,
+    message: "Trino/Presto JDBC URLs are not yet supported by the `jdbc` connector (no Node.js client bundled)."
+  },
+  {
+    prefix: /^jdbc:td:\/\//i,
+    message: "Treasure Data JDBC URLs are not yet supported by the `jdbc` connector (no Node.js client bundled). The TD JDBC driver speaks Presto under the hood; Trino/Presto support is the same prerequisite."
+  },
+  {
+    prefix: /^jdbc:oracle:oci/i,
+    message: "Oracle OCI driver URLs are not supported. Use the thin driver form: jdbc:oracle:thin:@host:port/service"
+  },
+  {
+    prefix: /^jdbc:db2:\/\//i,
+    message: "DB2 JDBC URLs are not yet supported by the `jdbc` connector."
+  },
+  {
+    prefix: /^jdbc:(sybase|h2|hsqldb|derby|firebird|sqlite):/i,
+    message: "This JDBC dialect is not supported by the `jdbc` connector."
+  }
+];
 function parseJdbcUrl(jdbcUrl, options = {}) {
   const trimmed = jdbcUrl.trim();
-  const match = JDBC_PREFIX_RE.exec(trimmed);
-  if (!match) {
+  if (SQLSERVER_PREFIX_RE2.test(trimmed)) {
+    return { driver: "sqlserver", originalUrl: trimmed };
+  }
+  if (ORACLE_PREFIX_RE.test(trimmed)) {
+    return { driver: "oracle", originalUrl: trimmed };
+  }
+  let driver;
+  let defaultPort;
+  let forceSsl = false;
+  let nativeProtocol;
+  let withoutPrefix;
+  if (POSTGRES_PREFIX_RE.test(trimmed)) {
+    driver = "postgresql";
+    defaultPort = 5432;
+    nativeProtocol = "postgresql://";
+    withoutPrefix = trimmed.replace(POSTGRES_PREFIX_RE, nativeProtocol);
+  } else if (REDSHIFT_PREFIX_RE.test(trimmed)) {
+    driver = "postgresql";
+    defaultPort = 5439;
+    forceSsl = true;
+    nativeProtocol = "postgresql://";
+    withoutPrefix = trimmed.replace(REDSHIFT_PREFIX_RE, nativeProtocol);
+  } else if (MYSQL_PREFIX_RE.test(trimmed)) {
+    driver = "mysql";
+    defaultPort = 3306;
+    nativeProtocol = "mysql://";
+    withoutPrefix = trimmed.replace(MYSQL_PREFIX_RE, nativeProtocol);
+  } else {
+    for (const { prefix, message } of KNOWN_UNSUPPORTED) {
+      if (prefix.test(trimmed)) throw new Error(message);
+    }
     throw new Error(
-      `Unsupported JDBC URL "${redactJdbcUrl(trimmed)}". Supported prefixes: jdbc:postgresql://, jdbc:mysql://, jdbc:mariadb://.`
+      `Unsupported JDBC URL "${redactJdbcUrl(trimmed)}". Supported prefixes: jdbc:postgresql://, jdbc:postgres://, jdbc:mysql://, jdbc:mariadb://, jdbc:sqlserver://, jdbc:oracle:thin:@, jdbc:redshift://.`
     );
   }
-  const subProtocol = match[1].toLowerCase();
-  const driver = subProtocol === "mysql" || subProtocol === "mariadb" ? "mysql" : "postgresql";
-  const defaultPort = driver === "postgresql" ? 5432 : 3306;
-  const nativeProtocol = driver === "postgresql" ? "postgresql://" : "mysql://";
-  const withoutPrefix = trimmed.replace(JDBC_PREFIX_RE, nativeProtocol);
   const url = new URL(withoutPrefix);
   if (options.username && !url.username) {
     url.username = encodeURIComponent(options.username);
@@ -20436,10 +20782,10 @@ function parseJdbcUrl(jdbcUrl, options = {}) {
   if (options.password && !url.password) {
     url.password = encodeURIComponent(options.password);
   }
-  return { driver, nativeUrl: url.toString(), defaultPort };
+  return { driver, nativeUrl: url.toString(), defaultPort, forceSsl };
 }
 function redactJdbcUrl(jdbcUrl) {
-  return jdbcUrl.replace(/(:\/\/)([^@/]+)@/, "$1***@");
+  return jdbcUrl.replace(/(:\/\/)([^@/]+)@/, "$1***@").replace(/(password\s*=\s*)([^;&]+)/gi, "$1***");
 }
 
 // ../connectors/src/connectors/jdbc/sdk/index.ts
@@ -20452,46 +20798,80 @@ function createClient(params) {
   const password = params[parameters.password.slug];
   const parsed = parseJdbcUrl(jdbcUrl, { username, password });
   async function runQuery(sql, queryParams) {
-    let tunnel;
     try {
-      tunnel = await maybeOpenSshTunnel(
+      if (parsed.driver === "sqlserver") {
+        if (queryParams && queryParams.length > 0) {
+          throw new Error(
+            "jdbc sdk: positional parameters are not yet supported for the sqlserver route. Inline literals into the SQL."
+          );
+        }
+        const mssqlParsed = parseSqlServerJdbcUrl(parsed.originalUrl, {
+          username,
+          password
+        });
+        const result = await runMssqlQuery(mssqlParsed, sql, {
+          tunnelParams: params
+        });
+        return result.rows;
+      }
+      if (parsed.driver === "oracle") {
+        if (queryParams && queryParams.length > 0) {
+          throw new Error(
+            "jdbc sdk: positional parameters are not yet supported for the oracle route. Inline literals into the SQL."
+          );
+        }
+        const oracleParsed = parseOracleJdbcUrl(parsed.originalUrl, {
+          username,
+          password
+        });
+        const cleanSql = sql.replace(/;\s*$/, "");
+        const result = await runOracleQuery(oracleParsed, cleanSql, {
+          tunnelParams: params
+        });
+        return result.rows;
+      }
+      const tunnel = await maybeOpenSshTunnel(
         params,
         parsed.nativeUrl,
         parsed.defaultPort
       );
-      if (parsed.driver === "postgresql") {
-        const { Pool } = await import("pg");
-        const pool2 = new Pool({
-          connectionString: tunnel.connectionUrl,
-          ssl: { rejectUnauthorized: false },
-          connectionTimeoutMillis: 1e4,
-          statement_timeout: 6e4
+      try {
+        if (parsed.driver === "postgresql") {
+          const { Pool } = await import("pg");
+          const pool2 = new Pool({
+            connectionString: tunnel.connectionUrl,
+            ssl: { rejectUnauthorized: false },
+            connectionTimeoutMillis: 1e4,
+            statement_timeout: 6e4
+          });
+          try {
+            const result = await pool2.query(sql, queryParams);
+            return result.rows;
+          } finally {
+            await pool2.end();
+          }
+        }
+        const mysql = await import("mysql2/promise");
+        const pool = mysql.createPool({
+          uri: tunnel.connectionUrl,
+          connectTimeout: 1e4
         });
         try {
-          const result = await pool2.query(sql, queryParams);
-          return result.rows;
+          const [rows] = await pool.query(sql, queryParams);
+          return Array.isArray(rows) ? rows : [];
         } finally {
-          await pool2.end();
+          await pool.end();
         }
-      }
-      const mysql = await import("mysql2/promise");
-      const pool = mysql.createPool({
-        uri: tunnel.connectionUrl,
-        connectTimeout: 1e4
-      });
-      try {
-        const [rows] = await pool.query(sql, queryParams);
-        return Array.isArray(rows) ? rows : [];
       } finally {
-        await pool.end();
+        await tunnel.close();
       }
     } catch (err) {
       let msg = err instanceof Error ? err.message : String(err);
-      msg = msg.replaceAll(parsed.nativeUrl, redactJdbcUrl(jdbcUrl));
+      if (parsed.driver === "postgresql" || parsed.driver === "mysql") {
+        msg = msg.replaceAll(parsed.nativeUrl, redactJdbcUrl(jdbcUrl));
+      }
       msg = msg.replaceAll(jdbcUrl, redactJdbcUrl(jdbcUrl));
       throw new Error(msg);
-    } finally {
-      await tunnel?.close();
     }
   }
   return {
@@ -20678,7 +21058,7 @@ var inputSchema = z.object({
   ),
   connectionId: z.string().describe("ID of the JDBC connection to use"),
   sql: z.string().describe(
-    "SQL query to execute. Use the dialect that matches the JDBC URL (PostgreSQL or MySQL/MariaDB). Always include LIMIT."
+    "SQL query to execute. Use the dialect that matches the JDBC URL prefix (PostgreSQL / Redshift: LIMIT N; MySQL/MariaDB: LIMIT N; SQL Server: TOP N; Oracle: FETCH FIRST N ROWS ONLY). Always bound the row count."
   )
 });
 var outputSchema = z.discriminatedUnion("success", [
@@ -20696,9 +21076,10 @@ var outputSchema = z.discriminatedUnion("success", [
 var executeQueryTool = new ConnectorTool({
   name: "executeQuery",
   description: `Execute a SQL query through the JDBC connector. Returns up to ${MAX_ROWS} rows.
-Use for: schema exploration via \`information_schema\`, data sampling, analytical queries.
-The connector dispatches by JDBC URL prefix to the matching driver (PostgreSQL or MySQL/MariaDB),
-so use the dialect that matches the connection. Always include LIMIT.`,
+Use for: schema exploration via \`information_schema\` (or USER_TABLES on Oracle), data sampling, analytical queries.
+The connector dispatches by JDBC URL prefix to the matching driver
+(PostgreSQL / Redshift / MySQL / MariaDB / SQL Server / Oracle), so use the dialect that matches the connection.
+Always bound results: LIMIT for PG/MySQL/Redshift, TOP for SQL Server, FETCH FIRST for Oracle.`,
   inputSchema,
   outputSchema,
   async execute({ connectionId, sql }, connections) {
@@ -20724,87 +21105,139 @@ so use the dialect that matches the connection. Always include LIMIT.`,
         error: err instanceof Error ? err.message : String(err)
       };
     }
-    let tunnel;
     try {
-      tunnel = await maybeOpenSshTunnel(
-        connectionParamsToRecord(connection2),
-        parsed.nativeUrl,
-        parsed.defaultPort
-      );
-      if (parsed.driver === "postgresql") {
-        const { Pool } = await import("pg");
-        const pool2 = new Pool({
-          connectionString: tunnel.connectionUrl,
-          ssl: { rejectUnauthorized: false },
-          connectionTimeoutMillis: CONNECT_TIMEOUT_MS,
-          statement_timeout: STATEMENT_TIMEOUT_MS
+      const tunnelParams = connectionParamsToRecord(connection2);
+      if (parsed.driver === "sqlserver") {
+        const mssqlParsed = parseSqlServerJdbcUrl(parsed.originalUrl, {
+          username,
+          password
+        });
+        const result = await runMssqlQuery(mssqlParsed, sql, { tunnelParams });
+        const rows = result.rows;
+        return {
+          success: true,
+          rowCount: Math.min(rows.length, MAX_ROWS),
+          truncated: rows.length > MAX_ROWS,
+          rows: rows.slice(0, MAX_ROWS)
+        };
+      }
+      if (parsed.driver === "oracle") {
+        const oracleParsed = parseOracleJdbcUrl(parsed.originalUrl, {
+          username,
+          password
+        });
+        const cleanSql = sql.replace(/;\s*$/, "");
+        const result = await runOracleQuery(oracleParsed, cleanSql, {
+          tunnelParams
+        });
+        const rows = result.rows;
+        return {
+          success: true,
+          rowCount: Math.min(rows.length, MAX_ROWS),
+          truncated: rows.length > MAX_ROWS,
+          rows: rows.slice(0, MAX_ROWS)
+        };
+      }
+      let tunnel;
+      try {
+        tunnel = await maybeOpenSshTunnel(
+          tunnelParams,
+          parsed.nativeUrl,
+          parsed.defaultPort
+        );
+        if (parsed.driver === "postgresql") {
+          const { Pool } = await import("pg");
+          const pool2 = new Pool({
+            connectionString: tunnel.connectionUrl,
+            ssl: { rejectUnauthorized: false },
+            connectionTimeoutMillis: CONNECT_TIMEOUT_MS,
+            statement_timeout: STATEMENT_TIMEOUT_MS
+          });
+          try {
+            const result = await pool2.query(sql);
+            const rows = result.rows;
+            const truncated = rows.length > MAX_ROWS;
+            return {
+              success: true,
+              rowCount: Math.min(rows.length, MAX_ROWS),
+              truncated,
+              rows: rows.slice(0, MAX_ROWS)
+            };
+          } finally {
+            await pool2.end();
+          }
+        }
+        const mysql = await import("mysql2/promise");
+        const pool = mysql.createPool({
+          uri: tunnel.connectionUrl,
+          connectTimeout: CONNECT_TIMEOUT_MS
         });
         try {
-          const result = await pool2.query(sql);
-          const rows = result.rows;
-          const truncated = rows.length > MAX_ROWS;
+          const queryPromise = pool.query(sql);
+          const timeoutPromise = new Promise(
+            (_, reject) => setTimeout(
+              () => reject(new Error("Query timed out after 60 seconds")),
+              STATEMENT_TIMEOUT_MS
+            )
+          );
+          const [rows] = await Promise.race([queryPromise, timeoutPromise]);
+          const resultRows = Array.isArray(rows) ? rows : [];
+          const truncated = resultRows.length > MAX_ROWS;
           return {
             success: true,
-            rowCount: Math.min(rows.length, MAX_ROWS),
+            rowCount: Math.min(resultRows.length, MAX_ROWS),
             truncated,
-            rows: rows.slice(0, MAX_ROWS)
+            rows: resultRows.slice(0, MAX_ROWS)
           };
         } finally {
-          await pool2.end();
+          await pool.end();
         }
-      }
-      const mysql = await import("mysql2/promise");
-      const pool = mysql.createPool({
-        uri: tunnel.connectionUrl,
-        connectTimeout: CONNECT_TIMEOUT_MS
-      });
-      try {
-        const queryPromise = pool.query(sql);
-        const timeoutPromise = new Promise(
-          (_, reject) => setTimeout(
-            () => reject(new Error("Query timed out after 60 seconds")),
-            STATEMENT_TIMEOUT_MS
-          )
-        );
-        const [rows] = await Promise.race([queryPromise, timeoutPromise]);
-        const resultRows = Array.isArray(rows) ? rows : [];
-        const truncated = resultRows.length > MAX_ROWS;
-        return {
-          success: true,
-          rowCount: Math.min(resultRows.length, MAX_ROWS),
-          truncated,
-          rows: resultRows.slice(0, MAX_ROWS)
-        };
       } finally {
-        await pool.end();
+        await tunnel?.close();
       }
     } catch (err) {
       let msg = err instanceof Error ? err.message : String(err);
-      msg = msg.replaceAll(parsed.nativeUrl, redactJdbcUrl(jdbcUrl));
+      if (parsed.driver === "postgresql" || parsed.driver === "mysql") {
+        msg = msg.replaceAll(parsed.nativeUrl, redactJdbcUrl(jdbcUrl));
+      }
       msg = msg.replaceAll(jdbcUrl, redactJdbcUrl(jdbcUrl));
       return { success: false, error: msg };
-    } finally {
-      await tunnel?.close();
     }
   }
 });
 
+// ../connectors/src/lib/unwrap-sample-limit.ts
+var STRICT_WRAPPER_RE = /^\s*SELECT\s+\*\s+FROM\s+\(([\s\S]+)\)\s+AS\s+\w+\s+LIMIT\s+(\d+)\s*;?\s*$/i;
+var TRAILING_LIMIT_RE = /\s+LIMIT\s+(\d+)\s*;?\s*$/i;
+function unwrapSampleLimit(sql) {
+  const strict = sql.match(STRICT_WRAPPER_RE);
+  if (strict) {
+    return { inner: strict[1].trim(), limit: Number.parseInt(strict[2], 10) };
+  }
+  const trailing = sql.match(TRAILING_LIMIT_RE);
+  if (!trailing) return null;
+  if (!/^\s*SELECT\s+\*\s+FROM\s*\(/i.test(sql)) return null;
+  const limit = Number.parseInt(trailing[1], 10);
+  const inner = sql.slice(0, sql.length - trailing[0].length).trim();
+  return { inner, limit };
+}
+
 // ../connectors/src/connectors/jdbc/index.ts
 var tools = { executeQuery: executeQueryTool };
 var jdbcConnector = new ConnectorPlugin({
   slug: "jdbc",
   authType: AUTH_TYPES.USER_PASSWORD,
   name: "JDBC",
-  description: "Generic JDBC-style connection. Accepts a JDBC URL and dispatches to the matching driver (PostgreSQL, MySQL, MariaDB).",
+  description: "Generic JDBC-style connection. Accepts a JDBC URL and dispatches to the matching driver (PostgreSQL, MySQL/MariaDB, SQL Server, Oracle, Redshift).",
   iconUrl: "https://images.ctfassets.net/9ncizv60xc5y/4Hgb5qQffrdu5nOkc49WtM/76d82ef6b108c7780e42998137c61b83/jdbc-icon.png",
   parameters,
-  releaseFlag: { dev1: true, dev2: false, prod: false },
+  releaseFlag: { dev1: true, dev2: true, prod: true },
   categories: ["database"],
   onboarding: jdbcOnboarding,
   systemPrompt: {
     en: `### Tools
 
-- \`jdbc_executeQuery\`: Executes a SQL query through a JDBC URL and returns rows. The connector dispatches by URL prefix to the matching driver (PostgreSQL or MySQL/MariaDB), so use the dialect that matches the connection. Use this for schema exploration via \`information_schema\` and for sampling data. See the SQL Reference below.
+- \`jdbc_executeQuery\`: Executes a SQL query through a JDBC URL and returns rows. The connector dispatches by URL prefix to the matching native driver, so use the dialect that matches the connection. Use this for schema exploration via \`information_schema\` (or vendor equivalent) and for sampling data. See the SQL Reference below.
 
 ### Business Logic
 
@@ -20814,16 +21247,29 @@ The business logic type for this connector is "sql".
 
 The dialect depends on the JDBC URL prefix:
 
-- \`jdbc:postgresql://...\` \u2192 PostgreSQL dialect
+- \`jdbc:postgresql://...\` / \`jdbc:postgres://...\` \u2192 PostgreSQL (driver: \`pg\`). \`LIMIT N\` is native.
   - List tables: \`SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'\`
   - List columns: \`SELECT column_name, data_type FROM information_schema.columns WHERE table_schema = 'public' AND table_name = 'xxx'\`
-- \`jdbc:mysql://...\` / \`jdbc:mariadb://...\` \u2192 MySQL dialect
+- \`jdbc:redshift://...\` \u2192 Amazon Redshift (driver: \`pg\` with SSL forced; default port 5439). PostgreSQL-compatible wire protocol; \`LIMIT N\` is native.
+- \`jdbc:mysql://...\` / \`jdbc:mariadb://...\` \u2192 MySQL / MariaDB (driver: \`mysql2\`). \`LIMIT N\` is native.
   - List tables: \`SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE()\`
   - List columns: \`SELECT COLUMN_NAME, DATA_TYPE FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'xxx'\`
-- Always include LIMIT in queries`,
+- \`jdbc:sqlserver://...\` \u2192 Microsoft SQL Server / Azure SQL (driver: \`mssql\` / \`tedious\`). T-SQL dialect. **Use \`TOP N\` instead of \`LIMIT N\`** in queries you write.
+  - List tables: \`SELECT TABLE_SCHEMA, TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'\`
+  - List columns: \`SELECT COLUMN_NAME, DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = 'xxx'\`
+- \`jdbc:oracle:thin:@host:port/service\` (or \`@//host:port/service\` / \`@host:port:sid\`) \u2192 Oracle Database (driver: \`oracledb\` thin). Oracle SQL. **No \`LIMIT\` keyword** \u2014 use \`FETCH FIRST N ROWS ONLY\`, \`OFFSET m ROWS FETCH NEXT N ROWS ONLY\`, or \`ROWNUM\` filters.
+  - List tables: \`SELECT TABLE_NAME FROM USER_TABLES\`
+  - List columns: \`SELECT COLUMN_NAME, DATA_TYPE FROM USER_TAB_COLUMNS WHERE TABLE_NAME = UPPER('xxx')\`
+
+Explicitly **not** supported via this connector \u2014 use the dedicated connector or open a request:
+\`jdbc:snowflake://\` (use \`snowflake\`), \`jdbc:bigquery://\` (use \`bigquery\`), \`jdbc:databricks://\` (use \`databricks\`), \`jdbc:trino://\` / \`jdbc:presto://\` / \`jdbc:td://\` (Treasure Data) \u2014 no Node.js client bundled.
+
+### Row-limit compatibility (server-logic schema inference)
+
+The platform's server-logic schema inference may wrap your query as \`SELECT * FROM (<inner>) AS _sq LIMIT N\` (PostgreSQL/MySQL syntax). For PostgreSQL / Redshift / MySQL routes this executes natively. For \`jdbc:sqlserver://\` and \`jdbc:oracle:thin:\` routes, the connector detects this exact wrapper at \`query()\` time, executes \`<inner>\` directly via the dialect-specific driver, and slices the first N rows in JS. You do not need to handle this \u2014 but in queries **you author**, do not use \`LIMIT\` for the SQL Server / Oracle routes; use \`TOP\` / \`FETCH FIRST\` as listed above.`,
     ja: `### \u30C4\u30FC\u30EB
 
-- \`jdbc_executeQuery\`: JDBC URL \u7D4C\u7531\u3067 SQL \u30AF\u30A8\u30EA\u3092\u5B9F\u884C\u3057\u3001\u884C\u30C7\u30FC\u30BF\u3092\u8FD4\u3057\u307E\u3059\u3002\u30B3\u30CD\u30AF\u30BF\u306F URL \u30D7\u30EC\u30D5\u30A3\u30C3\u30AF\u30B9\u304B\u3089\u5BFE\u5FDC\u3059\u308B\u30C9\u30E9\u30A4\u30D0\uFF08PostgreSQL \u307E\u305F\u306F MySQL/MariaDB\uFF09\u306B\u632F\u308A\u5206\u3051\u308B\u305F\u3081\u3001\u63A5\u7D9A\u5148\u306B\u5408\u3063\u305F\u65B9\u8A00\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\u3002\`information_schema\` \u3092\u4F7F\u3063\u305F\u30B9\u30AD\u30FC\u30DE\u63A2\u7D22\u3084\u30C7\u30FC\u30BF\u306E\u30B5\u30F3\u30D7\u30EA\u30F3\u30B0\u306B\u4F7F\u3044\u307E\u3059\u3002\u4E0B\u90E8\u306E\u300CSQL \u30EA\u30D5\u30A1\u30EC\u30F3\u30B9\u300D\u3092\u53C2\u7167\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+- \`jdbc_executeQuery\`: JDBC URL \u7D4C\u7531\u3067 SQL \u30AF\u30A8\u30EA\u3092\u5B9F\u884C\u3057\u3001\u884C\u30C7\u30FC\u30BF\u3092\u8FD4\u3057\u307E\u3059\u3002\u30B3\u30CD\u30AF\u30BF\u306F URL \u30D7\u30EC\u30D5\u30A3\u30C3\u30AF\u30B9\u304B\u3089\u5BFE\u5FDC\u3059\u308B\u30CD\u30A4\u30C6\u30A3\u30D6\u30C9\u30E9\u30A4\u30D0\u3078\u632F\u308A\u5206\u3051\u308B\u305F\u3081\u3001\u63A5\u7D9A\u5148\u306B\u5408\u3063\u305F\u65B9\u8A00\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\u3002\`information_schema\`\uFF08\u307E\u305F\u306F\u5404 DB \u306E\u540C\u7B49\u306E\u30E1\u30BF\u30C7\u30FC\u30BF\u30D3\u30E5\u30FC\uFF09\u3092\u4F7F\u3063\u305F\u30B9\u30AD\u30FC\u30DE\u63A2\u7D22\u3084\u30C7\u30FC\u30BF\u306E\u30B5\u30F3\u30D7\u30EA\u30F3\u30B0\u306B\u4F7F\u3044\u307E\u3059\u3002\u4E0B\u90E8\u306E\u300CSQL \u30EA\u30D5\u30A1\u30EC\u30F3\u30B9\u300D\u3092\u53C2\u7167\u3057\u3066\u304F\u3060\u3055\u3044\u3002
 
 ### Business Logic
 
@@ -20833,13 +21279,26 @@ The dialect depends on the JDBC URL prefix:
 
 JDBC URL \u306E\u30D7\u30EC\u30D5\u30A3\u30C3\u30AF\u30B9\u306B\u3088\u308A\u65B9\u8A00\u304C\u6C7A\u307E\u308A\u307E\u3059:
 
-- \`jdbc:postgresql://...\` \u2192 PostgreSQL \u65B9\u8A00
+- \`jdbc:postgresql://...\` / \`jdbc:postgres://...\` \u2192 PostgreSQL\uFF08\u30C9\u30E9\u30A4\u30D0: \`pg\`\uFF09\u3002\`LIMIT N\` \u304C\u30CD\u30A4\u30C6\u30A3\u30D6\u3067\u4F7F\u3048\u307E\u3059\u3002
   - \u30C6\u30FC\u30D6\u30EB\u4E00\u89A7: \`SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'\`
   - \u30AB\u30E9\u30E0\u4E00\u89A7: \`SELECT column_name, data_type FROM information_schema.columns WHERE table_schema = 'public' AND table_name = 'xxx'\`
-- \`jdbc:mysql://...\` / \`jdbc:mariadb://...\` \u2192 MySQL \u65B9\u8A00
+- \`jdbc:redshift://...\` \u2192 Amazon Redshift\uFF08\u30C9\u30E9\u30A4\u30D0: \`pg\`\u3001SSL \u5F37\u5236\u3001\u30C7\u30D5\u30A9\u30EB\u30C8\u30DD\u30FC\u30C8 5439\uFF09\u3002PostgreSQL \u30EF\u30A4\u30E4\u4E92\u63DB\u306E\u305F\u3081 \`LIMIT N\` \u304C\u305D\u306E\u307E\u307E\u4F7F\u3048\u307E\u3059\u3002
+- \`jdbc:mysql://...\` / \`jdbc:mariadb://...\` \u2192 MySQL / MariaDB\uFF08\u30C9\u30E9\u30A4\u30D0: \`mysql2\`\uFF09\u3002\`LIMIT N\` \u304C\u30CD\u30A4\u30C6\u30A3\u30D6\u3067\u4F7F\u3048\u307E\u3059\u3002
   - \u30C6\u30FC\u30D6\u30EB\u4E00\u89A7: \`SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE()\`
   - \u30AB\u30E9\u30E0\u4E00\u89A7: \`SELECT COLUMN_NAME, DATA_TYPE FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'xxx'\`
-- \u30AF\u30A8\u30EA\u306B\u306F\u5FC5\u305A LIMIT \u3092\u542B\u3081\u3066\u304F\u3060\u3055\u3044`
+- \`jdbc:sqlserver://...\` \u2192 Microsoft SQL Server / Azure SQL\uFF08\u30C9\u30E9\u30A4\u30D0: \`mssql\` / \`tedious\`\uFF09\u3002T-SQL \u65B9\u8A00\u3002**\u81EA\u5206\u3067\u66F8\u304F SQL \u3067\u306F \`LIMIT N\` \u3067\u306F\u306A\u304F \`TOP N\` \u3092\u4F7F\u3046\u3053\u3068**\u3002
+  - \u30C6\u30FC\u30D6\u30EB\u4E00\u89A7: \`SELECT TABLE_SCHEMA, TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'\`
+  - \u30AB\u30E9\u30E0\u4E00\u89A7: \`SELECT COLUMN_NAME, DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = 'xxx'\`
+- \`jdbc:oracle:thin:@host:port/service\`\uFF08\`@//host:port/service\` / \`@host:port:sid\` \u3082\u53EF\uFF09\u2192 Oracle Database\uFF08\u30C9\u30E9\u30A4\u30D0: \`oracledb\` thin\uFF09\u3002Oracle SQL\u3002**\`LIMIT\` \u30AD\u30FC\u30EF\u30FC\u30C9\u306F\u5B58\u5728\u3057\u307E\u305B\u3093** \u2014 \`FETCH FIRST N ROWS ONLY\` / \`OFFSET m ROWS FETCH NEXT N ROWS ONLY\` / \`ROWNUM\` \u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+  - \u30C6\u30FC\u30D6\u30EB\u4E00\u89A7: \`SELECT TABLE_NAME FROM USER_TABLES\`
+  - \u30AB\u30E9\u30E0\u4E00\u89A7: \`SELECT COLUMN_NAME, DATA_TYPE FROM USER_TAB_COLUMNS WHERE TABLE_NAME = UPPER('xxx')\`
+
+\u3053\u306E\u30B3\u30CD\u30AF\u30BF\u3067\u306F **\u30B5\u30DD\u30FC\u30C8\u5916**\uFF08\u5C02\u7528\u30B3\u30CD\u30AF\u30BF\u3092\u4F7F\u3046\u304B\u3001\u30EA\u30AF\u30A8\u30B9\u30C8\u8FFD\u52A0\u3057\u3066\u304F\u3060\u3055\u3044\uFF09:
+\`jdbc:snowflake://\`\uFF08\`snowflake\` \u3092\u4F7F\u7528\uFF09\u3001\`jdbc:bigquery://\`\uFF08\`bigquery\` \u3092\u4F7F\u7528\uFF09\u3001\`jdbc:databricks://\`\uFF08\`databricks\` \u3092\u4F7F\u7528\uFF09\u3001\`jdbc:trino://\` / \`jdbc:presto://\` / \`jdbc:td://\`\uFF08Treasure Data\uFF09\u2014 Node.js \u30AF\u30E9\u30A4\u30A2\u30F3\u30C8\u3092\u540C\u68B1\u3057\u3066\u3044\u307E\u305B\u3093\u3002
+
+### \u884C\u6570\u5236\u9650\u306E\u4E92\u63DB\u6027\uFF08server-logic \u30B9\u30AD\u30FC\u30DE\u63A8\u8AD6\uFF09
+
+\u30D7\u30E9\u30C3\u30C8\u30D5\u30A9\u30FC\u30E0\u306E server-logic \u30B9\u30AD\u30FC\u30DE\u63A8\u8AD6\u306F\u3001\u30AF\u30A8\u30EA\u3092 \`SELECT * FROM (<inner>) AS _sq LIMIT N\`\uFF08PostgreSQL/MySQL \u69CB\u6587\uFF09\u306E\u5F62\u3067\u30E9\u30C3\u30D7\u3057\u3066\u304F\u308B\u3053\u3068\u304C\u3042\u308A\u307E\u3059\u3002PostgreSQL / Redshift / MySQL \u30EB\u30FC\u30C8\u3067\u306F\u305D\u306E\u307E\u307E\u5B9F\u884C\u3055\u308C\u307E\u3059\u3002\`jdbc:sqlserver://\` \u304A\u3088\u3073 \`jdbc:oracle:thin:\` \u30EB\u30FC\u30C8\u3067\u306F\u3001\u30B3\u30CD\u30AF\u30BF\u304C \`query()\` \u5185\u3067\u3053\u306E\u30E9\u30C3\u30D1\u3092\u691C\u51FA\u3057\u3001\`<inner>\` \u3092\u65B9\u8A00\u56FA\u6709\u306E\u30C9\u30E9\u30A4\u30D0\u3067\u76F4\u63A5\u5B9F\u884C\u3057\u3066 JS \u5074\u3067\u5148\u982D N \u884C\u306B\u5207\u308A\u8A70\u3081\u307E\u3059\u3002\u5229\u7528\u8005\u5074\u3067\u5BFE\u51E6\u3059\u308B\u5FC5\u8981\u306F\u3042\u308A\u307E\u305B\u3093\u304C\u3001**\u81EA\u5206\u3067\u66F8\u304F SQL** \u3067\u306F SQL Server / Oracle \u30EB\u30FC\u30C8\u3067 \`LIMIT\` \u3092\u4F7F\u308F\u305A\u3001\u4E0A\u8A18\u306E \`TOP\` / \`FETCH FIRST\` \u3092\u4F7F\u3063\u3066\u304F\u3060\u3055\u3044\u3002`
   },
   tools,
   async checkConnection(params, _config) {
@@ -20855,6 +21314,20 @@ JDBC URL \u306E\u30D7\u30EC\u30D5\u30A3\u30C3\u30AF\u30B9\u306B\u3088\u308A\u65B
         error: e instanceof Error ? e.message : String(e)
       };
     }
+    if (parsed.driver === "sqlserver") {
+      return checkMssqlConnection(
+        parsed.originalUrl,
+        { username, password },
+        { tunnelParams: params }
+      );
+    }
+    if (parsed.driver === "oracle") {
+      return checkOracleConnection(
+        parsed.originalUrl,
+        { username, password },
+        { tunnelParams: params }
+      );
+    }
     const tunnel = await maybeOpenSshTunnel(
       params,
       parsed.nativeUrl,
@@ -20864,7 +21337,7 @@ JDBC URL \u306E\u30D7\u30EC\u30D5\u30A3\u30C3\u30AF\u30B9\u306B\u3088\u308A\u65B
       const { Pool } = await import("pg");
       const pool2 = new Pool({
         connectionString: tunnel.connectionUrl,
-        ssl: { rejectUnauthorized: false },
+        ssl: parsed.forceSsl ? { rejectUnauthorized: false } : { rejectUnauthorized: false },
         connectionTimeoutMillis: 1e4
       });
       try {
@@ -20903,6 +21376,36 @@ JDBC URL \u306E\u30D7\u30EC\u30D5\u30A3\u30C3\u30AF\u30B9\u306B\u3088\u308A\u65B
     const username = params[parameters.username.slug];
     const password = params[parameters.password.slug];
     const parsed = parseJdbcUrl(jdbcUrl, { username, password });
+    if (parsed.driver === "sqlserver") {
+      const mssqlParsed = parseSqlServerJdbcUrl(parsed.originalUrl, {
+        username,
+        password
+      });
+      const sample = unwrapSampleLimit(sql);
+      if (sample) {
+        const result = await runMssqlQuery(mssqlParsed, sample.inner, {
+          tunnelParams: params
+        });
+        return { rows: result.rows.slice(0, sample.limit) };
+      }
+      return runMssqlQuery(mssqlParsed, sql, { tunnelParams: params });
+    }
+    if (parsed.driver === "oracle") {
+      const oracleParsed = parseOracleJdbcUrl(parsed.originalUrl, {
+        username,
+        password
+      });
+      const sample = unwrapSampleLimit(sql);
+      if (sample) {
+        const inner = sample.inner.replace(/;\s*$/, "");
+        const result = await runOracleQuery(oracleParsed, inner, {
+          tunnelParams: params
+        });
+        return { rows: result.rows.slice(0, sample.limit) };
+      }
+      const cleanSql = sql.replace(/;\s*$/, "");
+      return runOracleQuery(oracleParsed, cleanSql, { tunnelParams: params });
+    }
     const tunnel = await maybeOpenSshTunnel(
       params,
       parsed.nativeUrl,
@@ -20913,7 +21416,7 @@ JDBC URL \u306E\u30D7\u30EC\u30D5\u30A3\u30C3\u30AF\u30B9\u306B\u3088\u308A\u65B
       const cleanSql = sql.replace(/;\s*$/, "");
       const pool2 = new Pool({
         connectionString: tunnel.connectionUrl,
-        ssl: { rejectUnauthorized: false },
+        ssl: parsed.forceSsl ? { rejectUnauthorized: false } : { rejectUnauthorized: false },
         connectionTimeoutMillis: 1e4,
         statement_timeout: 6e4
       });