@query-doctor/core 0.8.1 → 0.8.2

package/dist/optimizer/statistics.mjs

@@ -0,0 +1,729 @@
+"use client";
+import { _defineProperty } from "../_virtual/_@oxc-project_runtime@0.122.0/helpers/defineProperty.mjs";
+import { gray } from "colorette";
+import { z } from "zod";
+import dedent from "dedent";
+//#region src/optimizer/statistics.ts
+const StatisticsSource = z.union([z.object({
+	kind: z.literal("path"),
+	path: z.string().min(1)
+}), z.object({ kind: z.literal("inline") })]);
+const ExportedStatsStatistics = z.object({
+	stawidth: z.number(),
+	stainherit: z.boolean().default(false),
+	stadistinct: z.number(),
+	stanullfrac: z.number(),
+	stakind1: z.number().min(0),
+	stakind2: z.number().min(0),
+	stakind3: z.number().min(0),
+	stakind4: z.number().min(0),
+	stakind5: z.number().min(0),
+	staop1: z.string(),
+	staop2: z.string(),
+	staop3: z.string(),
+	staop4: z.string(),
+	staop5: z.string(),
+	stacoll1: z.string(),
+	stacoll2: z.string(),
+	stacoll3: z.string(),
+	stacoll4: z.string(),
+	stacoll5: z.string(),
+	stanumbers1: z.array(z.number()).nullable(),
+	stanumbers2: z.array(z.number()).nullable(),
+	stanumbers3: z.array(z.number()).nullable(),
+	stanumbers4: z.array(z.number()).nullable(),
+	stanumbers5: z.array(z.number()).nullable(),
+	stavalues1: z.array(z.any()).nullable(),
+	stavalues2: z.array(z.any()).nullable(),
+	stavalues3: z.array(z.any()).nullable(),
+	stavalues4: z.array(z.any()).nullable(),
+	stavalues5: z.array(z.any()).nullable()
+});
+const ExportedStatsColumns = z.object({
+	columnName: z.string(),
+	attlen: z.number().nullable(),
+	stats: ExportedStatsStatistics.nullable()
+});
+const ExportedStatsIndex = z.object({
+	indexName: z.string(),
+	amname: z.string().default("btree"),
+	relpages: z.number(),
+	reltuples: z.number(),
+	relallvisible: z.number(),
+	relallfrozen: z.number().optional(),
+	fillfactor: z.number().default(90),
+	columns: z.array(z.object({ attlen: z.number().nullable() })).default([])
+});
+const ExportedStatsV1 = z.object({
+	tableName: z.string(),
+	schemaName: z.string(),
+	relpages: z.number(),
+	reltuples: z.number(),
+	relallvisible: z.number(),
+	relallfrozen: z.number().optional(),
+	columns: z.array(ExportedStatsColumns).default([]),
+	indexes: z.array(ExportedStatsIndex)
+});
+const ExportedStats = z.union([ExportedStatsV1]);
+const StatisticsMode = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("fromAssumption"),
+	reltuples: z.number().min(0)
+}), z.object({
+	kind: z.literal("fromStatisticsExport"),
+	stats: z.array(ExportedStats),
+	source: StatisticsSource
+})]);
+const DEFAULT_RELTUPLES = 1e4;
+const DEFAULT_RELPAGES = 1;
+const DEFAULT_PAGE_SIZE = 2 ** 13;
+function estimateStawidth(col) {
+	return col.attlen ?? 32;
+}
+function estimateRelpages(reltuples, columns) {
+	const rowWidth = columns.reduce((sum, col) => sum + estimateStawidth(col), 0) + 27;
+	return Math.ceil(reltuples * rowWidth / DEFAULT_PAGE_SIZE);
+}
+function estimateIndexRelpages(reltuples, columns, fillfactor, amname, tableRelpages) {
+	if (amname === "gin") return Math.ceil(tableRelpages * .3);
+	const keyWidth = columns.reduce((sum, col) => sum + estimateStawidth(col) + 16, 0);
+	return Math.ceil(reltuples * keyWidth / DEFAULT_PAGE_SIZE / fillfactor);
+}
+var Statistics = class Statistics {
+	constructor(db, postgresVersion, ownMetadata, statsMode) {
+		this.db = db;
+		this.postgresVersion = postgresVersion;
+		this.ownMetadata = ownMetadata;
+		_defineProperty(this, "mode", void 0);
+		_defineProperty(this, "exportedMetadata", void 0);
+		if (statsMode) {
+			this.mode = statsMode;
+			if (statsMode.kind === "fromStatisticsExport") this.exportedMetadata = statsMode.stats;
+		} else this.mode = Statistics.defaultStatsMode;
+	}
+	static statsModeFromAssumption({ reltuples }) {
+		return {
+			kind: "fromAssumption",
+			reltuples
+		};
+	}
+	/**
+	* Create a statistic mode from stats exported from another database
+	**/
+	static statsModeFromExport(stats) {
+		return {
+			kind: "fromStatisticsExport",
+			source: { kind: "inline" },
+			stats
+		};
+	}
+	static async fromPostgres(db, statsMode) {
+		const version = await db.serverNum();
+		return new Statistics(db, version, await Statistics.dumpStats(db, version, "full"), statsMode);
+	}
+	restoreStats(tx) {
+		return this.restoreStats17(tx);
+	}
+	approximateTotalRows() {
+		if (!this.exportedMetadata) return 0;
+		let totalRows = 0;
+		for (const table of this.exportedMetadata) totalRows += table.reltuples;
+		return totalRows;
+	}
+	/**
+	* We have to cast stavaluesN to the correct type
+	* This derives that type for us so it can be used in `array_in`
+	*/
+	stavalueKind(values) {
+		if (!values || values.length === 0) return null;
+		const [elem] = values;
+		if (typeof elem === "number") return "real";
+		else if (typeof elem === "boolean") return "boolean";
+		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: [],
+			tablesNotInTest: [],
+			tableNotAnalyzed: [],
+			statsMissing: []
+		};
+		const processedTables = /* @__PURE__ */ new Set();
+		let columnStatsUpdatePromise;
+		const columnStatsValues = [];
+		for (const table of this.ownMetadata) {
+			const target = (this.exportedMetadata?.find((m) => m.tableName === table.tableName && m.schemaName === table.schemaName))?.columns ?? table.columns;
+			for (const column of target) {
+				const { stats } = column;
+				if (!stats || this.mode.kind === "fromAssumption") {
+					const stawidth = stats?.stawidth || estimateStawidth(column);
+					columnStatsValues.push({
+						schema_name: table.schemaName,
+						table_name: table.tableName,
+						column_name: column.columnName,
+						stainherit: false,
+						stanullfrac: .04,
+						stawidth,
+						stadistinct: -.9,
+						stakind1: 0,
+						stakind2: 0,
+						stakind3: 3,
+						stakind4: 0,
+						stakind5: 0,
+						stacoll1: "0",
+						stacoll2: "0",
+						stacoll3: "0",
+						stacoll4: "0",
+						stacoll5: "0",
+						staop1: "0",
+						staop2: "0",
+						staop3: "0",
+						staop4: "0",
+						staop5: "0",
+						stanumbers1: null,
+						stanumbers2: null,
+						stanumbers3: [.9],
+						stanumbers4: null,
+						stanumbers5: null,
+						stavalues1: null,
+						stavalues2: null,
+						stavalues3: null,
+						stavalues4: null,
+						stavalues5: null,
+						_value_type1: "real",
+						_value_type2: "real",
+						_value_type3: "real",
+						_value_type4: "real",
+						_value_type5: "real"
+					});
+					continue;
+				}
+				columnStatsValues.push({
+					schema_name: table.schemaName,
+					table_name: table.tableName,
+					column_name: column.columnName,
+					stainherit: stats.stainherit ?? false,
+					stanullfrac: stats.stanullfrac,
+					stawidth: stats.stawidth,
+					stadistinct: stats.stadistinct,
+					stakind1: stats.stakind1,
+					stakind2: stats.stakind2,
+					stakind3: stats.stakind3,
+					stakind4: stats.stakind4,
+					stakind5: stats.stakind5,
+					staop1: stats.staop1,
+					staop2: stats.staop2,
+					staop3: stats.staop3,
+					staop4: stats.staop4,
+					staop5: stats.staop5,
+					stacoll1: stats.stacoll1,
+					stacoll2: stats.stacoll2,
+					stacoll3: stats.stacoll3,
+					stacoll4: stats.stacoll4,
+					stacoll5: stats.stacoll5,
+					stanumbers1: stats.stanumbers1,
+					stanumbers2: stats.stanumbers2,
+					stanumbers3: stats.stanumbers3,
+					stanumbers4: stats.stanumbers4,
+					stanumbers5: stats.stanumbers5,
+					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))
+				});
+			}
+		}
+		/**
+		* Postgres has 5 different slots for storing statistics per column and a potentially unlimited
+		* number of statistic types to choose from. Each code in `stakindN` can mean different things.
+		* Some statistics are just numerical values such as `n_distinct` and `correlation`, meaning
+		* they're only derived from `stanumbersN` and the value of `stanumbersN` is never read.
+		* Others take advantage of the `stavaluesN` columns which use `anyarray` type to store
+		* concrete values internally for things like histogram bounds.
+		* Unfortunately we cannot change anyarrays without a C extension.
+		*
+		* (1) = most common values
+		* (2) = scalar histogram
+		* (3) = correlation <- can change
+		* (4) = most common elements
+		* (5) = distinct elem count histogram <- can change
+		* (6) = length histogram (?) These don't appear in pg_stats
+		* (7) = bounds histogram (?) These don't appear in pg_stats
+		* (N) = potentially many more kinds of statistics. But postgres <=18 only uses these 7.
+		*
+		* What we're doing here is setting ANY statistic we cannot directly control
+		* (anything that relies on stavaluesN) to 0 to make sure the planner isn't influenced by what
+		* what the db collected from the test data.
+		* Because we do our tests with `generic_plan` it seems it's already unlikely that the planner will be
+		* using things like common values or histogram bounds to make the planning decisions we care about.
+		* This is a just in case.
+		*/
+		const sql = dedent`
+    WITH input AS (
+      SELECT
+        c.oid AS starelid,
+        a.attnum AS staattnum,
+        v.stainherit,
+        v.stanullfrac,
+        v.stawidth,
+        v.stadistinct,
+        v.stakind1,
+        v.stakind2,
+        v.stakind3,
+        v.stakind4,
+        v.stakind5,
+        v.staop1,
+        v.staop2,
+        v.staop3,
+        v.staop4,
+        v.staop5,
+        v.stacoll1,
+        v.stacoll2,
+        v.stacoll3,
+        v.stacoll4,
+        v.stacoll5,
+        v.stanumbers1,
+        v.stanumbers2,
+        v.stanumbers3,
+        v.stanumbers4,
+        v.stanumbers5,
+        v.stavalues1,
+        v.stavalues2,
+        v.stavalues3,
+        v.stavalues4,
+        v.stavalues5,
+        _value_type1,
+        _value_type2,
+        _value_type3,
+        _value_type4,
+        _value_type5
+      FROM jsonb_to_recordset($1::jsonb) AS v(
+        schema_name text,
+        table_name text,
+        column_name text,
+        stainherit boolean,
+        stanullfrac real,
+        stawidth integer,
+        stadistinct real,
+        stakind1 real,
+        stakind2 real,
+        stakind3 real,
+        stakind4 real,
+        stakind5 real,
+        staop1 oid,
+        staop2 oid,
+        staop3 oid,
+        staop4 oid,
+        staop5 oid,
+        stacoll1 oid,
+        stacoll2 oid,
+        stacoll3 oid,
+        stacoll4 oid,
+        stacoll5 oid,
+        stanumbers1 real[],
+        stanumbers2 real[],
+        stanumbers3 real[],
+        stanumbers4 real[],
+        stanumbers5 real[],
+        stavalues1 text[],
+        stavalues2 text[],
+        stavalues3 text[],
+        stavalues4 text[],
+        stavalues5 text[],
+        _value_type1 text,
+        _value_type2 text,
+        _value_type3 text,
+        _value_type4 text,
+        _value_type5 text
+      )
+      JOIN pg_class c ON c.relname = v.table_name
+      JOIN pg_namespace n ON n.oid = c.relnamespace AND n.nspname = v.schema_name
+      JOIN pg_attribute a ON a.attrelid = c.oid AND a.attname = v.column_name
+    ),
+    updated AS (
+      UPDATE pg_statistic s
+      SET
+        stanullfrac = i.stanullfrac,
+        stawidth = i.stawidth,
+        stadistinct = i.stadistinct,
+        stakind1 = i.stakind1,
+        stakind2 = i.stakind2,
+        stakind3 = i.stakind3,
+        stakind4 = i.stakind4,
+        stakind5 = i.stakind5,
+        staop1 = i.staop1,
+        staop2 = i.staop2,
+        staop3 = i.staop3,
+        staop4 = i.staop4,
+        staop5 = i.staop5,
+        stacoll1 = i.stacoll1,
+        stacoll2 = i.stacoll2,
+        stacoll3 = i.stacoll3,
+        stacoll4 = i.stacoll4,
+        stacoll5 = i.stacoll5,
+        stanumbers1 = i.stanumbers1,
+        stanumbers2 = i.stanumbers2,
+        stanumbers3 = i.stanumbers3,
+        stanumbers4 = i.stanumbers4,
+        stanumbers5 = i.stanumbers5,
+        stavalues1 = case
+          when i.stavalues1 is null then null
+          else array_in(i.stavalues1::text::cstring, i._value_type1::regtype::oid, -1)
+        end,
+        stavalues2 = case
+          when i.stavalues2 is null then null
+          else array_in(i.stavalues2::text::cstring, i._value_type2::regtype::oid, -1)
+        end,
+        stavalues3 = case
+          when i.stavalues3 is null then null
+          else array_in(i.stavalues3::text::cstring, i._value_type3::regtype::oid, -1)
+        end,
+        stavalues4 = case
+          when i.stavalues4 is null then null
+          else array_in(i.stavalues4::text::cstring, i._value_type4::regtype::oid, -1)
+        end,
+        stavalues5 = case
+          when i.stavalues5 is null then null
+          else array_in(i.stavalues5::text::cstring, i._value_type5::regtype::oid, -1)
+        end
+        -- stavalues1 = i.stavalues1,
+        -- stavalues2 = i.stavalues2,
+        -- stavalues3 = i.stavalues3,
+        -- stavalues4 = i.stavalues4,
+        -- stavalues5 = i.stavalues5
+      FROM input i
+      WHERE s.starelid = i.starelid AND s.staattnum = i.staattnum AND s.stainherit = i.stainherit
+      RETURNING s.starelid, s.staattnum, s.stainherit, s.stakind1, s.stakind2, s.stakind3, s.stakind4, s.stakind5
+    ),
+    inserted as (
+      INSERT INTO pg_statistic (
+        starelid, staattnum, stainherit,
+        stanullfrac, stawidth, stadistinct,
+        stakind1, stakind2, stakind3, stakind4, stakind5,
+        staop1, staop2, staop3, staop4, staop5,
+        stacoll1, stacoll2, stacoll3, stacoll4, stacoll5,
+        stanumbers1, stanumbers2, stanumbers3, stanumbers4, stanumbers5,
+        stavalues1, stavalues2, stavalues3, stavalues4, stavalues5
+      )
+      SELECT
+      i.starelid, i.staattnum, i.stainherit,
+      i.stanullfrac, i.stawidth, i.stadistinct,
+      i.stakind1, i.stakind2, i.stakind3, i.stakind4, i.stakind5,
+      i.staop1, i.staop2, i.staop3, i.staop4, i.staop5,
+      i.stacoll1, i.stacoll2, i.stacoll3, i.stacoll4, i.stacoll5,
+      i.stanumbers1, i.stanumbers2, i.stanumbers3, i.stanumbers4, i.stanumbers5,
+      -- i.stavalues1, i.stavalues2, i.stavalues3, i.stavalues4, i.stavalues5,
+      case
+        when i.stavalues1 is null then null
+        else array_in(i.stavalues1::text::cstring, i._value_type1::regtype::oid, -1)
+      end,
+      case
+        when i.stavalues2 is null then null
+        else array_in(i.stavalues2::text::cstring, i._value_type2::regtype::oid, -1)
+      end,
+      case
+        when i.stavalues3 is null then null
+        else array_in(i.stavalues3::text::cstring, i._value_type3::regtype::oid, -1)
+      end,
+      case
+        when i.stavalues4 is null then null
+        else array_in(i.stavalues4::text::cstring, i._value_type4::regtype::oid, -1)
+      end,
+      case
+        when i.stavalues5 is null then null
+        else array_in(i.stavalues5::text::cstring, i._value_type5::regtype::oid, -1)
+      end
+      -- i._value_type1, i._value_type2, i._value_type3, i._value_type4, i._value_type5
+      FROM input i
+      LEFT JOIN updated u
+        ON i.starelid = u.starelid AND i.staattnum = u.staattnum AND i.stainherit = u.stainherit
+      WHERE u.starelid IS NULL
+      returning starelid, staattnum, stainherit, stakind1, stakind2, stakind3, stakind4, stakind5
+    )
+    select * from updated union all (select * from inserted); -- @qd_introspection`;
+		columnStatsUpdatePromise = tx.exec(sql, [columnStatsValues]).catch((err) => {
+			console.error("Something wrong wrong updating column stats");
+			console.error(err);
+			throw err;
+		});
+		const reltuplesValues = [];
+		for (const table of this.ownMetadata) {
+			processedTables.add(`${table.schemaName}.${table.tableName}`);
+			let targetTable;
+			if (this.exportedMetadata) targetTable = this.exportedMetadata.find((m) => m.tableName === table.tableName && m.schemaName === table.schemaName);
+			else targetTable = table;
+			let reltuples;
+			let relpages;
+			let relallvisible = 0;
+			let relallfrozen;
+			if (this.mode.kind === "fromAssumption") {
+				reltuples = this.mode.reltuples;
+				relpages = estimateRelpages(reltuples, table.columns);
+			} else if (targetTable) {
+				reltuples = targetTable.reltuples;
+				relpages = targetTable.relpages;
+				relallvisible = targetTable.relallvisible;
+				relallfrozen = targetTable.relallfrozen;
+			} else {
+				warnings.tablesNotInExports.push(`${table.schemaName}.${table.tableName}`);
+				reltuples = DEFAULT_RELTUPLES;
+				relpages = DEFAULT_RELPAGES;
+			}
+			reltuplesValues.push({
+				relname: table.tableName,
+				schema_name: table.schemaName,
+				reltuples,
+				relpages,
+				relallfrozen,
+				relallvisible
+			});
+			if (this.mode.kind === "fromAssumption") for (const index of table.indexes) {
+				const indexRelpages = estimateIndexRelpages(this.mode.reltuples, index.columns, index.fillfactor / 100, index.amname, relpages);
+				reltuplesValues.push({
+					relname: index.indexName,
+					schema_name: table.schemaName,
+					reltuples: this.mode.reltuples,
+					relpages: indexRelpages,
+					relallfrozen: 0,
+					relallvisible: indexRelpages
+				});
+			}
+			else if (targetTable) for (const index of targetTable.indexes) reltuplesValues.push({
+				relname: index.indexName,
+				schema_name: targetTable.schemaName,
+				reltuples: index.reltuples,
+				relpages: index.relpages,
+				relallfrozen: index.relallfrozen,
+				relallvisible: index.relallvisible
+			});
+		}
+		const reltuplesQuery = dedent`
+        update pg_class p
+        set reltuples = v.reltuples,
+            relpages = v.relpages,
+            -- relallfrozen = case when v.relallfrozen is null then p.relallfrozen else v.relallfrozen end,
+            relallvisible = case when v.relallvisible is null then p.relallvisible else v.relallvisible end
+        from jsonb_to_recordset($1::jsonb)
+            as v(reltuples real, relpages integer, relallfrozen integer, relallvisible integer, relname text, schema_name text)
+        where p.relname = v.relname
+        and p.relnamespace = (select oid from pg_namespace where nspname = v.schema_name)
+        returning p.relname, p.relnamespace, p.reltuples, p.relpages;
+        `;
+		const reltuplesPromise = tx.exec(reltuplesQuery, [reltuplesValues]).catch((err) => {
+			console.error("Something went wrong updating reltuples/relpages");
+			console.error(err);
+			return err;
+		});
+		if (this.exportedMetadata) for (const table of this.exportedMetadata) {
+			const tableExists = processedTables.has(`${table.schemaName}.${table.tableName}`);
+			if (tableExists && table.reltuples === -1) {
+				console.warn(`Table ${table.tableName} has reltuples -1. Your production database is probably not analyzed properly`);
+				warnings.tableNotAnalyzed.push(`${table.schemaName}.${table.tableName}`);
+			}
+			if (tableExists) continue;
+			warnings.tablesNotInTest.push(`${table.schemaName}.${table.tableName}`);
+		}
+		const [statsUpdates, reltuplesUpdates] = await Promise.all([columnStatsUpdatePromise, reltuplesPromise]);
+		if (!(statsUpdates ? statsUpdates.length === columnStatsValues.length : true)) console.error(`Did not update expected column stats`);
+		if (reltuplesUpdates.length !== reltuplesValues.length) console.error(`Did not update expected reltuples/relpages`);
+		return warnings;
+	}
+	static async dumpStats(db, postgresVersion, kind) {
+		const fullDump = kind === "full";
+		console.log(`dumping stats for postgres ${gray(postgresVersion)}`);
+		const stats = await db.exec(`
+      WITH table_columns AS (
+        SELECT
+          cl.relname,
+          n.nspname,
+          cl.reltuples,
+          cl.relpages,
+          cl.relallvisible,
+          -- cl.relallfrozen,
+          json_agg(
+            json_build_object(
+              'columnName', a.attname,
+              'attlen', CASE WHEN a.attlen > 0 THEN a.attlen ELSE NULL END,
+              'stats', (
+                SELECT json_build_object(
+                  'starelid', s.starelid,
+                  'staattnum', s.staattnum,
+                  'stanullfrac', s.stanullfrac,
+                  'stawidth', s.stawidth,
+                  'stadistinct', s.stadistinct,
+                  'stakind1', s.stakind1, 'staop1', s.staop1, 'stacoll1', s.stacoll1, 'stanumbers1', s.stanumbers1,
+                  'stakind2', s.stakind2, 'staop2', s.staop2, 'stacoll2', s.stacoll2, 'stanumbers2', s.stanumbers2,
+                  'stakind3', s.stakind3, 'staop3', s.staop3, 'stacoll3', s.stacoll3, 'stanumbers3', s.stanumbers3,
+                  'stakind4', s.stakind4, 'staop4', s.staop4, 'stacoll4', s.stacoll4, 'stanumbers4', s.stanumbers4,
+                  'stakind5', s.stakind5, 'staop5', s.staop5, 'stacoll5', s.stacoll5, 'stanumbers5', s.stanumbers5,
+                  'stavalues1', CASE WHEN $1 THEN s.stavalues1 ELSE NULL END,
+                  'stavalues2', CASE WHEN $1 THEN s.stavalues2 ELSE NULL END,
+                  'stavalues3', CASE WHEN $1 THEN s.stavalues3 ELSE NULL END,
+                  'stavalues4', CASE WHEN $1 THEN s.stavalues4 ELSE NULL END,
+                  'stavalues5', CASE WHEN $1 THEN s.stavalues5 ELSE NULL END
+                )
+                FROM pg_statistic s
+                WHERE s.starelid = a.attrelid AND s.staattnum = a.attnum
+              )
+            )
+            ORDER BY a.attnum
+          ) AS columns
+        FROM pg_class cl
+        JOIN pg_namespace n ON n.oid = cl.relnamespace
+        JOIN pg_attribute a ON a.attrelid = cl.oid AND a.attnum > 0 AND NOT a.attisdropped
+        WHERE cl.relkind = 'r'
+          AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'tiger', 'tiger_data', 'topology')
+          AND cl.relname NOT IN ('pg_stat_statements', 'pg_stat_statements_info')
+        GROUP BY cl.relname, n.nspname, cl.reltuples, cl.relpages, cl.relallvisible
+      ),
+      table_indexes AS (
+        SELECT
+          t.relname AS table_name,
+          json_agg(
+            json_build_object(
+              'indexName', i.relname,
+              'amname', am.amname,
+              'reltuples', i.reltuples,
+              'relpages', i.relpages,
+              'relallvisible', i.relallvisible,
+              -- 'relallfrozen', i.relallfrozen,
+              'fillfactor', COALESCE(
+                (
+                  SELECT (regexp_match(opt, 'fillfactor=(\\d+)'))[1]::integer
+                  FROM unnest(i.reloptions) AS opt
+                  WHERE opt LIKE 'fillfactor=%'
+                  LIMIT 1
+                ),
+                90
+              ),
+              'columns', COALESCE(
+                (
+                  SELECT json_agg(json_build_object(
+                    'attlen', CASE WHEN a.attlen > 0 THEN a.attlen ELSE NULL END
+                  ) ORDER BY col_pos.ord)
+                  FROM unnest(ix.indkey) WITH ORDINALITY AS col_pos(attnum, ord)
+                  JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = col_pos.attnum
+                  WHERE col_pos.attnum > 0
+                ),
+                '[]'::json
+              )
+            )
+          ) AS indexes
+        FROM pg_class t
+        JOIN pg_index ix ON ix.indrelid = t.oid
+        JOIN pg_class i ON i.oid = ix.indexrelid
+        JOIN pg_am am ON am.oid = i.relam
+        JOIN pg_namespace n ON n.oid = t.relnamespace
+        WHERE t.relname NOT LIKE 'pg_%'
+          AND n.nspname <> 'information_schema'
+          AND n.nspname NOT IN ('tiger', 'tiger_data', 'topology')
+        GROUP BY t.relname
+      )
+      SELECT json_agg(
+        json_build_object(
+          'tableName', tc.relname,
+          'schemaName', tc.nspname,
+          'reltuples', tc.reltuples,
+          'relpages', tc.relpages,
+          'relallvisible', tc.relallvisible,
+          -- 'relallfrozen', tc.relallfrozen,
+          'columns', COALESCE(tc.columns, '[]'::json),
+          'indexes', COALESCE(ti.indexes, '[]'::json)
+        )
+      )
+      FROM table_columns tc
+      LEFT JOIN table_indexes ti
+        ON ti.table_name = tc.relname;
+      `, [fullDump]);
+		return z.array(ExportedStats).parse(stats[0].json_agg);
+	}
+	/**
+	* Returns all indexes in the database.
+	* ONLY handles regular btree indexes
+	*/
+	async getExistingIndexes() {
+		return await this.db.exec(`
+      WITH partitioned_tables AS (
+          SELECT
+              inhparent::regclass AS parent_table,
+              inhrelid::regclass AS partition_table
+          FROM
+              pg_inherits
+      )
+      SELECT
+          n.nspname AS schema_name,
+          COALESCE(pt.parent_table::text, t.relname) AS table_name,
+          i.relname AS index_name,
+          ix.indisprimary as is_primary,
+          ix.indisunique as is_unique,
+          am.amname AS index_type,
+          array_agg(
+              CASE
+                  -- Handle regular columns
+                  WHEN a.attname IS NOT NULL THEN
+                    json_build_object('name', a.attname, 'order',
+                      CASE
+                          WHEN (indoption[array_position(ix.indkey, a.attnum)] & 1) = 1 THEN 'DESC'
+                          ELSE 'ASC'
+                      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,
+                      'opclass', CASE WHEN opc.opcdefault THEN NULL ELSE opc.opcname END)
+              END
+              ORDER BY array_position(ix.indkey, k.attnum)
+          ) AS index_columns
+      FROM
+          pg_class t
+          LEFT JOIN partitioned_tables pt ON t.oid = pt.partition_table
+          JOIN pg_index ix ON t.oid = ix.indrelid
+          JOIN pg_class i ON i.oid = ix.indexrelid
+          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
+          n.nspname <> 'information_schema'
+      GROUP BY
+          n.nspname, COALESCE(pt.parent_table::text, t.relname), i.relname, am.amname, ix.indisprimary, ix.indisunique
+      ORDER BY
+          COALESCE(pt.parent_table::text, t.relname), i.relname; -- @qd_introspection
+      `);
+	}
+};
+_defineProperty(Statistics, "defaultStatsMode", Object.freeze({
+	kind: "fromAssumption",
+	reltuples: DEFAULT_RELTUPLES,
+	relpages: DEFAULT_RELPAGES
+}));
+//#endregion
+export { ExportedStats, ExportedStatsColumns, ExportedStatsIndex, ExportedStatsStatistics, ExportedStatsV1, Statistics, StatisticsMode, StatisticsSource };
+
+//# sourceMappingURL=statistics.mjs.map