@cano721/mysql-mcp-server 0.9.3 → 0.9.4

package/build/index.js

@@ -318,6 +318,39 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         throw new McpError(ErrorCode.InvalidParams, "Database name is required (no default database set)");
                     }
                 }
+                // 🚀 최적화: 한 번에 모든 FK 관계를 가져오기
+                console.error('[Tool] Fetching all FK relationships at once');
+                const allFKQuery = `
+          SELECT 
+            TABLE_NAME as child_table,
+            COLUMN_NAME as fk_column,
+            REFERENCED_TABLE_NAME as parent_table
+          FROM information_schema.KEY_COLUMN_USAGE
+          WHERE TABLE_SCHEMA = ?
+            AND REFERENCED_TABLE_NAME IS NOT NULL
+        `;
+                const { rows: allFKRows } = await executeQuery(pool, allFKQuery, [dbName]);
+                // FK 관계를 Map으로 구성 (빠른 조회를 위해)
+                const childToParents = new Map();
+                const parentToChildren = new Map();
+                for (const row of allFKRows) {
+                    const relation = {
+                        child: row.child_table,
+                        fk_column: row.fk_column,
+                        parent: row.parent_table
+                    };
+                    // child -> parent 매핑
+                    if (!childToParents.has(row.child_table)) {
+                        childToParents.set(row.child_table, []);
+                    }
+                    childToParents.get(row.child_table).push(relation);
+                    // parent -> child 매핑
+                    if (!parentToChildren.has(row.parent_table)) {
+                        parentToChildren.set(row.parent_table, []);
+                    }
+                    parentToChildren.get(row.parent_table).push(relation);
+                }
+                console.error(`[Tool] Loaded ${allFKRows.length} FK relationships into memory`);
                 const results = [];
                 const visited = new Set();
                 const circularReferences = [];
@@ -330,85 +363,67 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     if (current.depth >= requestedDepth)
                         continue;
                     // Find child tables (tables that reference the current table)
-                    const childQuery = `
-            SELECT 
-              TABLE_NAME as child_table,
-              COLUMN_NAME as fk_column,
-              REFERENCED_TABLE_NAME as parent_table
-            FROM information_schema.KEY_COLUMN_USAGE
-            WHERE REFERENCED_TABLE_SCHEMA = ?
-              AND REFERENCED_TABLE_NAME = ?
-              AND REFERENCED_TABLE_NAME IS NOT NULL
-          `;
-                    const { rows: childRows } = await executeQuery(pool, childQuery, [dbName, current.tableName]);
-                    for (const row of childRows) {
+                    const childRelations = parentToChildren.get(current.tableName) || [];
+                    for (const relation of childRelations) {
                         results.push({
                             depth: current.depth + 1,
-                            child_table: row.child_table,
-                            fk_column: row.fk_column,
-                            parent_table: row.parent_table,
+                            child_table: relation.child,
+                            fk_column: relation.fk_column,
+                            parent_table: relation.parent,
                             match_type: 'fk_constraint'
                         });
-                        if (!visited.has(row.child_table)) {
-                            visited.add(row.child_table);
+                        if (!visited.has(relation.child)) {
+                            visited.add(relation.child);
                             queue.push({
-                                tableName: row.child_table,
+                                tableName: relation.child,
                                 depth: current.depth + 1,
-                                path: [...current.path, row.child_table]
+                                path: [...current.path, relation.child]
                             });
                         }
-                        else if (current.path.includes(row.child_table)) {
+                        else if (current.path.includes(relation.child)) {
                             // 순환 참조 감지
-                            const cycleStart = current.path.indexOf(row.child_table);
-                            const cyclePath = [...current.path.slice(cycleStart), row.child_table];
-                            circularReferences.push({
-                                path: cyclePath,
-                                description: `${cyclePath.join(' → ')}`
-                            });
+                            const cycleStart = current.path.indexOf(relation.child);
+                            const cyclePath = [...current.path.slice(cycleStart), relation.child];
+                            const description = cyclePath.join(' → ');
+                            // 중복 제거
+                            if (!circularReferences.some(ref => ref.description === description)) {
+                                circularReferences.push({ path: cyclePath, description });
+                            }
                         }
                     }
                     // Find parent tables (tables that the current table references)
-                    const parentQuery = `
-            SELECT 
-              TABLE_NAME as child_table,
-              COLUMN_NAME as fk_column,
-              REFERENCED_TABLE_NAME as parent_table
-            FROM information_schema.KEY_COLUMN_USAGE
-            WHERE TABLE_SCHEMA = ?
-              AND TABLE_NAME = ?
-              AND REFERENCED_TABLE_NAME IS NOT NULL
-          `;
-                    const { rows: parentRows } = await executeQuery(pool, parentQuery, [dbName, current.tableName]);
-                    for (const row of parentRows) {
+                    const parentRelations = childToParents.get(current.tableName) || [];
+                    for (const relation of parentRelations) {
                         // Only add if not already in results (avoid duplicates)
-                        const exists = results.some(r => r.child_table === row.child_table &&
-                            r.parent_table === row.parent_table &&
-                            r.fk_column === row.fk_column);
+                        const exists = results.some(r => r.child_table === relation.child &&
+                            r.parent_table === relation.parent &&
+                            r.fk_column === relation.fk_column);
                         if (!exists) {
                             results.push({
                                 depth: current.depth + 1,
-                                child_table: row.child_table,
-                                fk_column: row.fk_column,
-                                parent_table: row.parent_table,
+                                child_table: relation.child,
+                                fk_column: relation.fk_column,
+                                parent_table: relation.parent,
                                 match_type: 'fk_constraint'
                             });
                         }
-                        if (!visited.has(row.parent_table)) {
-                            visited.add(row.parent_table);
+                        if (!visited.has(relation.parent)) {
+                            visited.add(relation.parent);
                             queue.push({
-                                tableName: row.parent_table,
+                                tableName: relation.parent,
                                 depth: current.depth + 1,
-                                path: [...current.path, row.parent_table]
+                                path: [...current.path, relation.parent]
                             });
                         }
-                        else if (current.path.includes(row.parent_table)) {
+                        else if (current.path.includes(relation.parent)) {
                             // 순환 참조 감지
-                            const cycleStart = current.path.indexOf(row.parent_table);
-                            const cyclePath = [...current.path.slice(cycleStart), row.parent_table];
-                            circularReferences.push({
-                                path: cyclePath,
-                                description: `${cyclePath.join(' → ')}`
-                            });
+                            const cycleStart = current.path.indexOf(relation.parent);
+                            const cyclePath = [...current.path.slice(cycleStart), relation.parent];
+                            const description = cyclePath.join(' → ');
+                            // 중복 제거
+                            if (!circularReferences.some(ref => ref.description === description)) {
+                                circularReferences.push({ path: cyclePath, description });
+                            }
                         }
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cano721/mysql-mcp-server",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "description": "An MCP server that provides read-only access to MySQL databases.",
   "type": "module",
   "bin": {