@query-doctor/core 0.0.3

package/dist/optimizer/genalgo.d.ts

@@ -0,0 +1,82 @@
+import type { NullTestType } from "@pgsql/types";
+import type { SortContext } from "../sql/analyzer.ts";
+import { PostgresQueryBuilder } from "../sql/builder.js";
+import type { Postgres, PostgresTransaction } from "../sql/database.ts";
+import type { IndexedTable, Statistics } from "./statistics.ts";
+export type IndexIdentifier = string;
+export type IndexRecommendation = PermutedIndexCandidate & {
+    definition: IndexIdentifier;
+};
+export declare class IndexOptimizer {
+    private readonly db;
+    private readonly statistics;
+    private existingIndexes;
+    private readonly config;
+    static prefix: string;
+    constructor(db: Postgres, statistics: Statistics, existingIndexes: IndexedTable[], config?: {
+        debug?: boolean;
+    });
+    run(builder: PostgresQueryBuilder, indexes: RootIndexCandidate[]): Promise<OptimizeResult>;
+    runWithoutIndexes(builder: PostgresQueryBuilder): Promise<{
+        Plan: any;
+    }>;
+    /**
+     * Postgres has a limit of 63 characters for index names.
+     * So we use this to make sure we don't derive it from a list of columns that can
+     * overflow that limit.
+     */
+    private indexName;
+    private indexAlreadyExists;
+    private toDefinition;
+    /**
+     * Drop indexes that can be dropped (non-primary keys)
+     */
+    private dropExistingIndexes;
+    private whereClause;
+    private nullsOrder;
+    private sortDirection;
+    testQueryWithStats(builder: PostgresQueryBuilder, f?: (tx: PostgresTransaction) => Promise<void>, options?: {
+        params?: unknown[];
+        genericPlan?: boolean;
+    }): Promise<{
+        Plan: any;
+    }>;
+    private tableColumnIndexCandidates;
+    private findUsedIndexes;
+}
+export type OptimizeResult = {
+    kind: "ok";
+    baseExplainPlan: object;
+    baseCost: number;
+    finalCost: number;
+    newIndexes: Set<string>;
+    existingIndexes: Set<string>;
+    triedIndexes: Map<string, IndexRecommendation>;
+    explainPlan: object;
+} | {
+    kind: "zero_cost_plan";
+    explainPlan: object;
+};
+export type RootIndexCandidate = {
+    schema: string;
+    table: string;
+    column: string;
+    sort?: SortContext;
+    where?: {
+        nulltest?: NullTestType;
+    };
+};
+export type PermutedIndexCandidate = {
+    schema: string;
+    table: string;
+    columns: RootIndexCandidate[];
+    where?: string;
+};
+export declare const PROCEED: unique symbol;
+export declare const SKIP: unique symbol;
+/**
+ * Allows permuting over an array of items.
+ * The generator allows the caller to prematurely stop the permutation chain.
+ */
+export declare function permuteWithFeedback<T>(arr: T[]): Generator<T[], void, typeof PROCEED | typeof SKIP>;
+//# sourceMappingURL=genalgo.d.ts.map

package/dist/optimizer/genalgo.d.ts.map

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

package/dist/optimizer/statistics.d.ts

@@ -0,0 +1,373 @@
+import { z } from "zod";
+import type { Postgres, PostgresTransaction, PostgresVersion } from "../sql/database.ts";
+export type Path = string;
+export declare const StatisticsSource: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"path">;
+    path: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"inline">;
+}, z.core.$strip>]>;
+export declare const ExportedStatsStatistics: z.ZodObject<{
+    stawidth: z.ZodNumber;
+    stainherit: z.ZodDefault<z.ZodBoolean>;
+    stadistinct: z.ZodNumber;
+    stanullfrac: z.ZodNumber;
+    stakind1: z.ZodNumber;
+    stakind2: z.ZodNumber;
+    stakind3: z.ZodNumber;
+    stakind4: z.ZodNumber;
+    stakind5: z.ZodNumber;
+    staop1: z.ZodString;
+    staop2: z.ZodString;
+    staop3: z.ZodString;
+    staop4: z.ZodString;
+    staop5: z.ZodString;
+    stacoll1: z.ZodString;
+    stacoll2: z.ZodString;
+    stacoll3: z.ZodString;
+    stacoll4: z.ZodString;
+    stacoll5: z.ZodString;
+    stanumbers1: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+    stanumbers2: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+    stanumbers3: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+    stanumbers4: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+    stanumbers5: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+    stavalues1: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+    stavalues2: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+    stavalues3: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+    stavalues4: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+    stavalues5: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+}, z.core.$strip>;
+export declare const ExportedStatsColumns: z.ZodObject<{
+    columnName: z.ZodString;
+    stats: z.ZodNullable<z.ZodObject<{
+        stawidth: z.ZodNumber;
+        stainherit: z.ZodDefault<z.ZodBoolean>;
+        stadistinct: z.ZodNumber;
+        stanullfrac: z.ZodNumber;
+        stakind1: z.ZodNumber;
+        stakind2: z.ZodNumber;
+        stakind3: z.ZodNumber;
+        stakind4: z.ZodNumber;
+        stakind5: z.ZodNumber;
+        staop1: z.ZodString;
+        staop2: z.ZodString;
+        staop3: z.ZodString;
+        staop4: z.ZodString;
+        staop5: z.ZodString;
+        stacoll1: z.ZodString;
+        stacoll2: z.ZodString;
+        stacoll3: z.ZodString;
+        stacoll4: z.ZodString;
+        stacoll5: z.ZodString;
+        stanumbers1: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+        stanumbers2: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+        stanumbers3: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+        stanumbers4: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+        stanumbers5: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+        stavalues1: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+        stavalues2: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+        stavalues3: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+        stavalues4: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+        stavalues5: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+    }, z.core.$strip>>;
+    dataType: z.ZodString;
+    isNullable: z.ZodBoolean;
+    numericScale: z.ZodNullable<z.ZodNumber>;
+    columnDefault: z.ZodNullable<z.ZodString>;
+    numericPrecision: z.ZodNullable<z.ZodNumber>;
+    characterMaximumLength: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ExportedStatsIndex: z.ZodObject<{
+    indexName: z.ZodString;
+    relpages: z.ZodNumber;
+    reltuples: z.ZodNumber;
+    relallvisible: z.ZodNumber;
+    relallfrozen: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ExportedStatsV1: z.ZodObject<{
+    tableName: z.ZodString;
+    schemaName: z.ZodString;
+    relpages: z.ZodNumber;
+    reltuples: z.ZodNumber;
+    relallvisible: z.ZodNumber;
+    relallfrozen: z.ZodOptional<z.ZodNumber>;
+    columns: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        columnName: z.ZodString;
+        stats: z.ZodNullable<z.ZodObject<{
+            stawidth: z.ZodNumber;
+            stainherit: z.ZodDefault<z.ZodBoolean>;
+            stadistinct: z.ZodNumber;
+            stanullfrac: z.ZodNumber;
+            stakind1: z.ZodNumber;
+            stakind2: z.ZodNumber;
+            stakind3: z.ZodNumber;
+            stakind4: z.ZodNumber;
+            stakind5: z.ZodNumber;
+            staop1: z.ZodString;
+            staop2: z.ZodString;
+            staop3: z.ZodString;
+            staop4: z.ZodString;
+            staop5: z.ZodString;
+            stacoll1: z.ZodString;
+            stacoll2: z.ZodString;
+            stacoll3: z.ZodString;
+            stacoll4: z.ZodString;
+            stacoll5: z.ZodString;
+            stanumbers1: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+            stanumbers2: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+            stanumbers3: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+            stanumbers4: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+            stanumbers5: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+            stavalues1: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+            stavalues2: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+            stavalues3: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+            stavalues4: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+            stavalues5: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+        }, z.core.$strip>>;
+        dataType: z.ZodString;
+        isNullable: z.ZodBoolean;
+        numericScale: z.ZodNullable<z.ZodNumber>;
+        columnDefault: z.ZodNullable<z.ZodString>;
+        numericPrecision: z.ZodNullable<z.ZodNumber>;
+        characterMaximumLength: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    indexes: z.ZodArray<z.ZodObject<{
+        indexName: z.ZodString;
+        relpages: z.ZodNumber;
+        reltuples: z.ZodNumber;
+        relallvisible: z.ZodNumber;
+        relallfrozen: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ExportedStats: z.ZodUnion<readonly [z.ZodObject<{
+    tableName: z.ZodString;
+    schemaName: z.ZodString;
+    relpages: z.ZodNumber;
+    reltuples: z.ZodNumber;
+    relallvisible: z.ZodNumber;
+    relallfrozen: z.ZodOptional<z.ZodNumber>;
+    columns: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        columnName: z.ZodString;
+        stats: z.ZodNullable<z.ZodObject<{
+            stawidth: z.ZodNumber;
+            stainherit: z.ZodDefault<z.ZodBoolean>;
+            stadistinct: z.ZodNumber;
+            stanullfrac: z.ZodNumber;
+            stakind1: z.ZodNumber;
+            stakind2: z.ZodNumber;
+            stakind3: z.ZodNumber;
+            stakind4: z.ZodNumber;
+            stakind5: z.ZodNumber;
+            staop1: z.ZodString;
+            staop2: z.ZodString;
+            staop3: z.ZodString;
+            staop4: z.ZodString;
+            staop5: z.ZodString;
+            stacoll1: z.ZodString;
+            stacoll2: z.ZodString;
+            stacoll3: z.ZodString;
+            stacoll4: z.ZodString;
+            stacoll5: z.ZodString;
+            stanumbers1: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+            stanumbers2: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+            stanumbers3: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+            stanumbers4: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+            stanumbers5: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+            stavalues1: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+            stavalues2: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+            stavalues3: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+            stavalues4: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+            stavalues5: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+        }, z.core.$strip>>;
+        dataType: z.ZodString;
+        isNullable: z.ZodBoolean;
+        numericScale: z.ZodNullable<z.ZodNumber>;
+        columnDefault: z.ZodNullable<z.ZodString>;
+        numericPrecision: z.ZodNullable<z.ZodNumber>;
+        characterMaximumLength: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    indexes: z.ZodArray<z.ZodObject<{
+        indexName: z.ZodString;
+        relpages: z.ZodNumber;
+        reltuples: z.ZodNumber;
+        relallvisible: z.ZodNumber;
+        relallfrozen: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>]>;
+export type ExportedStats = z.infer<typeof ExportedStats>;
+export declare const StatisticsMode: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"fromAssumption">;
+    reltuples: z.ZodNumber;
+    relpages: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"fromStatisticsExport">;
+    stats: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        tableName: z.ZodString;
+        schemaName: z.ZodString;
+        relpages: z.ZodNumber;
+        reltuples: z.ZodNumber;
+        relallvisible: z.ZodNumber;
+        relallfrozen: z.ZodOptional<z.ZodNumber>;
+        columns: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            columnName: z.ZodString;
+            stats: z.ZodNullable<z.ZodObject<{
+                stawidth: z.ZodNumber;
+                stainherit: z.ZodDefault<z.ZodBoolean>;
+                stadistinct: z.ZodNumber;
+                stanullfrac: z.ZodNumber;
+                stakind1: z.ZodNumber;
+                stakind2: z.ZodNumber;
+                stakind3: z.ZodNumber;
+                stakind4: z.ZodNumber;
+                stakind5: z.ZodNumber;
+                staop1: z.ZodString;
+                staop2: z.ZodString;
+                staop3: z.ZodString;
+                staop4: z.ZodString;
+                staop5: z.ZodString;
+                stacoll1: z.ZodString;
+                stacoll2: z.ZodString;
+                stacoll3: z.ZodString;
+                stacoll4: z.ZodString;
+                stacoll5: z.ZodString;
+                stanumbers1: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+                stanumbers2: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+                stanumbers3: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+                stanumbers4: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+                stanumbers5: z.ZodNullable<z.ZodArray<z.ZodNumber>>;
+                stavalues1: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+                stavalues2: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+                stavalues3: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+                stavalues4: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+                stavalues5: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+            }, z.core.$strip>>;
+            dataType: z.ZodString;
+            isNullable: z.ZodBoolean;
+            numericScale: z.ZodNullable<z.ZodNumber>;
+            columnDefault: z.ZodNullable<z.ZodString>;
+            numericPrecision: z.ZodNullable<z.ZodNumber>;
+            characterMaximumLength: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        indexes: z.ZodArray<z.ZodObject<{
+            indexName: z.ZodString;
+            relpages: z.ZodNumber;
+            reltuples: z.ZodNumber;
+            relallvisible: z.ZodNumber;
+            relallfrozen: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>>;
+    source: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"path">;
+        path: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"inline">;
+    }, z.core.$strip>]>;
+}, z.core.$strip>], "kind">;
+export type StatisticsMode = z.infer<typeof StatisticsMode>;
+export declare class Statistics {
+    private readonly db;
+    readonly postgresVersion: PostgresVersion;
+    readonly ownMetadata: ExportedStats[];
+    readonly mode: StatisticsMode;
+    private readonly exportedMetadata;
+    static readonly defaultStatsMode: StatisticsMode;
+    constructor(db: Postgres, postgresVersion: PostgresVersion, ownMetadata: ExportedStats[], statsMode: StatisticsMode);
+    static statsModeFromAssumption({ reltuples, relpages, }: {
+        reltuples: number;
+        relpages: number;
+    }): StatisticsMode;
+    /**
+     * Create a statistic mode from stats exported from another database
+     **/
+    static statsModeFromExport(stats: ExportedStats[]): StatisticsMode;
+    static fromPostgres(db: Postgres, statsMode: StatisticsMode): Promise<Statistics>;
+    restoreStats(tx: PostgresTransaction): Promise<{
+        tablesNotInExports: string[];
+        tablesNotInTest: string[];
+        tableNotAnalyzed: string[];
+        statsMissing: {
+            statistic: string;
+            table: string;
+            schema: string;
+            column: string;
+        }[];
+    }>;
+    /**
+     * We have to cast stavaluesN to the correct type
+     * This derives that type for us so it can be used in `array_in`
+     */
+    private stavalueKind;
+    private restoreStats17;
+    static dumpStats(db: PostgresTransaction, postgresVersion: PostgresVersion, kind: "anonymous" | "full"): Promise<ExportedStats[]>;
+    /**
+     * Returns all indexes in the database.
+     * ONLY handles regular btree indexes
+     */
+    getExistingIndexes(): Promise<IndexedTable[]>;
+}
+export type ColumnMetadata = {
+    columnName: string;
+    dataType: string;
+    isNullable: boolean;
+    stats: ColumnStats | null;
+};
+type ColumnStats = {
+    stainherit: boolean;
+    stanullfrac: number;
+    stawidth: number;
+    stadistinct: number;
+    stakind1: number;
+    stakind2: number;
+    stakind3: number;
+    stakind4: number;
+    stakind5: number;
+    staop1: number;
+    staop2: number;
+    staop3: number;
+    staop4: number;
+    staop5: number;
+    stacoll1: number;
+    stacoll2: number;
+    stacoll3: number;
+    stacoll4: number;
+    stacoll5: number;
+    stanumbers1: number;
+    stanumbers2: number;
+    stanumbers3: number;
+    stanumbers4: number;
+    stanumbers5: number;
+};
+export type TableMetadata = {
+    tableName: string;
+    schemaName: string;
+    reltuples: number;
+    relpages: number;
+    relallvisible: number;
+    relallfrozen?: number;
+    columns: ColumnMetadata[];
+};
+type TableName = string;
+export type TableStats = {
+    tupleEstimate: bigint;
+    pageCount: number;
+};
+export type SerializeResult = {
+    schema: TableMetadata[];
+    serialized: string;
+    sampledRecords: Record<TableName, number>;
+};
+export type IndexOrder = "ASC" | "DESC";
+export type IndexedTable = {
+    index_columns: Array<{
+        name: string;
+        order: IndexOrder;
+    }>;
+    is_primary: boolean;
+    index_name: string;
+    index_type: "btree" | "gin" | (string & {});
+    schema_name: string;
+    table_name: string;
+};
+export {};
+//# sourceMappingURL=statistics.d.ts.map

package/dist/optimizer/statistics.d.ts.map

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

package/dist/sql/analyzer.d.ts

@@ -0,0 +1,97 @@
+import type { NullTestType, SortByDir, SortByNulls } from "@pgsql/types";
+import type { RootIndexCandidate } from "../optimizer/genalgo.ts";
+import type { ExportedStats } from "../optimizer/statistics.ts";
+import type { Nudge } from "./nudges.ts";
+import { ColumnReferencePart } from "./walker.js";
+export interface DatabaseDriver {
+    query(query: string, params: unknown[]): Promise<unknown[]>;
+}
+export declare const ignoredIdentifier = "__qd_placeholder";
+export interface SQLCommenterTag {
+    key: string;
+    value: string;
+}
+export type SortContext = {
+    dir: SortByDir;
+    nulls: SortByNulls;
+};
+export type DiscoveredColumnReference = {
+    /** How often the column reference appears in the query. */
+    frequency: number;
+    /**
+     * Representation of the column reference exactly
+     * as it appears in the query.
+     */
+    representation: string;
+    /**
+     * Parts of the column reference separated by dots in the query.
+     * The table reference (if it exists) is resolved if the query
+     * uses an alias.
+     *
+     * Has 3 different potential configurations (in theory)
+     * `a.b.c` - a column reference with a table and a schema reference
+     * `a.b` - a column reference with a table reference but no schema
+     * `a` - a column reference with no table reference.
+     *
+     * We use a simple array here to allow parsing of any syntactically correct
+     * but logically incorrect query. The checks happen later when we're deriving
+     * potential indexes from parts of a column reference in `deriveIndexes`
+     */
+    parts: ColumnReferencePart[];
+    /**
+     * Whether the column reference is invalid. This
+     */
+    ignored: boolean;
+    /** The position of the column reference in the query. */
+    position: {
+        start: number;
+        end: number;
+    };
+    /**
+     * A sort direction associated by the column reference.
+     * Only relevant to references from sorts
+     */
+    sort?: SortContext;
+    where?: {
+        nulltest?: NullTestType;
+    };
+};
+/** A function defined by @pgsql/parser */
+export type Parser = (query: string) => Promise<unknown>;
+export type AnalysisResult = {
+    indexesToCheck: DiscoveredColumnReference[];
+    ansiHighlightedQuery: string;
+    referencedTables: string[];
+    shadowedAliases: ColumnReferencePart[];
+    tags: SQLCommenterTag[];
+    queryWithoutTags: string;
+    formattedQueryWithoutTags?: string;
+    nudges: Nudge[];
+};
+export type SQLCommenterExtraction = {
+    tags: SQLCommenterTag[];
+    queryWithoutTags: string;
+};
+/**
+ * Analyzes a query and returns a list of column references that
+ * should be indexed.
+ *
+ * This should be instantiated once per analyzed query.
+ */
+export declare class Analyzer {
+    private readonly parser;
+    constructor(parser: Parser);
+    analyze(query: string, formattedQuery?: string): Promise<AnalysisResult>;
+    deriveIndexes(tables: ExportedStats[], discovered: DiscoveredColumnReference[]): RootIndexCandidate[];
+    private colorizeKeywords;
+    /**
+     * Resolves aliases such as `a.b` to `x.b` if `a` is a known
+     * alias to a table called x.
+     *
+     * Ignores all other combination of parts such as `a.b.c`
+     */
+    private resolveTableAliases;
+    private normalize;
+    private extractSqlcommenter;
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/sql/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../src/sql/analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EAEZ,SAAS,EACT,WAAW,EACZ,MAAM,cAAc,CAAC;AAQtB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAyB,MAAM,aAAa,CAAC;AAEzE,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CAC7D;AAED,eAAO,MAAM,iBAAiB,qBAAqB,CAAC;AAEpD,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,SAAS,CAAC;IACf,KAAK,EAAE,WAAW,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;;;;;;;;;OAaG;IACH,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,yDAAyD;IACzD,QAAQ,EAAE;QACR,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;IACF;;;OAGG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,KAAK,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,YAAY,CAAA;KAAE,CAAC;CACrC,CAAC;AAEF,0CAA0C;AAC1C,MAAM,MAAM,MAAM,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAEzD,MAAM,MAAM,cAAc,GAAG;IAC3B,cAAc,EAAE,yBAAyB,EAAE,CAAC;IAC5C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,eAAe,EAAE,mBAAmB,EAAE,CAAC;IACvC,IAAI,EAAE,eAAe,EAAE,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,eAAe,EAAE,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,QAAQ;IACP,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IACrC,OAAO,CACX,KAAK,EAAE,MAAM,EACb,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,cAAc,CAAC;IA6F1B,aAAa,CACX,MAAM,EAAE,aAAa,EAAE,EACvB,UAAU,EAAE,yBAAyB,EAAE,GACtC,kBAAkB,EAAE;IA+GvB,OAAO,CAAC,gBAAgB;IAgBxB;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAkB3B,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,mBAAmB;CAuC5B"}

package/dist/sql/analyzer_test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=analyzer_test.d.ts.map

package/dist/sql/analyzer_test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer_test.d.ts","sourceRoot":"","sources":["../../src/sql/analyzer_test.ts"],"names":[],"mappings":""}

package/dist/sql/builder.d.ts

@@ -0,0 +1,24 @@
+export type PostgresQueryBuilderCommand = "bitmapscan" | "indexscan" | "seqscan";
+export declare class PostgresQueryBuilder {
+    private query;
+    private readonly commands;
+    private isIntrospection;
+    private explainFlags;
+    private _preamble;
+    constructor(query: string);
+    get preamble(): number;
+    static createIndex(definition: string, name?: string): PostgresQueryBuilder;
+    enable(command: PostgresQueryBuilderCommand, value?: boolean): this;
+    withQuery(query: string): this;
+    introspect(): this;
+    explain(flags: string[]): this;
+    build(): string;
+    /** Return the "set a=b" parts of the command in the query separate from the explain select ... part */
+    buildParts(): {
+        commands: string;
+        query: string;
+    };
+    private generateSetCommands;
+    private generateExplain;
+}
+//# sourceMappingURL=builder.d.ts.map

package/dist/sql/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/sql/builder.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,2BAA2B,GACnC,YAAY,GACZ,WAAW,GACX,SAAS,CAAC;AAEd,qBAAa,oBAAoB;IAMnB,OAAO,CAAC,KAAK;IALzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IACvD,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,SAAS,CAAK;gBAEF,KAAK,EAAE,MAAM;IAEjC,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM;IASpD,MAAM,CAAC,OAAO,EAAE,2BAA2B,EAAE,KAAK,GAAE,OAAc,GAAG,IAAI;IAUzE,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK9B,UAAU,IAAI,IAAI;IAKlB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAK9B,KAAK,IAAI,MAAM;IASf,uGAAuG;IACvG,UAAU;;;;IAUV,OAAO,CAAC,mBAAmB;IAS3B,OAAO,CAAC,eAAe;CAWxB"}

package/dist/sql/database.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export declare const PostgresVersion: z.core.$ZodBranded<z.ZodString, "PostgresVersion">;
+export type PostgresVersion = z.infer<typeof PostgresVersion>;
+export interface PostgresTransaction {
+    /**
+     * Exec a query and return the result as an array of objects.
+     */
+    exec<T>(query: string, params?: unknown[]): Promise<T[]>;
+}
+/**
+ * A shared interface for all postgres connections.
+ * This is required to allow interop between pglite and regular postgres drivers
+ */
+export interface Postgres extends PostgresTransaction {
+    transaction<T>(callback: (tx: PostgresTransaction) => Promise<T>): Promise<T>;
+    cursor?<T>(query: string, params?: unknown[], options?: {
+        size?: number;
+    }): AsyncGenerator<T, void, unknown>;
+    serverNum(): Promise<PostgresVersion>;
+}
+export type PostgresConnectionInput = {
+    url: string;
+};
+export type PostgresFactory = (input: PostgresConnectionInput) => Postgres;
+export type PostgresExplainPlan = any;
+export type PostgresExplainResult = {
+    "QUERY PLAN": {
+        Plan: PostgresExplainPlan[];
+    }[];
+};
+//# sourceMappingURL=database.d.ts.map

package/dist/sql/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../src/sql/database.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,eAAe,oDAAsC,CAAC;AACnE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;CAC1D;AAED;;;GAGG;AACH,MAAM,WAAW,QAAS,SAAQ,mBAAmB;IACnD,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,mBAAmB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC9E,MAAM,CAAC,CAAC,CAAC,EACP,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,OAAO,EAAE,EAClB,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAC1B,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAEpC,SAAS,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;CACvC;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,uBAAuB,KAAK,QAAQ,CAAC;AAG3E,MAAM,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAEtC,MAAM,MAAM,qBAAqB,GAAG;IAClC,YAAY,EAAE;QACZ,IAAI,EAAE,mBAAmB,EAAE,CAAC;KAC7B,EAAE,CAAC;CACL,CAAC"}

package/dist/sql/nudges.d.ts

@@ -0,0 +1,15 @@
+import type { Node } from "@pgsql/types";
+type NudgeKind = "LARGE_IMPROVEMENT_FOUND" | "SMALL_IMPROVEMENT_FOUND" | "AVOID_SELECT_STAR" | "AVOID_FUNCTIONS_ON_COLUMNS_IN_WHERE" | "MISSING_WHERE_CLAUSE" | "MISSING_LIMIT_CLAUSE" | "USE_IS_NULL_NOT_EQUALS" | "AVOID_DISTINCT_WITHOUT_REASON" | "MISSING_JOIN_CONDITION" | "AVOID_LEADING_WILDCARD_LIKE" | "CONSIDER_IN_INSTEAD_OF_MANY_ORS";
+export type Nudge = {
+    kind: NudgeKind;
+    severity: "CRITICAL" | "WARNING" | "INFO";
+    message: string;
+};
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+/**
+ * Detect nudges for a single node during AST traversal.
+ * Returns an array of nudges found for this node.
+ */
+export declare function parseNudges(node: Node, stack: (KeysOfUnion<Node> | string)[]): Nudge[];
+export {};
+//# sourceMappingURL=nudges.d.ts.map

package/dist/sql/nudges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nudges.d.ts","sourceRoot":"","sources":["../../src/sql/nudges.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,KAAK,SAAS,GACV,yBAAyB,GACzB,yBAAyB,GACzB,mBAAmB,GACnB,qCAAqC,GACrC,sBAAsB,GACtB,sBAAsB,GACtB,wBAAwB,GACxB,+BAA+B,GAC/B,wBAAwB,GACxB,6BAA6B,GAC7B,iCAAiC,CAAC;AAEtC,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,SAAS,CAAC;IAChB,QAAQ,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;IAC1C,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,GAAG,KAAK,CAAC;AAiBpD;;;GAGG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,EAAE,GACpC,KAAK,EAAE,CAsKT"}

package/dist/sql/permutations_test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=permutations_test.d.ts.map

package/dist/sql/permutations_test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permutations_test.d.ts","sourceRoot":"","sources":["../../src/sql/permutations_test.ts"],"names":[],"mappings":""}