@query-doctor/core 0.8.2 → 0.8.3

package/dist/optimizer/statistics.cjs

@@ -1,10 +1,10 @@
 "use client";
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
-const require_defineProperty = require("../_virtual/_@oxc-project_runtime@0.122.0/helpers/defineProperty.cjs");
+const require_defineProperty = require("../_virtual/_@oxc-project_runtime@0.126.0/helpers/defineProperty.cjs");
 let colorette = require("colorette");
 let zod = require("zod");
 let dedent = require("dedent");
-dedent = require_runtime.__toESM(dedent);
+dedent = require_runtime.__toESM(dedent, 1);
 //#region src/optimizer/statistics.ts
 const StatisticsSource = zod.z.union([zod.z.object({
 	kind: zod.z.literal("path"),
@@ -44,6 +44,7 @@ const ExportedStatsStatistics = zod.z.object({
 const ExportedStatsColumns = zod.z.object({
 	columnName: zod.z.string(),
 	attlen: zod.z.number().nullable(),
+	dataType: zod.z.string().optional(),
 	stats: ExportedStatsStatistics.nullable()
 });
 const ExportedStatsIndex = zod.z.object({
@@ -75,7 +76,59 @@ const StatisticsMode = zod.z.discriminatedUnion("kind", [zod.z.object({
 	stats: zod.z.array(ExportedStats),
 	source: StatisticsSource
 })]);
-const DEFAULT_RELTUPLES = 1e4;
+const ComputedColumnStats = zod.z.object({
+	schema_name: zod.z.string(),
+	table_name: zod.z.string(),
+	column_name: zod.z.string(),
+	data_type: zod.z.string().optional(),
+	stainherit: zod.z.boolean(),
+	stanullfrac: zod.z.number(),
+	stawidth: zod.z.number(),
+	stadistinct: zod.z.number(),
+	stakind1: zod.z.number(),
+	stakind2: zod.z.number(),
+	stakind3: zod.z.number(),
+	stakind4: zod.z.number(),
+	stakind5: zod.z.number(),
+	staop1: zod.z.string(),
+	staop2: zod.z.string(),
+	staop3: zod.z.string(),
+	staop4: zod.z.string(),
+	staop5: zod.z.string(),
+	stacoll1: zod.z.string(),
+	stacoll2: zod.z.string(),
+	stacoll3: zod.z.string(),
+	stacoll4: zod.z.string(),
+	stacoll5: zod.z.string(),
+	stanumbers1: zod.z.array(zod.z.number()).nullable(),
+	stanumbers2: zod.z.array(zod.z.number()).nullable(),
+	stanumbers3: zod.z.array(zod.z.number()).nullable(),
+	stanumbers4: zod.z.array(zod.z.number()).nullable(),
+	stanumbers5: zod.z.array(zod.z.number()).nullable(),
+	stavalues1: zod.z.array(zod.z.any()).nullable(),
+	stavalues2: zod.z.array(zod.z.any()).nullable(),
+	stavalues3: zod.z.array(zod.z.any()).nullable(),
+	stavalues4: zod.z.array(zod.z.any()).nullable(),
+	stavalues5: zod.z.array(zod.z.any()).nullable(),
+	_value_type1: zod.z.string().nullable(),
+	_value_type2: zod.z.string().nullable(),
+	_value_type3: zod.z.string().nullable(),
+	_value_type4: zod.z.string().nullable(),
+	_value_type5: zod.z.string().nullable()
+});
+const ComputedReltuples = zod.z.object({
+	relname: zod.z.string(),
+	schema_name: zod.z.string(),
+	reltuples: zod.z.number(),
+	relpages: zod.z.number(),
+	relallvisible: zod.z.number(),
+	relallfrozen: zod.z.number().optional()
+});
+const ComputedStats = zod.z.object({
+	columnStats: zod.z.array(ComputedColumnStats),
+	reltuples: zod.z.array(ComputedReltuples)
+});
+const DEFAULT_RELTUPLES = 1e7;
 const DEFAULT_RELPAGES = 1;
 const DEFAULT_PAGE_SIZE = 2 ** 13;
 function estimateStawidth(col) {
@@ -96,87 +149,29 @@ var Statistics = class Statistics {
 		this.postgresVersion = postgresVersion;
 		this.ownMetadata = ownMetadata;
 		require_defineProperty._defineProperty(this, "mode", void 0);
+		require_defineProperty._defineProperty(this, "computedStats", void 0);
 		require_defineProperty._defineProperty(this, "exportedMetadata", void 0);
 		if (statsMode) {
 			this.mode = statsMode;
 			if (statsMode.kind === "fromStatisticsExport") this.exportedMetadata = statsMode.stats;
 		} else this.mode = Statistics.defaultStatsMode;
+		this.computedStats = this.buildComputedStats();
 	}
-	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 = [];
+	buildComputedStats() {
+		const columnStats = [];
+		const reltuples = [];
 		for (const table of this.ownMetadata) {
-			const target = (this.exportedMetadata?.find((m) => m.tableName === table.tableName && m.schemaName === table.schemaName))?.columns ?? table.columns;
+			const targetTable = this.exportedMetadata?.find((m) => m.tableName === table.tableName && m.schemaName === table.schemaName);
+			const target = targetTable?.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({
+					columnStats.push({
 						schema_name: table.schemaName,
 						table_name: table.tableName,
 						column_name: column.columnName,
+						data_type: column.dataType,
 						stainherit: false,
 						stanullfrac: .04,
 						stawidth,
@@ -212,12 +207,11 @@ var Statistics = class Statistics {
 						_value_type4: "real",
 						_value_type5: "real"
 					});
-					continue;
-				}
-				columnStatsValues.push({
+				} else columnStats.push({
 					schema_name: table.schemaName,
 					table_name: table.tableName,
 					column_name: column.columnName,
+					data_type: column.dataType,
 					stainherit: stats.stainherit ?? false,
 					stanullfrac: stats.stanullfrac,
 					stawidth: stats.stawidth,
@@ -254,271 +248,148 @@ var Statistics = class Statistics {
 					_value_type5: this.stavalueKind(Statistics.safeStavalues(stats.stavalues5))
 				});
 			}
+			let tableReltuples;
+			let tableRelpages;
+			let relallvisible = 0;
+			let relallfrozen;
+			if (this.mode.kind === "fromAssumption") {
+				tableReltuples = this.mode.reltuples;
+				tableRelpages = estimateRelpages(tableReltuples, table.columns);
+			} else if (targetTable) {
+				tableReltuples = targetTable.reltuples;
+				tableRelpages = targetTable.relpages;
+				relallvisible = targetTable.relallvisible;
+				relallfrozen = targetTable.relallfrozen;
+			} else {
+				tableReltuples = DEFAULT_RELTUPLES;
+				tableRelpages = DEFAULT_RELPAGES;
+			}
+			reltuples.push({
+				relname: table.tableName,
+				schema_name: table.schemaName,
+				reltuples: tableReltuples,
+				relpages: tableRelpages,
+				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, tableRelpages);
+				reltuples.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) reltuples.push({
+				relname: index.indexName,
+				schema_name: targetTable.schemaName,
+				reltuples: index.reltuples,
+				relpages: index.relpages,
+				relallfrozen: index.relallfrozen,
+				relallvisible: index.relallvisible
+			});
 		}
-		/**
-		* 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.default`
-    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) => {
+		return {
+			columnStats,
+			reltuples
+		};
+	}
+	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 = new Set(this.ownMetadata.map((t) => `${t.schemaName}.${t.tableName}`));
+		const columnStatsUpdatePromise = tx.exec(Statistics.columnStatsSQL, [this.computedStats.columnStats]).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
-			});
-		}
+		/**
+		* 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 reltuplesQuery = dedent.default`
         update pg_class p
         set reltuples = v.reltuples,
@@ -531,7 +402,7 @@ var Statistics = class Statistics {
         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) => {
+		const reltuplesPromise = tx.exec(reltuplesQuery, [this.computedStats.reltuples]).catch((err) => {
 			console.error("Something went wrong updating reltuples/relpages");
 			console.error(err);
 			return err;
@@ -546,8 +417,8 @@ var Statistics = class Statistics {
 			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`);
+		if (!(statsUpdates ? statsUpdates.length === this.computedStats.columnStats.length : true)) console.error(`Did not update expected column stats`);
+		if (reltuplesUpdates.length !== this.computedStats.reltuples.length) console.error(`Did not update expected reltuples/relpages`);
 		return warnings;
 	}
 	static async dumpStats(db, postgresVersion, kind) {
@@ -566,6 +437,7 @@ var Statistics = class Statistics {
             json_build_object(
               'columnName', a.attname,
               'attlen', CASE WHEN a.attlen > 0 THEN a.attlen ELSE NULL END,
+              'dataType', t.typname,
               'stats', (
                 SELECT json_build_object(
                   'starelid', s.starelid,
@@ -593,6 +465,7 @@ var Statistics = class Statistics {
         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
+        JOIN pg_type t ON t.oid = a.atttypid
         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')
@@ -722,10 +595,195 @@ var Statistics = class Statistics {
 };
 require_defineProperty._defineProperty(Statistics, "defaultStatsMode", Object.freeze({
 	kind: "fromAssumption",
-	reltuples: DEFAULT_RELTUPLES,
-	relpages: DEFAULT_RELPAGES
+	reltuples: DEFAULT_RELTUPLES
 }));
+require_defineProperty._defineProperty(Statistics, "columnStatsSQL", dedent.default`
+    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`);
 //#endregion
+exports.ComputedColumnStats = ComputedColumnStats;
+exports.ComputedReltuples = ComputedReltuples;
+exports.ComputedStats = ComputedStats;
 exports.ExportedStats = ExportedStats;
 exports.ExportedStatsColumns = ExportedStatsColumns;
 exports.ExportedStatsIndex = ExportedStatsIndex;