Fix DDL bugs in schema, enums, indexes, and triggers tools

src/tools/enums.ts

@@ -84,17 +84,34 @@ async function executeCreateEnum(
   const db = DatabaseConnection.getInstance();
   try {
     await db.connect(resolvedConnectionString);
-    // Manually quote identifiers using double quotes
-    const qualifiedSchema = `"${schema || 'public'}"`;
+    const schemaName = schema || 'public';
+    const qualifiedSchema = `"${schemaName}"`;
     const qualifiedEnumName = `"${enumName}"`;
     const fullEnumName = `${qualifiedSchema}.${qualifiedEnumName}`;
-    // Use parameterized query for values and add explicit types to map
-    const valuesPlaceholders = values.map((_: string, i: number) => `$${i + 1}`).join(', ');
-    const ifNotExistsClause = ifNotExists ? 'IF NOT EXISTS' : '';
-
-    const query = `CREATE TYPE ${ifNotExistsClause} ${fullEnumName} AS ENUM (${valuesPlaceholders});`;
-
-    await db.query(query, values);
+    // PostgreSQL doesn't accept parameter placeholders ($1) inside DDL like CREATE TYPE.
+    // Embed values as escaped string literals instead.
+    const literalValues = values.map(v => `'${v.replace(/'/g, "''")}'`).join(', ');
+    const createSql = `CREATE TYPE ${fullEnumName} AS ENUM (${literalValues})`;
+
+    if (ifNotExists) {
+      // PostgreSQL has no native CREATE TYPE IF NOT EXISTS; emulate via DO block.
+      const schemaLit = `'${schemaName.replace(/'/g, "''")}'`;
+      const enumLit = `'${enumName.replace(/'/g, "''")}'`;
+      const guardedSql = `DO $do$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM pg_type t
+    JOIN pg_namespace n ON n.oid = t.typnamespace
+    WHERE n.nspname = ${schemaLit} AND t.typname = ${enumLit} AND t.typtype = 'e'
+  ) THEN
+    EXECUTE $sql$${createSql}$sql$;
+  END IF;
+END
+$do$;`;
+      await db.query(guardedSql);
+    } else {
+      await db.query(createSql);
+    }
     return { schema, enumName, values };
   } catch (error) {
     console.error("Error creating ENUM:", error);

src/tools/indexes.ts

@@ -49,26 +49,27 @@ async function executeGetIndexes(
     await db.connect(resolvedConnectionString);
 
     if (includeStats) {
+      // pg_stat_user_indexes exposes table/index names as relname/indexrelname (not tablename/indexname).
       const statsQuery = `
-        SELECT 
-          schemaname,
-          tablename,
-          indexname,
-          idx_scan as scans,
-          idx_tup_read as tuples_read,
-          idx_tup_fetch as tuples_fetched,
-          pg_relation_size(indexrelname::regclass) as size_bytes,
-          pg_size_pretty(pg_relation_size(indexrelname::regclass)) as size_pretty,
-          indisunique as is_unique,
-          indisprimary as is_primary,
-          CASE 
-            WHEN idx_scan = 0 THEN 0
-            ELSE round((idx_tup_fetch::numeric / idx_tup_read::numeric) * 100, 2)
-          END as usage_ratio
+        SELECT
+          psi.schemaname,
+          psi.relname AS tablename,
+          psi.indexrelname AS indexname,
+          psi.idx_scan AS scans,
+          psi.idx_tup_read AS tuples_read,
+          psi.idx_tup_fetch AS tuples_fetched,
+          pg_relation_size(psi.indexrelid) AS size_bytes,
+          pg_size_pretty(pg_relation_size(psi.indexrelid)) AS size_pretty,
+          pi.indisunique AS is_unique,
+          pi.indisprimary AS is_primary,
+          CASE
+            WHEN psi.idx_scan = 0 THEN 0
+            ELSE round((psi.idx_tup_fetch::numeric / NULLIF(psi.idx_tup_read::numeric, 0)) * 100, 2)
+          END AS usage_ratio
         FROM pg_stat_user_indexes psi
         JOIN pg_index pi ON psi.indexrelid = pi.indexrelid
-        WHERE schemaname = $1 
-          ${tableName ? 'AND tablename = $2' : ''}
+        WHERE psi.schemaname = $1
+          ${tableName ? 'AND psi.relname = $2' : ''}
         ORDER BY size_bytes DESC, scans DESC
       `;
 
@@ -359,28 +360,29 @@ async function executeAnalyzeIndexUsage(
     await db.connect(resolvedConnectionString);
 
     // Get all index usage stats
+    // pg_stat_user_indexes exposes table/index names as relname/indexrelname (not tablename/indexname).
     const usageQuery = `
-      SELECT 
-        schemaname,
-        tablename,
-        indexname,
-        idx_scan as scans,
-        idx_tup_read as tuples_read,
-        idx_tup_fetch as tuples_fetched,
-        pg_relation_size(indexrelname::regclass) as size_bytes,
-        pg_size_pretty(pg_relation_size(indexrelname::regclass)) as size_pretty,
-        indisunique as is_unique,
-        indisprimary as is_primary,
-        CASE 
-          WHEN idx_scan = 0 THEN 0
-          ELSE round((idx_tup_fetch::numeric / NULLIF(idx_tup_read::numeric, 0)) * 100, 2)
-        END as usage_ratio
+      SELECT
+        psi.schemaname,
+        psi.relname AS tablename,
+        psi.indexrelname AS indexname,
+        psi.idx_scan AS scans,
+        psi.idx_tup_read AS tuples_read,
+        psi.idx_tup_fetch AS tuples_fetched,
+        pg_relation_size(psi.indexrelid) AS size_bytes,
+        pg_size_pretty(pg_relation_size(psi.indexrelid)) AS size_pretty,
+        pi.indisunique AS is_unique,
+        pi.indisprimary AS is_primary,
+        CASE
+          WHEN psi.idx_scan = 0 THEN 0
+          ELSE round((psi.idx_tup_fetch::numeric / NULLIF(psi.idx_tup_read::numeric, 0)) * 100, 2)
+        END AS usage_ratio
       FROM pg_stat_user_indexes psi
       JOIN pg_index pi ON psi.indexrelid = pi.indexrelid
-      WHERE schemaname = $1 
-        ${tableName ? 'AND tablename = $2' : ''}
-        AND pg_relation_size(indexrelname::regclass) >= $${tableName ? '3' : '2'}
-        AND NOT indisprimary  -- Exclude primary key indexes from analysis
+      WHERE psi.schemaname = $1
+        ${tableName ? 'AND psi.relname = $2' : ''}
+        AND pg_relation_size(psi.indexrelid) >= $${tableName ? '3' : '2'}
+        AND NOT pi.indisprimary
       ORDER BY size_bytes DESC
     `;
 
@@ -395,18 +397,18 @@ async function executeAnalyzeIndexUsage(
     if (showDuplicates) {
       // Find potentially duplicate indexes by comparing column definitions
       const duplicateQuery = `
-        SELECT 
-          schemaname,
-          tablename,
-          array_agg(indexname) as index_names,
-          string_agg(pg_get_indexdef(indexrelid), ' | ') as definitions,
-          count(*) as index_count
+        SELECT
+          psi.schemaname,
+          psi.relname AS tablename,
+          array_agg(psi.indexrelname) AS index_names,
+          string_agg(pg_get_indexdef(psi.indexrelid), ' | ') AS definitions,
+          count(*) AS index_count
         FROM pg_stat_user_indexes psi
         JOIN pg_index pi ON psi.indexrelid = pi.indexrelid
-        WHERE schemaname = $1 
-          ${tableName ? 'AND tablename = $2' : ''}
-          AND NOT indisprimary
-        GROUP BY schemaname, tablename, indkey
+        WHERE psi.schemaname = $1
+          ${tableName ? 'AND psi.relname = $2' : ''}
+          AND NOT pi.indisprimary
+        GROUP BY psi.schemaname, psi.relname, pi.indkey
         HAVING count(*) > 1
       `;