@voltro/database 0.85.0 → 0.87.0

package/dist/migrations/introspect.js

@@ -0,0 +1,801 @@
+import { parseSqliteDecimalStorageType as e } from "../sqliteDecimalStorage.js";
+import { indexStorageShape as t } from "../indexStorage.js";
+import { MIGRATION_OPS_TABLE as n } from "./resumeLedger.js";
+import { classifyMssqlJsonCheck as r, mssqlJsonValidation as i } from "../mssqlJsonValueCheck.js";
+import { extractIndexPredicate as a } from "./indexPredicate.js";
+import { idStorageOfType as o } from "./columnEquivalence.js";
+import { DEPLOY_LEDGER_TABLE as s } from "./deployLedger.js";
+import { SCHEMA_OWNER_TABLE as c } from "./schemaOwnerTable.js";
+import { postgresEnumCheckValues as l } from "./postgresEnumCheck.js";
+import { sqliteCatalogKey as u, sqliteCatalogName as d } from "./sqliteCatalogName.js";
+import { sqliteNamedUniqueConstraints as f, sqliteUniqueColumnsKey as p } from "./sqliteConstraintIdentity.js";
+import { Effect as m } from "effect";
+//#region src/migrations/introspect.ts
+var h = (e) => {
+	let t = [String(e)], n = e.cause;
+	for (let e = 0; e < 6 && n != null; e++) t.push(typeof n == "object" && typeof n.message == "string" ? n.message : String(n)), n = typeof n == "object" ? n.cause : void 0;
+	return t.join(" ");
+}, g = (e) => {
+	let t = /[`"[]?([A-Za-z_][A-Za-z0-9_]*)[`"\]]?\s*(?:in\b|=)/i.exec(e);
+	if (!t) return null;
+	let n = [...e.replace(/\\'/g, "'").matchAll(/'((?:[^']|'')*)'/g)].map((e) => e[1].replace(/''/g, "'")).filter((e) => e.length > 0);
+	return n.length === 0 ? null : {
+		column: t[1],
+		values: n
+	};
+}, _ = (e, t) => {
+	if (t === "vector" || t === "halfvec") return "vector";
+	switch (e) {
+		case "text":
+		case "character varying":
+		case "varchar":
+		case "uuid":
+		case "character": return "text";
+		case "integer":
+		case "smallint": return "integer";
+		case "bigint": return "bigint";
+		case "double precision":
+		case "real": return "real";
+		case "numeric":
+		case "decimal": return "decimal";
+		case "boolean": return "boolean";
+		case "bytea": return "bytes";
+		case "timestamp without time zone":
+		case "timestamp with time zone":
+		case "timestamptz":
+		case "timestamp": return "timestamp";
+		case "date": return "date";
+		case "json":
+		case "jsonb": return "json";
+		case "ARRAY": return "array";
+		case "USER-DEFINED": return "text";
+		default: return "text";
+	}
+}, v = {
+	_text: "text",
+	_varchar: "text",
+	_uuid: "text",
+	_int4: "integer",
+	_int2: "integer",
+	_int8: "bigint",
+	_float8: "real",
+	_float4: "real",
+	_bool: "boolean",
+	_bytea: "bytes",
+	_timestamptz: "timestamp",
+	_timestamp: "timestamp",
+	_date: "date",
+	_jsonb: "json",
+	_json: "json"
+}, y = (e) => e === void 0 ? void 0 : v[e], b = (e, t) => e == null || e === "" ? void 0 : { generatedAs: {
+	expr: e,
+	stored: t
+} }, x = (e) => {
+	switch (e.toUpperCase()) {
+		case "CASCADE": return "cascade";
+		case "RESTRICT": return "restrict";
+		case "SET NULL": return "setNull";
+		case "SET DEFAULT": return "noAction";
+		default: return "noAction";
+	}
+}, S = (e, t) => {
+	let n = e !== void 0 && e !== "" ? Number(e) : NaN;
+	return Number.isInteger(n) && n > 0 ? n : t;
+}, C = () => S(process.env.VOLTRO_INTROSPECT_BATCH, 20), w = 300, T = () => {
+	let e = process.env.VOLTRO_INTROSPECT_TIMEOUT_MS;
+	return e !== void 0 && e.trim() === "0" ? 0 : S(e, 3e4);
+}, E = (e, t) => {
+	let n = Number.isFinite(t) && t >= 1 ? Math.floor(t) : 1, r = [];
+	for (let t = 0; t < e.length; t += n) r.push(e.slice(t, t + n));
+	return r;
+}, D = (e) => {
+	let n = T(), r = m.gen(function* () {
+		n > 0 && (yield* e.unsafe(`SET LOCAL statement_timeout = ${n}`));
+		let r = (t) => e.unsafe("(" + t.map((e) => `'${e.replace(/'/g, "''")}'`).join(", ") + ")"), i = (t) => e.unsafe(String(Math.max(0, Math.trunc(t)))), a = C(), s = (e, t) => m.gen(function* () {
+			let n = [];
+			for (let i of E(e, a)) i.length !== 0 && n.push(...yield* t(r(i)));
+			return n;
+		}), c = [];
+		for (let t = 0;; t += w) {
+			let n = yield* e`
+        SELECT c.relname AS table_name,
+               COALESCE(c.reltuples::bigint, 0) AS row_count
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = current_schema() AND c.relkind = 'r'
+        ORDER BY c.relname
+        LIMIT ${i(w)} OFFSET ${i(t)}
+      `;
+			if (c.push(...n), n.length < w) break;
+		}
+		let u = /* @__PURE__ */ new Set(), d = [];
+		for (let e of c) u.has(e.table_name) || (u.add(e.table_name), d.push(e));
+		let f = d.map((e) => e.table_name), p = yield* s(f, (t) => e`
+      SELECT table_name, column_name, data_type, udt_name, is_nullable, column_default,
+             character_maximum_length, numeric_precision, numeric_scale,
+             is_generated, generation_expression,
+             (SELECT a.atttypmod FROM pg_attribute a
+              JOIN pg_class c ON c.oid = a.attrelid
+              JOIN pg_namespace n ON n.oid = c.relnamespace
+              WHERE n.nspname = col.table_schema AND c.relname = col.table_name
+                AND a.attname = col.column_name) AS type_modifier
+      FROM information_schema.columns col
+      WHERE table_schema = current_schema() AND table_name IN ${t}
+      ORDER BY table_name, ordinal_position
+    `), h = yield* s(f, (t) => e`
+      SELECT rel.relname AS table_name, att.attname AS column_name
+      FROM pg_constraint con
+      JOIN pg_class     rel ON rel.oid = con.conrelid
+      JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+      JOIN pg_attribute att ON att.attrelid = con.conrelid AND att.attnum = ANY (con.conkey)
+      WHERE con.contype = 'p' AND nsp.nspname = current_schema()
+        AND rel.relname IN ${t}
+      ORDER BY rel.relname, array_position(con.conkey, att.attnum)
+    `), g = yield* s(f, (t) => e`
+      SELECT rel.relname AS table_name, con.conname AS constraint_name,
+             att.attname AS column_name, array_position(con.conkey, att.attnum) AS position
+      FROM pg_constraint con
+      JOIN pg_class rel ON rel.oid = con.conrelid
+      JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+      JOIN pg_attribute att ON att.attrelid = rel.oid AND att.attnum = ANY (con.conkey)
+      WHERE con.contype = 'u' AND nsp.nspname = current_schema() AND rel.relname IN ${t}
+    `), v = yield* s(f, (t) => e`
+      SELECT rel.relname AS table_name, att.attname AS column_name, pg_get_constraintdef(con.oid) AS def
+      FROM pg_constraint con
+      JOIN pg_class rel ON rel.oid = con.conrelid
+      JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+      JOIN pg_attribute att ON att.attrelid = rel.oid AND att.attnum = con.conkey[1]
+      WHERE con.contype = 'c' AND nsp.nspname = current_schema() AND array_length(con.conkey, 1) = 1
+        AND rel.relname IN ${t}
+    `), S = yield* m.orElseSucceed(e`
+        SELECT t.typname, e.enumlabel
+        FROM pg_type t JOIN pg_enum e ON e.enumtypid = t.oid
+        WHERE t.typtype = 'e'
+        ORDER BY t.typname, e.enumsortorder`, () => []), T = /* @__PURE__ */ new Map();
+		for (let e of S) {
+			let t = T.get(e.typname);
+			t ? t.push(e.enumlabel) : T.set(e.typname, [e.enumlabel]);
+		}
+		let D = new Set(T.keys()), O = (yield* m.orElseSucceed(e`SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'postgis') AS present`, () => []))[0]?.present === !0 ? yield* e`
+          SELECT f_table_name AS table_name, f_geometry_column AS column_name,
+                 'geometry' AS kind, type AS geom_kind, srid
+          FROM geometry_columns WHERE f_table_schema = current_schema()
+          UNION ALL
+          SELECT f_table_name AS table_name, f_geography_column AS column_name,
+                 'geography' AS kind, type AS geom_kind, srid
+          FROM geography_columns WHERE f_table_schema = current_schema()` : [], k = new Map(O.map((e) => [`${e.table_name}.${e.column_name}`, {
+			kind: e.kind === "geography" ? "geography" : "geometry",
+			geomKind: e.geom_kind,
+			srid: e.srid
+		}])), A = /* @__PURE__ */ new Map();
+		for (let e of v) {
+			let t = l(e.def, e.column_name);
+			t !== null && A.set(`${e.table_name}.${e.column_name}`, t);
+		}
+		let j = yield* s(f, (t) => e`
+      SELECT
+        rel.relname   AS source_table,
+        att.attname   AS source_column,
+        frel.relname  AS target_table,
+        fatt.attname  AS target_column,
+        con.conname   AS constraint_name,
+        CASE con.confdeltype
+          WHEN 'c' THEN 'CASCADE' WHEN 'r' THEN 'RESTRICT'
+          WHEN 'n' THEN 'SET NULL' WHEN 'd' THEN 'SET DEFAULT'
+          ELSE 'NO ACTION' END AS delete_rule,
+        CASE con.confupdtype
+          WHEN 'c' THEN 'CASCADE' WHEN 'r' THEN 'RESTRICT'
+          WHEN 'n' THEN 'SET NULL' WHEN 'd' THEN 'SET DEFAULT'
+          ELSE 'NO ACTION' END AS update_rule
+      FROM pg_constraint con
+      JOIN pg_class     rel  ON rel.oid  = con.conrelid
+      JOIN pg_class     frel ON frel.oid = con.confrelid
+      JOIN pg_namespace nsp  ON nsp.oid  = rel.relnamespace
+      JOIN unnest(con.conkey)  WITH ORDINALITY AS ck(attnum, ord) ON true
+      JOIN unnest(con.confkey) WITH ORDINALITY AS fk(attnum, ord) ON fk.ord = ck.ord
+      JOIN pg_attribute att  ON att.attrelid  = con.conrelid  AND att.attnum  = ck.attnum
+      JOIN pg_attribute fatt ON fatt.attrelid = con.confrelid AND fatt.attnum = fk.attnum
+      WHERE con.contype = 'f' AND nsp.nspname = current_schema()
+        AND rel.relname IN ${t}
+      ORDER BY rel.relname, con.conname, ck.ord
+    `), M = yield* s(f, (t) => e`
+      WITH ix AS (
+        SELECT
+          c.relname AS table_name,
+          i.relname AS index_name,
+          ix2.indisunique AS is_unique,
+          am.amname AS access_method,
+          -- An opclass is spelled BARE when it resolves unqualified from this
+          -- connection's search_path, and qualified only when it does not.
+          -- The declared side has no catalog to ask: it maps the distance
+          -- metric to a bare vector_cosine_ops, the same bare token the DDL
+          -- writer emits. So qualifying everything outside public/pg_catalog
+          -- made an extension created in the APP's own schema (DB_SCHEMA pins
+          -- the search_path, and our CREATE EXTENSION is unqualified, so it
+          -- lands there) unmatchable against the declaration: the plan emitted
+          -- drop-index + add-index, executed both, re-planned the same two,
+          -- and a plan that does not converge records no fingerprint -- so
+          -- every boot repeated it, forever.
+          CASE WHEN opn.oid = ANY (current_schemas(true)::regnamespace[]) THEN opc.opcname
+            ELSE opn.nspname || '.' || opc.opcname END AS operator_class,
+          i.reloptions AS reloptions,
+          pg_get_expr(ix2.indpred, ix2.indrelid) AS predicate,
+          ix2.indisvalid AS is_valid,
+          (0 = ANY (ix2.indkey::int[])) AS has_expression,
+          a.attname AS column_name,
+          array_position(ix2.indkey::int[], a.attnum) + 1 AS position
+        FROM pg_index ix2
+        JOIN pg_class i ON i.oid = ix2.indexrelid
+        JOIN pg_am am ON am.oid = i.relam
+        LEFT JOIN pg_opclass opc ON opc.oid = ix2.indclass[0]
+        LEFT JOIN pg_namespace opn ON opn.oid = opc.opcnamespace
+        JOIN pg_class c ON c.oid = ix2.indrelid
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        LEFT JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ANY (ix2.indkey)
+        LEFT JOIN pg_constraint con ON con.conindid = i.oid
+        WHERE n.nspname = current_schema()
+          AND NOT ix2.indisprimary
+          AND con.conindid IS NULL
+          AND c.relname IN ${t}
+      )
+      SELECT * FROM ix ORDER BY table_name, index_name, position
+    `), N = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Map(), F = /* @__PURE__ */ new Map(), I = /* @__PURE__ */ new Map(), L = /* @__PURE__ */ new Map(), R = /* @__PURE__ */ new Map();
+		for (let e of p) {
+			let t = N.get(e.table_name);
+			t || (t = [], N.set(e.table_name, t)), t.push(e);
+		}
+		for (let e of h) {
+			let t = P.get(e.table_name);
+			t || (t = /* @__PURE__ */ new Set(), P.set(e.table_name, t)), t.add(e.column_name);
+		}
+		let z = /* @__PURE__ */ new Map();
+		for (let e of g) {
+			let t = `${e.table_name}\u0000${e.constraint_name}`, n = z.get(t);
+			n || (n = {
+				table: e.table_name,
+				columns: []
+			}, z.set(t, n)), n.columns.push({
+				name: e.column_name,
+				position: e.position
+			});
+		}
+		for (let [e, t] of z) {
+			let n = [...t.columns].sort((e, t) => e.position - t.position).map((e) => e.name);
+			if (n.length === 1) {
+				let e = F.get(t.table);
+				e || (e = /* @__PURE__ */ new Set(), F.set(t.table, e)), e.add(n[0]);
+			} else {
+				let r = I.get(t.table);
+				r || (r = [], I.set(t.table, r)), r.push({
+					name: e.slice(e.indexOf("\0") + 1),
+					table: t.table,
+					columns: n,
+					unique: !0
+				});
+			}
+		}
+		for (let e of j) {
+			let t = L.get(e.source_table);
+			t || (t = [], L.set(e.source_table, t)), t.push(e);
+		}
+		for (let e of M) {
+			let t = R.get(e.table_name);
+			t || (t = /* @__PURE__ */ new Map(), R.set(e.table_name, t));
+			let n = t.get(e.index_name);
+			n || (n = [], t.set(e.index_name, n)), n.push(e);
+		}
+		let B = [];
+		for (let e of d) {
+			let n = /* @__PURE__ */ new Set(), r = (N.get(e.table_name) ?? []).filter((e) => !n.has(e.column_name) && (n.add(e.column_name), !0)), i = P.get(e.table_name) ?? /* @__PURE__ */ new Set(), a = F.get(e.table_name) ?? /* @__PURE__ */ new Set(), s = L.get(e.table_name) ?? [], c = new Map(s.map((e) => [e.source_column, e])), l = new Set(r.filter((e) => e.udt_name === "tsvector").map((e) => e.column_name)), u = r.filter((e) => !l.has(e.column_name)).map((t) => {
+				let n = i.has(t.column_name) && i.size === 1, r = c.get(t.column_name), s = t.data_type === "USER-DEFINED" && t.udt_name !== void 0 && D.has(t.udt_name), l = s ? "enum" : _(t.data_type, t.udt_name), u = !r && n && t.column_name === "id", d = r ? "reference" : u ? "id" : l, f = r ? {
+					table: r.target_table,
+					column: r.target_column,
+					onDelete: x(r.delete_rule),
+					onUpdate: x(r.update_rule),
+					constraintName: r.constraint_name
+				} : void 0, p = A.get(`${e.table_name}.${t.column_name}`);
+				return {
+					name: t.column_name,
+					type: d,
+					...s ? {
+						enumName: t.udt_name,
+						enumValues: T.get(t.udt_name) ?? []
+					} : {},
+					...d === "array" && y(t.udt_name) !== void 0 ? { arrayElement: y(t.udt_name) } : {},
+					...k.has(`${e.table_name}.${t.column_name}`) ? { spatial: k.get(`${e.table_name}.${t.column_name}`) } : {},
+					...u ? { idStorage: o(l) } : {},
+					...d === "vector" ? {
+						vectorPrecision: t.udt_name === "halfvec" ? "half" : "float32",
+						...t.type_modifier !== void 0 && t.type_modifier > 0 ? { vectorDim: t.type_modifier } : {}
+					} : {},
+					...V(t.data_type, t.character_maximum_length) === void 0 ? {} : { maxLength: V(t.data_type, t.character_maximum_length) },
+					...l === "decimal" && typeof t.numeric_precision == "number" ? {
+						precision: t.numeric_precision,
+						...typeof t.numeric_scale == "number" ? { scale: t.numeric_scale } : {}
+					} : {},
+					nullable: t.is_nullable === "YES",
+					unique: a.has(t.column_name) || n && t.column_name === "id",
+					hasDefault: t.column_default !== null,
+					...t.column_default === null ? {} : { defaultValue: t.column_default },
+					...f ? { references: f } : {},
+					...r ? { referenceStorage: ["integer", "bigint"].includes(_(t.data_type, t.udt_name)) ? "numeric" : "text" } : {},
+					...p ? { oneOf: p } : {},
+					...b(t.is_generated === "ALWAYS" ? t.generation_expression ?? "generated" : null, !0) ?? {}
+				};
+			}), d = [], f = R.get(e.table_name);
+			if (f) for (let [n, r] of f) {
+				let i = /* @__PURE__ */ new Set(), a = [...r].filter((e) => e.column_name !== null && e.position !== null).sort((e, t) => (e.position ?? 0) - (t.position ?? 0)).filter((e) => {
+					let t = e.position;
+					return !i.has(t) && (i.add(t), !0);
+				});
+				if (a.some((e) => l.has(e.column_name))) continue;
+				let o = r.some((e) => e.has_expression), s = r[0], c = new Map((s?.reloptions ?? []).map((e) => {
+					let [t, n] = e.split("=");
+					return [t, Number(n)];
+				}));
+				if (s?.access_method === "hnsw" && !s.operator_class) throw Error(`Cannot read HNSW operator class for index ${n}`);
+				d.push({
+					name: n,
+					table: e.table_name,
+					columns: a.map((e) => e.column_name),
+					unique: r[0]?.is_unique ?? !1,
+					...t(s?.access_method, s?.access_method === "hnsw" ? { hnsw: {
+						opclass: s.operator_class,
+						m: c.get("m") ?? 16,
+						efConstruction: c.get("ef_construction") ?? 64
+					} } : s?.access_method === "gin" && s.operator_class ? { gin: { opclass: s.operator_class } } : void 0),
+					...r[0]?.predicate == null ? {} : { where: r[0].predicate },
+					...r[0]?.is_valid === !1 ? { valid: !1 } : {},
+					...o ? { expression: !0 } : {}
+				});
+			}
+			for (let t of I.get(e.table_name) ?? []) d.push(t);
+			i.size > 0 && d.push({
+				name: `${e.table_name}_pkey`,
+				table: e.table_name,
+				columns: [...i],
+				unique: !0
+			});
+			let p = Number(e.row_count ?? 0);
+			B.push({
+				name: e.table_name,
+				columns: u,
+				indexes: d,
+				...p > 0 ? { rowCount: p } : {}
+			});
+		}
+		return { tables: B };
+	});
+	return (n > 0 ? e.withTransaction(r) : r).pipe(m.catch((e) => {
+		let t = h(e).toLowerCase();
+		return t.includes("statement timeout") || t.includes("57014") ? m.die(/* @__PURE__ */ Error(`schema introspection exceeded VOLTRO_INTROSPECT_TIMEOUT_MS (${n}ms) — the schema is very large / FK-dense or the database is slow. Raise VOLTRO_INTROSPECT_TIMEOUT_MS, set it to 0 to disable the ceiling, or use DB_DIRECT_URL for a non-pooler connection.`)) : m.fail(e);
+	}));
+}, O = (e, t) => {
+	switch (e.toLowerCase()) {
+		case "varchar":
+		case "char":
+		case "text":
+		case "tinytext":
+		case "mediumtext":
+		case "longtext": return "text";
+		case "enum": return "enum";
+		case "tinyint": return t.toLowerCase() === "tinyint(1)" ? "boolean" : "integer";
+		case "int":
+		case "integer":
+		case "smallint":
+		case "mediumint": return "integer";
+		case "bigint": return "bigint";
+		case "decimal":
+		case "numeric": return "decimal";
+		case "double":
+		case "float":
+		case "real": return "real";
+		case "datetime":
+		case "timestamp": return "timestamp";
+		case "date": return "date";
+		case "blob":
+		case "tinyblob":
+		case "mediumblob":
+		case "longblob":
+		case "binary":
+		case "varbinary": return "bytes";
+		case "json": return "json";
+		default: return "text";
+	}
+}, k = (e) => e.map((e) => {
+	let t = e, n = {};
+	for (let e of Object.keys(t)) n[e.toLowerCase()] = t[e];
+	return n;
+}), A = (e) => m.gen(function* () {
+	let t = k(yield* e`
+      SELECT table_name, COALESCE(table_rows, 0) AS table_rows
+      FROM information_schema.tables
+      WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE'
+      ORDER BY table_name`), n = k(yield* e`
+      SELECT table_name, column_name, data_type, column_type, is_nullable, column_default, column_key,
+             character_maximum_length, numeric_precision, numeric_scale,
+             generation_expression, extra, character_set_name
+      FROM information_schema.columns
+      WHERE table_schema = DATABASE()
+      ORDER BY table_name, ordinal_position`), r = k(yield* e`
+      SELECT k.table_name              AS source_table,
+             k.column_name             AS source_column,
+             k.referenced_table_name   AS target_table,
+             k.referenced_column_name  AS target_column,
+             k.constraint_name         AS constraint_name,
+             r.delete_rule, r.update_rule
+      FROM information_schema.key_column_usage k
+      JOIN information_schema.referential_constraints r
+        ON k.constraint_name = r.constraint_name
+       AND k.table_schema    = r.constraint_schema
+      WHERE k.table_schema = DATABASE() AND k.referenced_table_name IS NOT NULL`), i = k(yield* e`
+      SELECT table_name, index_name, non_unique, column_name, seq_in_index
+      FROM information_schema.statistics
+      WHERE table_schema = DATABASE() AND index_name <> 'PRIMARY' AND index_type <> 'FULLTEXT'
+      ORDER BY table_name, index_name, seq_in_index`), a = e`
+      SELECT cc.table_name AS table_name, cc.check_clause AS check_clause
+      FROM information_schema.check_constraints cc
+      WHERE cc.constraint_schema = DATABASE()`.unprepared, s = e`
+      SELECT tc.table_name AS table_name, cc.check_clause AS check_clause
+      FROM information_schema.check_constraints cc
+      JOIN information_schema.table_constraints tc
+        ON tc.constraint_schema = cc.constraint_schema
+       AND tc.constraint_name   = cc.constraint_name
+      WHERE cc.constraint_schema = DATABASE()`.unprepared, c = k(yield* a.pipe(m.catch(() => s), m.orElseSucceed(() => []))), l = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Map();
+	for (let e of c) {
+		let t = /json_valid\(`?([^`)]+)`?\)/i.exec(e.check_clause);
+		if (t) {
+			l.add(`${e.table_name}.${t[1]}`);
+			continue;
+		}
+		let n = g(e.check_clause);
+		n && u.set(`${e.table_name}.${n.column}`, n.values);
+	}
+	let d = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map();
+	for (let e of n) {
+		let t = d.get(e.table_name) ?? [];
+		t.push(e), d.set(e.table_name, t);
+	}
+	for (let e of r) {
+		let t = f.get(e.source_table) ?? [];
+		t.push(e), f.set(e.source_table, t);
+	}
+	for (let e of i) {
+		let t = p.get(e.table_name);
+		t || (t = /* @__PURE__ */ new Map(), p.set(e.table_name, t));
+		let n = t.get(e.index_name) ?? [];
+		n.push(e), t.set(e.index_name, n);
+	}
+	let h = [];
+	for (let e of t) {
+		let t = d.get(e.table_name) ?? [], n = f.get(e.table_name) ?? [], r = new Map(n.map((e) => [e.source_column, e])), i = t.filter((e) => e.column_key === "PRI").map((e) => e.column_name), a = /* @__PURE__ */ new Set(), s = p.get(e.table_name);
+		if (s) for (let e of s.values()) e.length === 1 && e[0].non_unique === 0 && a.add(e[0].column_name);
+		let c = t.map((t) => {
+			let n = i.includes(t.column_name) && i.length === 1, s = r.get(t.column_name), c = l.has(`${e.table_name}.${t.column_name}`) ? "json" : O(t.data_type, t.column_type), d = !s && n && t.column_name === "id", f = s ? "reference" : d ? "id" : c, p = s ? {
+				table: s.target_table,
+				column: s.target_column,
+				onDelete: x(s.delete_rule),
+				onUpdate: x(s.update_rule),
+				constraintName: s.constraint_name
+			} : void 0, m = a.has(t.column_name) || n && t.column_name === "id", h = t.column_default === "NULL" ? null : t.column_default, g = u.get(`${e.table_name}.${t.column_name}`), _ = t.data_type.toLowerCase() === "enum" ? [...t.column_type.matchAll(/'((?:[^']|'')*)'/g)].map((e) => e[1].replace(/''/g, "'")) : void 0;
+			return {
+				name: t.column_name,
+				type: f,
+				...d ? { idStorage: o(c) } : {},
+				...f === "enum" && _ !== void 0 ? { enumValues: _ } : {},
+				nullable: t.is_nullable === "YES",
+				...V(t.data_type, t.character_maximum_length) === void 0 ? {} : { maxLength: V(t.data_type, t.character_maximum_length) },
+				...c === "decimal" && typeof t.numeric_precision == "number" ? {
+					precision: t.numeric_precision,
+					...typeof t.numeric_scale == "number" ? { scale: t.numeric_scale } : {}
+				} : {},
+				unique: m,
+				hasDefault: h !== null,
+				...h === null ? {} : { defaultValue: h },
+				...p ? { references: p } : {},
+				...s ? { referenceStorage: ["integer", "bigint"].includes(O(t.data_type, t.column_type)) ? "numeric" : "text" } : {},
+				...g ? { oneOf: g } : {},
+				...b(t.generation_expression, /STORED/i.test(t.extra ?? "")) ?? {},
+				...t.character_set_name !== null && t.character_set_name !== void 0 && f !== "json" ? { charset: t.character_set_name } : {}
+			};
+		}), m = new Set(n.map((e) => e.source_column)), g = [];
+		if (s) for (let [t, n] of s) {
+			let r = [...n].sort((e, t) => e.seq_in_index - t.seq_in_index);
+			(r.length !== 1 || r[0].non_unique !== 0) && (r.length === 1 && r[0].non_unique !== 0 && m.has(r[0].column_name) && t !== `${e.table_name}_${r[0].column_name}_idx` || g.push({
+				name: t,
+				table: e.table_name,
+				columns: r.map((e) => e.column_name),
+				unique: r[0].non_unique === 0
+			}));
+		}
+		i.length > 0 && g.push({
+			name: `${e.table_name}_pkey`,
+			table: e.table_name,
+			columns: i,
+			unique: !0
+		});
+		let _ = Number(e.table_rows ?? 0);
+		h.push({
+			name: e.table_name,
+			columns: c,
+			indexes: g,
+			..._ > 0 ? { rowCount: _ } : {}
+		});
+	}
+	return { tables: h };
+}), j = (t) => {
+	if (e(t)) return "decimal";
+	let n = t.toUpperCase();
+	return n.includes("INT") ? "integer" : n.includes("CHAR") || n.includes("CLOB") || n.includes("TEXT") ? "text" : n.includes("REAL") || n.includes("FLOA") || n.includes("DOUB") ? "real" : n.includes("BLOB") ? "bytes" : /^(NUMERIC|DECIMAL)\b/.test(n.trim()) ? "decimal" : "text";
+}, M = (e) => e === 1 || e === !0, N = [
+	"content",
+	"data",
+	"idx",
+	"config",
+	"docsize",
+	"segments",
+	"segdir",
+	"stat"
+], P = (t) => m.gen(function* () {
+	let n = yield* t`
+      SELECT name, sql FROM sqlite_master
+      WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+      ORDER BY name`, r = new Map(n.map((e) => [u(e.name), d("table", e.name, e.sql)])), i = yield* t`
+      SELECT name, sql FROM sqlite_master WHERE type = 'index'`, s = new Map(i.map((e) => [e.name, e.sql])), c = (e) => `'${e.replace(/'/g, "''")}'`, l = [], m = n.filter((e) => /^\s*CREATE\s+VIRTUAL\s+TABLE\b/i.test(e.sql ?? "")).map((e) => e.name), h = new Set(m);
+	for (let e of m) for (let t of N) h.add(`${e}_${t}`);
+	let g = (e) => h.has(e);
+	for (let { name: i, sql: m } of n.filter((e) => !g(e.name))) {
+		let n = r.get(u(i)) ?? i, h = /* @__PURE__ */ new Map();
+		for (let e of (m ?? "").matchAll(/CHECK\s*\(\s*"([^"]+)"\s+IN\s*\(([^)]*)\)/gi)) {
+			let t = [...e[2].matchAll(/'((?:[^']|'')*)'/g)].map((e) => e[1].replace(/''/g, "'"));
+			t.length > 0 && h.set(e[1], t);
+		}
+		let g = yield* t.unsafe(`PRAGMA table_xinfo(${c(n)})`), _ = yield* t.unsafe(`PRAGMA foreign_key_list(${c(n)})`), v = yield* t.unsafe(`PRAGMA index_list(${c(n)})`), y = new Map(_.map((e) => [e.from, e])), S = g.filter((e) => e.pk > 0).sort((e, t) => e.pk - t.pk).map((e) => e.name), C = new Map(g.map((e) => [e.name.toLowerCase(), e.name])), w = /* @__PURE__ */ new Map(), T = /* @__PURE__ */ new Map(), E = /* @__PURE__ */ new Set();
+		for (let e of v) {
+			let n = (yield* t.unsafe(`PRAGMA index_info(${c(e.name)})`)).map((e) => e.name).filter((e) => e !== null).map((e) => C.get(e.toLowerCase()) ?? e);
+			if (w.set(e.name, n), e.partial !== void 0 && M(e.partial)) {
+				let t = a(s.get(e.name) ?? "");
+				t !== void 0 && T.set(e.name, t);
+			}
+			!T.has(e.name) && M(e.unique) && n.length === 1 && E.add(n[0]);
+		}
+		let D = g.map((t) => {
+			let n = S.length === 1 && S[0] === t.name, i = y.get(t.name), a = j(t.type), s = e(t.type), c = !i && n && t.name === "id", l = i ? "reference" : c ? "id" : a, d = i ? {
+				table: r.get(u(i.table)) ?? i.table,
+				column: i.to,
+				onDelete: x(i.on_delete),
+				onUpdate: x(i.on_update)
+			} : void 0, f = h.get(t.name);
+			return {
+				name: t.name,
+				type: l,
+				...s ? {
+					...s,
+					sqliteDecimalEncoding: "sortable-v1"
+				} : {},
+				...c ? { idStorage: o(a) } : {},
+				nullable: t.notnull === 0 && !(n && t.type.trim().toUpperCase() === "INTEGER" && !v.some((e) => e.origin === "pk")),
+				unique: E.has(t.name) || n && t.name === "id",
+				hasDefault: t.dflt_value !== null,
+				...t.dflt_value === null ? {} : { defaultValue: t.dflt_value },
+				...d ? { references: d } : {},
+				...i ? { referenceStorage: ["integer", "bigint"].includes(j(t.type)) ? "numeric" : "text" } : {},
+				...f ? { oneOf: f } : {},
+				...b(t.hidden === 2 || t.hidden === 3 ? "generated" : null, t.hidden === 3) ?? {}
+			};
+		}), O = new Set(_.map((e) => e.from)), k, A = [];
+		for (let e of v) {
+			if (e.origin === "pk") continue;
+			let t = w.get(e.name) ?? [], r = T.get(e.name);
+			if (r === void 0 && t.length === 1 && M(e.unique) || r === void 0 && t.length === 1 && !M(e.unique) && O.has(t[0]) && e.name.toLowerCase() !== `${n}_${t[0]}_idx`.toLowerCase()) continue;
+			let i = d("index", e.name, s.get(e.name) ?? null), a = e.origin === "u" && r === void 0 && M(e.unique) ? (k ??= f(m ?? "")).get(p(t)) ?? i : i;
+			A.push({
+				name: a,
+				table: n,
+				columns: t,
+				unique: M(e.unique),
+				...r === void 0 ? {} : { where: r }
+			});
+		}
+		S.length > 0 && A.push({
+			name: `${n}_pkey`,
+			table: n,
+			columns: S,
+			unique: !0
+		}), l.push({
+			name: n,
+			columns: D,
+			indexes: A
+		});
+	}
+	return { tables: l };
+}), F = (e) => {
+	switch (e.toLowerCase()) {
+		case "int":
+		case "smallint":
+		case "tinyint": return "integer";
+		case "bigint": return "bigint";
+		case "decimal":
+		case "numeric":
+		case "money": return "decimal";
+		case "float":
+		case "real": return "real";
+		case "bit": return "boolean";
+		case "datetime2":
+		case "datetime":
+		case "smalldatetime":
+		case "datetimeoffset": return "timestamp";
+		case "date": return "date";
+		case "varbinary":
+		case "binary":
+		case "image": return "bytes";
+		default: return "text";
+	}
+}, I = (e) => e === !0 || e === 1, L = (e) => m.gen(function* () {
+	let t = yield* e`
+      SELECT TABLE_NAME AS table_name FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_TYPE = 'BASE TABLE' ORDER BY TABLE_NAME`, n = yield* e`
+      SELECT TABLE_NAME AS table_name, COLUMN_NAME AS column_name, DATA_TYPE AS data_type,
+             IS_NULLABLE AS is_nullable, COLUMN_DEFAULT AS column_default,
+             CHARACTER_MAXIMUM_LENGTH AS character_maximum_length,
+             NUMERIC_PRECISION AS numeric_precision, NUMERIC_SCALE AS numeric_scale
+      FROM INFORMATION_SCHEMA.COLUMNS ORDER BY TABLE_NAME, ORDINAL_POSITION`, a = yield* m.orElseSucceed(e`
+        SELECT t.name AS table_name, c.name AS column_name, cc.definition AS definition,
+               cc.is_persisted AS is_persisted
+        FROM sys.computed_columns cc
+        JOIN sys.columns c ON c.object_id = cc.object_id AND c.column_id = cc.column_id
+        JOIN sys.tables  t ON t.object_id = cc.object_id`, () => []), s = new Map(a.map((e) => [`${e.table_name}.${e.column_name}`, e])), c = yield* e`
+      SELECT st.name AS source_table, sc.name AS source_column,
+             tt.name AS target_table, tc.name AS target_column,
+             fk.name AS constraint_name,
+             fk.delete_referential_action_desc AS delete_rule,
+             fk.update_referential_action_desc AS update_rule
+      FROM sys.foreign_keys fk
+      JOIN sys.foreign_key_columns fkc ON fkc.constraint_object_id = fk.object_id
+      JOIN sys.tables  st ON st.object_id = fkc.parent_object_id
+      JOIN sys.columns sc ON sc.object_id = fkc.parent_object_id AND sc.column_id = fkc.parent_column_id
+      JOIN sys.tables  tt ON tt.object_id = fkc.referenced_object_id
+      JOIN sys.columns tc ON tc.object_id = fkc.referenced_object_id AND tc.column_id = fkc.referenced_column_id`, l = yield* e`
+      SELECT t.name AS table_name, i.name AS index_name, i.is_unique AS is_unique,
+             i.filter_definition AS predicate,
+             i.is_primary_key AS is_primary, c.name AS column_name, ic.key_ordinal AS key_ordinal
+      FROM sys.indexes i
+      JOIN sys.tables t ON t.object_id = i.object_id
+      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      WHERE i.type > 0 AND ic.is_included_column = 0
+      ORDER BY t.name, i.name, ic.key_ordinal`, u = yield* e`
+      SELECT t.name AS table_name, c.name AS column_name, cc.definition AS def,
+             cc.name AS constraint_name, cc.is_disabled, cc.is_not_trusted
+      FROM sys.check_constraints cc
+      JOIN sys.tables t ON t.object_id = cc.parent_object_id
+      LEFT JOIN sys.columns c ON c.object_id = cc.parent_object_id AND c.column_id = cc.parent_column_id`, d = /* @__PURE__ */ new Map();
+	for (let e of u) {
+		let t = g(e.def);
+		t?.column === e.column_name && d.set(`${e.table_name}.${e.column_name}`, t.values);
+	}
+	let f = /* @__PURE__ */ new Map();
+	for (let e of n) {
+		let t = f.get(e.table_name) ?? [];
+		t.push(e), f.set(e.table_name, t);
+	}
+	let p = /* @__PURE__ */ new Map();
+	for (let e of c) {
+		let t = p.get(e.source_table) ?? [];
+		t.push(e), p.set(e.source_table, t);
+	}
+	let h = /* @__PURE__ */ new Map();
+	for (let e of l) {
+		let t = h.get(e.table_name);
+		t || (t = /* @__PURE__ */ new Map(), h.set(e.table_name, t));
+		let n = t.get(e.index_name) ?? [];
+		n.push(e), t.set(e.index_name, n);
+	}
+	let _ = [];
+	for (let { table_name: e } of t) {
+		let t = f.get(e) ?? [], n = p.get(e) ?? [], a = new Map(n.map((e) => [e.source_column, e])), c = new Set(n.map((e) => e.source_column)), l = h.get(e), m = [], g = /* @__PURE__ */ new Set();
+		if (l) for (let [, e] of l) {
+			let t = [...e].sort((e, t) => e.key_ordinal - t.key_ordinal);
+			if (I(t[0].is_primary)) for (let e of t) m.push(e.column_name);
+			else t[0].predicate == null && I(t[0].is_unique) && t.length === 1 && g.add(t[0].column_name);
+		}
+		let v = t.map((t) => {
+			let n = m.length === 1 && m[0] === t.column_name, c = a.get(t.column_name), l = F(t.data_type), f = !c && n && t.column_name === "id", p = c ? "reference" : f ? "id" : l, h = c ? {
+				table: c.target_table,
+				column: c.target_column,
+				onDelete: R(c.delete_rule),
+				onUpdate: R(c.update_rule),
+				constraintName: c.constraint_name
+			} : void 0, _ = t.column_default === null ? null : z(t.column_default), v = d.get(`${e}.${t.column_name}`), y = u.flatMap((n) => {
+				if (n.table_name !== e || n.column_name !== null && n.column_name !== t.column_name) return [];
+				let i = r(t.column_name, n.def);
+				return i ? [{
+					name: n.constraint_name,
+					validation: i,
+					enabled: !I(n.is_disabled),
+					trusted: !I(n.is_not_trusted)
+				}] : [];
+			}).sort((e, t) => e.name.localeCompare(t.name)), x = i(y);
+			return {
+				name: t.column_name,
+				type: p,
+				...f ? { idStorage: o(l) } : {},
+				nullable: t.is_nullable === "YES",
+				...V(t.data_type, t.character_maximum_length) === void 0 ? {} : { maxLength: V(t.data_type, t.character_maximum_length) },
+				...l === "decimal" && typeof t.numeric_precision == "number" ? {
+					precision: t.numeric_precision,
+					...typeof t.numeric_scale == "number" ? { scale: t.numeric_scale } : {}
+				} : {},
+				unique: g.has(t.column_name) || n && t.column_name === "id",
+				hasDefault: _ !== null,
+				..._ === null ? {} : { defaultValue: _ },
+				...h ? { references: h } : {},
+				...c ? { referenceStorage: ["integer", "bigint"].includes(F(t.data_type)) ? "numeric" : "text" } : {},
+				...v ? { oneOf: v } : {},
+				...y.length > 0 ? { jsonChecks: y } : {},
+				...x ? { jsonValidation: x } : {},
+				...b(s.get(`${e}.${t.column_name}`)?.definition ?? null, I(s.get(`${e}.${t.column_name}`)?.is_persisted ?? !1)) ?? {}
+			};
+		}), y = [];
+		if (l) for (let [t, n] of l) {
+			let r = [...n].sort((e, t) => e.key_ordinal - t.key_ordinal);
+			if (I(r[0].is_primary)) continue;
+			let i = r[0].predicate ?? void 0;
+			i === void 0 && r.length === 1 && I(r[0].is_unique) || (i !== void 0 || r.length !== 1 || I(r[0].is_unique) || !c.has(r[0].column_name) || t === `${e}_${r[0].column_name}_idx`) && y.push({
+				name: t,
+				table: e,
+				columns: r.map((e) => e.column_name),
+				unique: I(r[0].is_unique),
+				...i === void 0 ? {} : { where: i }
+			});
+		}
+		m.length > 0 && y.push({
+			name: `${e}_pkey`,
+			table: e,
+			columns: m,
+			unique: !0
+		}), _.push({
+			name: e,
+			columns: v,
+			indexes: y
+		});
+	}
+	return { tables: _ };
+}), R = (e) => {
+	switch (e.toUpperCase().replace(/_/g, " ")) {
+		case "CASCADE": return "cascade";
+		case "SET NULL": return "setNull";
+		case "SET DEFAULT": return "noAction";
+		default: return "noAction";
+	}
+}, z = (e) => {
+	let t = e.trim();
+	for (; t.startsWith("(") && t.endsWith(")");) t = t.slice(1, -1).trim();
+	return t.startsWith("N'") && t.endsWith("'") ? t = t.slice(2, -1) : t.startsWith("'") && t.endsWith("'") && (t = t.slice(1, -1)), t;
+}, B = /* @__PURE__ */ new Set([
+	"character varying",
+	"varchar",
+	"nvarchar",
+	"char",
+	"character",
+	"nchar"
+]), V = (e, t) => {
+	if (!B.has(e.toLowerCase())) return;
+	let n = Number(t);
+	if (!(!Number.isFinite(n) || n <= 0)) return n;
+}, H = /* @__PURE__ */ new Set([
+	n,
+	s,
+	c,
+	"_voltro_plugin_migrations"
+]), U = (e) => e.onDialectOrElse({
+	mysql: () => A(e),
+	mssql: () => L(e),
+	sqlite: () => P(e),
+	orElse: () => D(e)
+}).pipe(m.map((e) => ({
+	...e,
+	tables: e.tables.filter((e) => !H.has(e.name))
+})));
+//#endregion
+export { E as chunkTables, U as introspectSchema, _ as mapPgType, g as parseEnumCheck };