@query-doctor/core 0.3.0 → 0.4.1

package/dist/explain/rewriter.d.ts

@@ -0,0 +1,4 @@
+import type { PostgresExplainResult } from "../sql/database.js";
+import type { ExplainPlan } from "./tree.js";
+export declare function convertPostgresExplain(explainResult: PostgresExplainResult, query: string): ExplainPlan;
+//# sourceMappingURL=rewriter.d.ts.map

package/dist/explain/rewriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewriter.d.ts","sourceRoot":"","sources":["../../src/explain/rewriter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EAEtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAIV,WAAW,EAIZ,MAAM,WAAW,CAAC;AA0CnB,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,qBAAqB,EACpC,KAAK,EAAE,MAAM,GACZ,WAAW,CA8Bb"}

package/dist/explain/traverse.d.ts

@@ -0,0 +1,3 @@
+import type { PostgresExplainStage } from "../sql/database";
+export declare function traverseExplain(explain: PostgresExplainStage): Generator<PostgresExplainStage>;
+//# sourceMappingURL=traverse.d.ts.map

package/dist/explain/traverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverse.d.ts","sourceRoot":"","sources":["../../src/explain/traverse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5D,wBAAiB,eAAe,CAC9B,OAAO,EAAE,oBAAoB,GAC5B,SAAS,CAAC,oBAAoB,CAAC,CAUjC"}

package/dist/explain/tree.d.ts

@@ -0,0 +1,73 @@
+import type { PostgresExplainResult } from "../sql/database.js";
+export type ExplainNodeKind = string;
+export interface ExplainCostMetrics {
+    startupCost: number;
+    totalCost: number;
+}
+export interface ExplainRowMetrics {
+    estimatedRows: number;
+    actualRows?: number;
+}
+export interface ExplainNodeMetadata {
+    raw: Record<string, unknown>;
+}
+export type DatabaseSystem = "postgresql";
+export interface ExplainPlanMetadata {
+    databaseSystem: DatabaseSystem;
+    query: string;
+    analyzed: boolean;
+    planningTime?: number;
+    executionTime?: number;
+    raw: Record<string, unknown>;
+}
+export interface CostBreakdown {
+    reason: string;
+    cost: number;
+}
+export interface ExplainAlternativePlan {
+    kind: ExplainNodeKind;
+    indexName?: string;
+    pruneReason: string;
+    costBreakdown: CostBreakdown[];
+    totalCost: number;
+}
+export declare class ExplainNode {
+    readonly id: string;
+    readonly kind: ExplainNodeKind;
+    readonly cost: ExplainCostMetrics;
+    readonly rows: ExplainRowMetrics;
+    readonly metadata: ExplainNodeMetadata;
+    parent: ExplainNode | null;
+    private _children;
+    private _alternatives;
+    get children(): readonly ExplainNode[];
+    get alternatives(): readonly ExplainNode[];
+    constructor(params: {
+        id: string;
+        kind: ExplainNodeKind;
+        cost: ExplainCostMetrics;
+        rows: ExplainRowMetrics;
+        metadata: ExplainNodeMetadata;
+    });
+    addChild(node: ExplainNode): void;
+    addAlternative(node: ExplainNode): void;
+    root(): ExplainNode;
+    depth(): number;
+    siblings(): ExplainNode[];
+    ancestors(): ExplainNode[];
+    find(predicate: (node: ExplainNode) => boolean): ExplainNode | undefined;
+    walk(visitor: (node: ExplainNode) => void): void;
+    walkBreadth(visitor: (node: ExplainNode) => void): void;
+}
+export declare class ExplainTree {
+    root: ExplainNode;
+    metadata: ExplainPlanMetadata;
+    constructor(root: ExplainNode, metadata: ExplainPlanMetadata);
+    static fromPostgresExplain(explainResult: PostgresExplainResult, query: string): ExplainTree;
+    replaceFromPostgresExplain(explainResult: PostgresExplainResult, query: string): void;
+    find(predicate: (node: ExplainNode) => boolean): ExplainNode | undefined;
+    walk(visitor: (node: ExplainNode) => void): void;
+    walkBreadth(visitor: (node: ExplainNode) => void): void;
+    nodeCount(): number;
+}
+//# sourceMappingURL=tree.d.ts.map

package/dist/explain/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../../src/explain/tree.ts"],"names":[],"mappings":"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"}

package/dist/index.cjs

@@ -76,12 +76,25 @@ function isANode(node) {
 }
 function parseNudges(node, stack) {
   const nudges = [];
-  if (is(node, "A_Star")) {
-    nudges.push({
-      kind: "AVOID_SELECT_STAR",
-      severity: "INFO",
-      message: "Avoid using SELECT *"
-    });
+  if (is(node, "SelectStmt")) {
+    const star = node.SelectStmt.targetList?.find(
+      (target) => {
+        if (!(is(target, "ResTarget") && target.ResTarget.val && is(target.ResTarget.val, "ColumnRef"))) {
+          return false;
+        }
+        return target.ResTarget.val.ColumnRef.fields?.some(
+          (field) => is(field, "A_Star")
+        ) ?? false;
+      }
+    );
+    if (star) {
+      nudges.push({
+        kind: "AVOID_SELECT_STAR",
+        severity: "INFO",
+        message: "Avoid using SELECT *",
+        location: star.ResTarget.location
+      });
+    }
   }
   if (is(node, "FuncCall")) {
     const inWhereClause = stack.some((item) => item === "whereClause");
@@ -91,7 +104,8 @@ function parseNudges(node, stack) {
         nudges.push({
           kind: "AVOID_FUNCTIONS_ON_COLUMNS_IN_WHERE",
           severity: "WARNING",
-          message: "Avoid using functions on columns in WHERE clause"
+          message: "Avoid using functions on columns in WHERE clause",
+          location: node.FuncCall.location
         });
       }
     }
@@ -107,18 +121,24 @@ function parseNudges(node, stack) {
           return is(fromItem, "RangeVar") || is(fromItem, "JoinExpr") && hasActualTablesInJoin(fromItem);
         });
         if (hasActualTables) {
+          const firstTable = node.SelectStmt.fromClause.find(
+            (item) => is(item, "RangeVar")
+          );
+          const fromLocation = firstTable?.RangeVar.location;
           if (!node.SelectStmt.whereClause) {
             nudges.push({
               kind: "MISSING_WHERE_CLAUSE",
               severity: "INFO",
-              message: "Missing WHERE clause"
+              message: "Missing WHERE clause",
+              location: fromLocation
             });
           }
           if (!node.SelectStmt.limitCount) {
             nudges.push({
               kind: "MISSING_LIMIT_CLAUSE",
               severity: "INFO",
-              message: "Missing LIMIT clause"
+              message: "Missing LIMIT clause",
+              location: fromLocation
             });
           }
         }
@@ -134,7 +154,8 @@ function parseNudges(node, stack) {
         nudges.push({
           kind: "USE_IS_NULL_NOT_EQUALS",
           severity: "WARNING",
-          message: "Use IS NULL instead of = or != or <> for NULL comparisons"
+          message: "Use IS NULL instead of = or != or <> for NULL comparisons",
+          location: node.A_Expr.location
         });
       }
     }
@@ -142,10 +163,15 @@ function parseNudges(node, stack) {
     if (isLikeOp && node.A_Expr.rexpr) {
       const patternString = getStringConstantValue(node.A_Expr.rexpr);
       if (patternString && patternString.startsWith("%")) {
+        let stringNode;
+        if (is(node.A_Expr.rexpr, "A_Const")) {
+          stringNode = node.A_Expr.rexpr.A_Const;
+        }
         nudges.push({
           kind: "AVOID_LEADING_WILDCARD_LIKE",
           severity: "WARNING",
-          message: "Avoid using LIKE with leading wildcards"
+          message: "Avoid using LIKE with leading wildcards",
+          location: stringNode?.location
         });
       }
     }
@@ -167,14 +193,15 @@ function parseNudges(node, stack) {
     }
   }
   if (is(node, "SelectStmt") && node.SelectStmt.fromClause && node.SelectStmt.fromClause.length > 1) {
-    const tableCount = node.SelectStmt.fromClause.filter(
+    const tables = node.SelectStmt.fromClause.filter(
       (item) => is(item, "RangeVar")
-    ).length;
-    if (tableCount > 1) {
+    );
+    if (tables.length > 1) {
       nudges.push({
         kind: "MISSING_JOIN_CONDITION",
         severity: "WARNING",
-        message: "Missing JOIN condition"
+        message: "Missing JOIN condition",
+        location: tables[1].RangeVar.location
       });
     }
   }
@@ -184,7 +211,8 @@ function parseNudges(node, stack) {
       nudges.push({
         kind: "CONSIDER_IN_INSTEAD_OF_MANY_ORS",
         severity: "WARNING",
-        message: "Consider using IN instead of many ORs"
+        message: "Consider using IN instead of many ORs",
+        location: node.BoolExpr.location
       });
     }
   }
@@ -200,7 +228,8 @@ function parseNudges(node, stack) {
         nudges.push({
           kind: "REPLACE_LARGE_IN_TUPLE_WITH_ANY_ARRAY",
           message: "`in (...)` queries with large tuples can often be replaced with `= ANY($1)` using a single parameter",
-          severity: "INFO"
+          severity: "INFO",
+          location: node.A_Expr.location
         });
       }
     }
@@ -314,7 +343,7 @@ var Walker = class _Walker {
     this.seenReferences = /* @__PURE__ */ new Map();
     this.shadowedAliases = [];
     this.nudges = [];
-    _Walker.traverse(root, [], (node, stack) => {
+    _Walker.traverse(root, (node, stack) => {
       const nodeNudges = parseNudges(node, stack);
       this.nudges = [...this.nudges, ...nodeNudges];
       if (is2(node, "CommonTableExpr")) {
@@ -392,6 +421,18 @@ var Walker = class _Walker {
           }
         }
       }
+      if (is2(node, "A_Expr") && node.A_Expr.kind === "AEXPR_OP") {
+        const opName = node.A_Expr.name?.[0] && is2(node.A_Expr.name[0], "String") && node.A_Expr.name[0].String.sval;
+        if (opName && (opName === "@>" || opName === "?" || opName === "?|" || opName === "?&")) {
+          const jsonbOperator = opName;
+          if (node.A_Expr.lexpr && is2(node.A_Expr.lexpr, "ColumnRef")) {
+            this.add(node.A_Expr.lexpr, { jsonbOperator });
+          }
+          if (node.A_Expr.rexpr && is2(node.A_Expr.rexpr, "ColumnRef")) {
+            this.add(node.A_Expr.rexpr, { jsonbOperator });
+          }
+        }
+      }
       if (is2(node, "ColumnRef")) {
         for (let i = 0; i < stack.length; i++) {
           const inReturningList = stack[i] === "returningList" && stack[i + 1] === "ResTarget" && stack[i + 2] === "val" && stack[i + 3] === "ColumnRef";
@@ -490,9 +531,15 @@ var Walker = class _Walker {
     if (options?.where) {
       ref.where = options.where;
     }
+    if (options?.jsonbOperator) {
+      ref.jsonbOperator = options.jsonbOperator;
+    }
     this.highlights.push(ref);
   }
-  static traverse(node, stack, callback) {
+  static traverse(node, callback) {
+    _Walker.doTraverse(node, [], callback);
+  }
+  static doTraverse(node, stack, callback) {
     if (isANode2(node)) {
       callback(node, [...stack, getNodeKind(node)]);
     }
@@ -502,15 +549,19 @@ var Walker = class _Walker {
     if (Array.isArray(node)) {
       for (const item of node) {
         if (isANode2(item)) {
-          _Walker.traverse(item, stack, callback);
+          _Walker.doTraverse(item, stack, callback);
         }
       }
     } else if (isANode2(node)) {
       const keys = Object.keys(node);
-      _Walker.traverse(node[keys[0]], [...stack, getNodeKind(node)], callback);
+      _Walker.doTraverse(node[keys[0]], [...stack, getNodeKind(node)], callback);
     } else {
       for (const [key, child] of Object.entries(node)) {
-        _Walker.traverse(child, [...stack, key], callback);
+        _Walker.doTraverse(
+          child,
+          [...stack, key],
+          callback
+        );
       }
     }
   }
@@ -654,6 +705,9 @@ var Analyzer = class {
           if (colReference.where) {
             index.where = colReference.where;
           }
+          if (colReference.jsonbOperator) {
+            index.jsonbOperator = colReference.jsonbOperator;
+          }
           addIndex(index);
         }
       } else if (tableReference) {
@@ -675,6 +729,9 @@ var Analyzer = class {
           if (colReference.where) {
             index.where = colReference.where;
           }
+          if (colReference.jsonbOperator) {
+            index.jsonbOperator = colReference.jsonbOperator;
+          }
           addIndex(index);
         }
       } else if (fullReference) {
@@ -693,6 +750,9 @@ var Analyzer = class {
         if (colReference.where) {
           index.where = colReference.where;
         }
+        if (colReference.jsonbOperator) {
+          index.jsonbOperator = colReference.jsonbOperator;
+        }
         addIndex(index);
       } else {
         console.error(
@@ -815,7 +875,7 @@ async function dropIndex(tx, index) {
 
 // src/sql/indexes.ts
 function isIndexSupported(index) {
-  return index.index_type === "btree";
+  return index.index_type === "btree" || index.index_type === "gin";
 }
 function isIndexProbablyDroppable(index) {
   return !index.is_primary && !index.is_unique;
@@ -1297,8 +1357,10 @@ var _IndexOptimizer = class _IndexOptimizer {
    * Derive the list of indexes [tableA(X, Y, Z), tableB(H, I, J)]
    **/
   indexesToCreate(rootCandidates) {
-    const permutedIndexes = this.groupPotentialIndexColumnsByTable(rootCandidates);
+    const btreeCandidates = rootCandidates.filter((c) => !c.jsonbOperator);
+    const ginCandidates = rootCandidates.filter((c) => c.jsonbOperator);
     const nextStage = [];
+    const permutedIndexes = this.groupPotentialIndexColumnsByTable(btreeCandidates);
     for (const permutation of permutedIndexes.values()) {
       const { table: rawTable, schema: rawSchema, columns } = permutation;
       const permutations = permutationsWithDescendingLength(columns);
@@ -1323,6 +1385,41 @@ var _IndexOptimizer = class _IndexOptimizer {
         });
       }
     }
+    const ginGroups = this.groupGinCandidatesByColumn(ginCandidates);
+    for (const group of ginGroups.values()) {
+      const { schema: rawSchema, table: rawTable, column, operators } = group;
+      const schema = PgIdentifier.fromString(rawSchema);
+      const table = PgIdentifier.fromString(rawTable);
+      const needsKeyExistence = operators.some(
+        (op) => op === "?" || op === "?|" || op === "?&"
+      );
+      const opclass = needsKeyExistence ? void 0 : "jsonb_path_ops";
+      const existingGin = this.ginIndexAlreadyExists(table.toString(), column);
+      if (existingGin) {
+        continue;
+      }
+      const indexName = this.indexName();
+      const candidate = {
+        schema: rawSchema,
+        table: rawTable,
+        column
+      };
+      const definition = this.toGinDefinition({
+        table,
+        schema,
+        column: PgIdentifier.fromString(column),
+        opclass
+      });
+      nextStage.push({
+        name: indexName,
+        schema: schema.toString(),
+        table: table.toString(),
+        columns: [candidate],
+        definition,
+        indexMethod: "gin",
+        opclass
+      });
+    }
     return nextStage;
   }
   toDefinition({
@@ -1357,6 +1454,47 @@ var _IndexOptimizer = class _IndexOptimizer {
     const colored = make(import_colorette2.green, import_colorette2.yellow, import_colorette2.magenta, import_colorette2.blue);
     return { raw, colored };
   }
+  toGinDefinition({
+    schema,
+    table,
+    column,
+    opclass
+  }) {
+    let fullyQualifiedTable;
+    if (schema.toString() === "public") {
+      fullyQualifiedTable = table;
+    } else {
+      fullyQualifiedTable = PgIdentifier.fromParts(schema, table);
+    }
+    const opclassSuffix = opclass ? ` ${opclass}` : "";
+    return `${fullyQualifiedTable} using gin (${column}${opclassSuffix})`;
+  }
+  groupGinCandidatesByColumn(candidates) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const c of candidates) {
+      if (!c.jsonbOperator) continue;
+      const key = `${c.schema}.${c.table}.${c.column}`;
+      const existing = groups.get(key);
+      if (existing) {
+        if (!existing.operators.includes(c.jsonbOperator)) {
+          existing.operators.push(c.jsonbOperator);
+        }
+      } else {
+        groups.set(key, {
+          schema: c.schema,
+          table: c.table,
+          column: c.column,
+          operators: [c.jsonbOperator]
+        });
+      }
+    }
+    return groups;
+  }
+  ginIndexAlreadyExists(table, column) {
+    return this.existingIndexes.find(
+      (index) => index.index_type === "gin" && index.table_name === table && index.index_columns.some((c) => c.name === column)
+    );
+  }
   /**
    * Drop indexes that can be dropped. Ignore the ones that can't
    */
@@ -1673,6 +1811,21 @@ var _Statistics = class _Statistics {
     }
     return "text";
   }
+  /**
+   * PostgreSQL's anyarray columns in pg_statistic can hold arrays of arrays
+   * for columns with array types (e.g. text[], int4[]). These create
+   * multidimensional arrays that can be "ragged" (sub-arrays with different
+   * lengths). jsonb_to_recordset can't reconstruct ragged multidimensional
+   * arrays from JSON, so we need to drop these values.
+   */
+  static safeStavalues(values) {
+    if (!values || values.length === 0) return values;
+    if (values.some((v) => Array.isArray(v))) {
+      console.warn("Discarding ragged multidimensional stavalues array");
+      return null;
+    }
+    return values;
+  }
   async restoreStats17(tx) {
     const warnings = {
       tablesNotInExports: [],
@@ -1724,16 +1877,26 @@ var _Statistics = class _Statistics {
             stanumbers3: stats.stanumbers3,
             stanumbers4: stats.stanumbers4,
             stanumbers5: stats.stanumbers5,
-            stavalues1: stats.stavalues1,
-            stavalues2: stats.stavalues2,
-            stavalues3: stats.stavalues3,
-            stavalues4: stats.stavalues4,
-            stavalues5: stats.stavalues5,
-            _value_type1: this.stavalueKind(stats.stavalues1),
-            _value_type2: this.stavalueKind(stats.stavalues2),
-            _value_type3: this.stavalueKind(stats.stavalues3),
-            _value_type4: this.stavalueKind(stats.stavalues4),
-            _value_type5: this.stavalueKind(stats.stavalues5)
+            stavalues1: _Statistics.safeStavalues(stats.stavalues1),
+            stavalues2: _Statistics.safeStavalues(stats.stavalues2),
+            stavalues3: _Statistics.safeStavalues(stats.stavalues3),
+            stavalues4: _Statistics.safeStavalues(stats.stavalues4),
+            stavalues5: _Statistics.safeStavalues(stats.stavalues5),
+            _value_type1: this.stavalueKind(
+              _Statistics.safeStavalues(stats.stavalues1)
+            ),
+            _value_type2: this.stavalueKind(
+              _Statistics.safeStavalues(stats.stavalues2)
+            ),
+            _value_type3: this.stavalueKind(
+              _Statistics.safeStavalues(stats.stavalues3)
+            ),
+            _value_type4: this.stavalueKind(
+              _Statistics.safeStavalues(stats.stavalues4)
+            ),
+            _value_type5: this.stavalueKind(
+              _Statistics.safeStavalues(stats.stavalues5)
+            )
           });
         }
       }
@@ -2149,14 +2312,16 @@ var _Statistics = class _Statistics {
                       CASE
                           WHEN (indoption[array_position(ix.indkey, a.attnum)] & 1) = 1 THEN 'DESC'
                           ELSE 'ASC'
-                      END)
+                      END,
+                      'opclass', CASE WHEN opc.opcdefault THEN NULL ELSE opc.opcname END)
                   -- Handle expressions
                   ELSE
                       json_build_object('name', pg_get_expr((ix.indexprs)::pg_node_tree, t.oid), 'order',
                       CASE
                           WHEN (indoption[array_position(ix.indkey, k.attnum)] & 1) = 1 THEN 'DESC'
                           ELSE 'ASC'
-                      END)
+                      END,
+                      'opclass', CASE WHEN opc.opcdefault THEN NULL ELSE opc.opcname END)
               END
               ORDER BY array_position(ix.indkey, k.attnum)
           ) AS index_columns
@@ -2168,6 +2333,7 @@ var _Statistics = class _Statistics {
           JOIN pg_am am ON i.relam = am.oid
           LEFT JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY k(attnum, ordinality) ON true
           LEFT JOIN pg_attribute a ON a.attnum = k.attnum AND a.attrelid = t.oid
+          LEFT JOIN pg_opclass opc ON opc.oid = ix.indclass[k.ordinality - 1]
           JOIN pg_namespace n ON t.relnamespace = n.oid
       WHERE
           n.nspname not like 'pg_%' and