@hechtcarmel/vertica-mcp/dist/tools/execute-query.js

MCP (Model Context Protocol) server for readonly Vertica database operations

import { z } from "zod";
import { VerticaService } from "../services/vertica-service.js";
import { getDatabaseConfig } from "../config/database.js";
import { formatQueryResult } from "../utils/response-formatter.js";
export default class ExecuteQueryTool {
    name = "execute_query";
    description = "Execute a readonly SQL query against the Vertica database. Supports SELECT, SHOW, DESCRIBE, EXPLAIN, and WITH queries.";
    inputSchema = {
        type: "object",
        properties: {
            sql: {
                type: "string",
                description: "SQL query to execute. Must be a readonly query (SELECT, SHOW, DESCRIBE, EXPLAIN, or WITH).",
            },
            params: {
                type: "array",
                items: {},
                description: "Optional parameters for parameterized queries.",
            },
        },
        required: ["sql"],
    };
    async execute(input) {
        const parsed = this.parseInput(input);
        let service = null;
        try {
            const config = getDatabaseConfig();
            service = new VerticaService(config);
            const result = await service.executeQuery(parsed.sql, parsed.params || []);
            const formatted = formatQueryResult({
                ...result,
                query: parsed.sql,
            });
            return JSON.stringify({
                success: true,
                ...formatted,
                query: parsed.sql,
                executedAt: new Date().toISOString(),
            }, null, 2);
        }
        catch (error) {
            const errorMessage = error instanceof Error ? error.message : String(error);
            return JSON.stringify({
                success: false,
                error: errorMessage,
                query: parsed.sql,
                executedAt: new Date().toISOString(),
            }, null, 2);
        }
        finally {
            if (service) {
                try {
                    await service.disconnect();
                }
                catch (error) {
                    console.warn("Warning during service cleanup:", error);
                }
            }
        }
    }
    parseInput(input) {
        const schema = z.object({
            sql: z.string(),
            params: z.array(z.unknown()).optional(),
        });
        return schema.parse(input);
    }
}
//# sourceMappingURL=execute-query.js.map