qubu 0.6.0 → 0.6.1

package/dist/introspection/mysql.mjs

@@ -0,0 +1,1145 @@
+import { n as createIntrospectionDiagnostic } from "../diagnostics-I9vVtXkc.mjs";
+//#region src/introspection/mysql.ts
+const mysqlServerQuery = `SELECT VERSION() AS version, @@version_comment AS version_comment`;
+const mysqlTablesQuery = `
+  SELECT TABLE_NAME AS table_name, TABLE_TYPE AS table_type,
+         ENGINE AS engine, TABLE_COLLATION AS table_collation,
+         CREATE_OPTIONS AS create_options, TABLE_COMMENT AS table_comment
+  FROM INFORMATION_SCHEMA.TABLES
+  WHERE TABLE_SCHEMA = ?
+  ORDER BY TABLE_NAME
+`;
+const mysqlColumnsQuery = `
+  SELECT TABLE_NAME AS table_name, COLUMN_NAME AS column_name,
+         ORDINAL_POSITION AS ordinal_position, COLUMN_TYPE AS column_type,
+         DATA_TYPE AS data_type,
+         IS_NULLABLE AS is_nullable, COLUMN_DEFAULT AS column_default,
+         EXTRA AS extra, GENERATION_EXPRESSION AS generation_expression,
+         CHARACTER_SET_NAME AS character_set_name,
+         COLLATION_NAME AS collation_name, COLUMN_COMMENT AS column_comment
+  FROM INFORMATION_SCHEMA.COLUMNS
+  WHERE TABLE_SCHEMA = ?
+  ORDER BY TABLE_NAME, ORDINAL_POSITION
+`;
+const mysqlKeyUsageQuery = `
+  SELECT kcu.TABLE_NAME AS table_name, kcu.CONSTRAINT_NAME AS constraint_name,
+         tc.CONSTRAINT_TYPE AS constraint_type, tc.ENFORCED AS enforced,
+         kcu.COLUMN_NAME AS column_name, kcu.ORDINAL_POSITION AS ordinal_position,
+         kcu.REFERENCED_TABLE_NAME AS referenced_table_name,
+         kcu.REFERENCED_COLUMN_NAME AS referenced_column_name,
+         rc.UPDATE_RULE AS update_rule, rc.DELETE_RULE AS delete_rule,
+         rc.MATCH_OPTION AS match_option
+  FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+  JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+    ON tc.CONSTRAINT_SCHEMA = kcu.CONSTRAINT_SCHEMA
+   AND tc.TABLE_NAME = kcu.TABLE_NAME
+   AND tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
+  LEFT JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
+    ON rc.CONSTRAINT_SCHEMA = kcu.CONSTRAINT_SCHEMA
+   AND rc.TABLE_NAME = kcu.TABLE_NAME
+   AND rc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
+  WHERE kcu.CONSTRAINT_SCHEMA = ?
+  ORDER BY kcu.TABLE_NAME, kcu.CONSTRAINT_NAME, kcu.ORDINAL_POSITION
+`;
+const mysqlChecksQuery = `
+  SELECT tc.TABLE_NAME AS table_name, tc.CONSTRAINT_NAME AS constraint_name,
+         tc.ENFORCED AS enforced, cc.CHECK_CLAUSE AS check_clause
+  FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+  JOIN INFORMATION_SCHEMA.CHECK_CONSTRAINTS cc
+    ON cc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA
+   AND cc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
+  WHERE tc.CONSTRAINT_SCHEMA = ? AND tc.CONSTRAINT_TYPE = 'CHECK'
+  ORDER BY tc.TABLE_NAME, tc.CONSTRAINT_NAME
+`;
+const mysqlStatisticsQuery = `
+  SELECT TABLE_NAME AS table_name, INDEX_NAME AS index_name,
+         NON_UNIQUE AS non_unique, SEQ_IN_INDEX AS seq_in_index,
+         COLUMN_NAME AS column_name, COLLATION AS collation,
+         INDEX_TYPE AS index_type, EXPRESSION AS expression,
+         SUB_PART AS sub_part, IS_VISIBLE AS is_visible,
+         COMMENT AS comment, INDEX_COMMENT AS index_comment
+  FROM INFORMATION_SCHEMA.STATISTICS
+  WHERE TABLE_SCHEMA = ?
+  ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX
+`;
+/** View definitions and execution properties for the selected database. */
+const mysqlViewsQuery = `
+  SELECT TABLE_NAME AS table_name, VIEW_DEFINITION AS view_definition,
+         CHECK_OPTION AS check_option, IS_UPDATABLE AS is_updatable,
+         SECURITY_TYPE AS security_type, DEFINER AS definer
+  FROM INFORMATION_SCHEMA.VIEWS
+  WHERE TABLE_SCHEMA = ?
+  ORDER BY TABLE_NAME
+`;
+/** Stored function and procedure declarations for the selected database. */
+const mysqlRoutinesQuery = `
+  SELECT ROUTINE_NAME AS routine_name, ROUTINE_TYPE AS routine_type,
+         DATA_TYPE AS data_type, DTD_IDENTIFIER AS dtd_identifier,
+         ROUTINE_BODY AS routine_body,
+         ROUTINE_DEFINITION AS routine_definition,
+         EXTERNAL_LANGUAGE AS external_language,
+         SQL_DATA_ACCESS AS sql_data_access,
+         IS_DETERMINISTIC AS is_deterministic,
+         SECURITY_TYPE AS security_type, SQL_MODE AS sql_mode,
+         ROUTINE_COMMENT AS routine_comment
+  FROM INFORMATION_SCHEMA.ROUTINES
+  WHERE ROUTINE_SCHEMA = ?
+  ORDER BY ROUTINE_NAME, ROUTINE_TYPE
+`;
+/** Parameter rows, including the ordinal zero return row for functions. */
+const mysqlRoutineParametersQuery = `
+  SELECT SPECIFIC_NAME AS routine_name, ORDINAL_POSITION AS ordinal_position,
+         PARAMETER_MODE AS parameter_mode, PARAMETER_NAME AS parameter_name,
+         DATA_TYPE AS data_type, DTD_IDENTIFIER AS dtd_identifier
+  FROM INFORMATION_SCHEMA.PARAMETERS
+  WHERE SPECIFIC_SCHEMA = ?
+  ORDER BY SPECIFIC_NAME, ORDINAL_POSITION
+`;
+/** Trigger bodies and their table/event metadata. */
+const mysqlTriggersQuery = `
+  SELECT TRIGGER_NAME AS trigger_name, EVENT_MANIPULATION AS event_manipulation,
+         EVENT_OBJECT_TABLE AS table_name, ACTION_CONDITION AS action_condition,
+         ACTION_STATEMENT AS action_statement,
+         ACTION_ORIENTATION AS action_orientation,
+         ACTION_TIMING AS action_timing, ACTION_ORDER AS action_order,
+         DEFINER AS definer, SQL_MODE AS sql_mode
+  FROM INFORMATION_SCHEMA.TRIGGERS
+  WHERE TRIGGER_SCHEMA = ?
+  ORDER BY TRIGGER_NAME, ACTION_ORDER
+`;
+/** Partition and subpartition declarations for tables in the selected database. */
+const mysqlPartitionsQuery = `
+  SELECT TABLE_NAME AS table_name, PARTITION_NAME AS partition_name,
+         SUBPARTITION_NAME AS subpartition_name,
+         PARTITION_ORDINAL_POSITION AS partition_ordinal_position,
+         SUBPARTITION_ORDINAL_POSITION AS subpartition_ordinal_position,
+         PARTITION_METHOD AS partition_method,
+         SUBPARTITION_METHOD AS subpartition_method,
+         PARTITION_EXPRESSION AS partition_expression,
+         SUBPARTITION_EXPRESSION AS subpartition_expression,
+         PARTITION_DESCRIPTION AS partition_description,
+         PARTITION_COMMENT AS partition_comment,
+         TABLESPACE_NAME AS tablespace_name
+  FROM INFORMATION_SCHEMA.PARTITIONS
+  WHERE TABLE_SCHEMA = ? AND PARTITION_NAME IS NOT NULL
+  ORDER BY TABLE_NAME, PARTITION_ORDINAL_POSITION, SUBPARTITION_ORDINAL_POSITION
+`;
+/** Collations used by tables or columns in the selected database. */
+const mysqlCollationsQuery = `
+  SELECT c.COLLATION_NAME AS collation_name,
+         c.CHARACTER_SET_NAME AS character_set_name,
+         c.ID AS collation_id, c.IS_DEFAULT AS is_default,
+         c.IS_COMPILED AS is_compiled, c.SORTLEN AS sort_length,
+         c.PAD_ATTRIBUTE AS pad_attribute
+  FROM INFORMATION_SCHEMA.COLLATIONS c
+  JOIN (
+    SELECT DISTINCT TABLE_COLLATION AS collation_name
+    FROM INFORMATION_SCHEMA.TABLES
+    WHERE TABLE_SCHEMA = ? AND TABLE_COLLATION IS NOT NULL
+    UNION
+    SELECT DISTINCT COLLATION_NAME AS collation_name
+    FROM INFORMATION_SCHEMA.COLUMNS
+    WHERE TABLE_SCHEMA = ? AND COLLATION_NAME IS NOT NULL
+  ) used ON used.collation_name = c.COLLATION_NAME
+  ORDER BY c.COLLATION_NAME
+`;
+/** Scheduled events are retained as opaque MySQL objects, not migration input. */
+const mysqlEventsQuery = `
+  SELECT EVENT_NAME AS event_name, EVENT_TYPE AS event_type,
+         STATUS AS status, EVENT_DEFINITION AS event_definition,
+         EVENT_BODY AS event_body, EXECUTE_AT AS execute_at,
+         INTERVAL_VALUE AS interval_value, INTERVAL_FIELD AS interval_field,
+         EVENT_COMMENT AS event_comment, DEFINER AS definer
+  FROM INFORMATION_SCHEMA.EVENTS
+  WHERE EVENT_SCHEMA = ?
+  ORDER BY EVENT_NAME
+`;
+/** Read one MySQL database into the normalized catalog contract. */
+async function readCatalog(connection, options) {
+	const diagnostics = [];
+	if (connection.dialect !== "mysql") {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "dialect-mismatch",
+			message: "MySQL catalog reading requires a MySQL CatalogConnection",
+			path: ["connection", "dialect"]
+		}));
+		return emptyCatalog(options.namespace, diagnostics);
+	}
+	const server = serverInfo((await query(connection, mysqlServerQuery, [], options, diagnostics, "server"))[0], diagnostics);
+	const tableRows = await query(connection, mysqlTablesQuery, [options.namespace], options, diagnostics, "tables");
+	const tables = tableRows.filter((row) => text(row.table_type) === "BASE TABLE").map((row) => table(row, options.namespace));
+	const deferredObjects = [];
+	const opaqueObjects = [];
+	const views = [];
+	const comments = [];
+	const tableByName = new Map(tables.map((item) => [item.physicalName, item]));
+	const viewRows = await query(connection, mysqlViewsQuery, [options.namespace], options, diagnostics, "views");
+	const viewRowsByName = new Map(viewRows.map((row) => [text(row.table_name) ?? "", row]));
+	for (const row of tableRows.filter((currentRow) => text(currentRow.table_type) !== "BASE TABLE")) {
+		const kind = text(row.table_type)?.toUpperCase();
+		if (kind === "VIEW" || kind === "SYSTEM VIEW") {
+			const mapped = viewObject(row, viewRowsByName.get(text(row.table_name) ?? ""), options.namespace, diagnostics);
+			if (mapped.kind === "deferred-object") deferredObjects.push(mapped);
+			else views.push(mapped);
+		} else {
+			const mapped = deferred(row, options.namespace);
+			deferredObjects.push(mapped);
+			diagnostics.push(createIntrospectionDiagnostic({
+				severity: "warning",
+				code: "unmodeled-object",
+				message: `MySQL object ${mapped.physicalName} (${kind ?? "unknown"}) is retained as a deferred record`,
+				path: ["deferredObjects", mapped.physicalName],
+				physicalReference: mapped.reference,
+				remediation: "Inspect the deferred record before using it as migration input."
+			}));
+		}
+	}
+	const relationByName = /* @__PURE__ */ new Map();
+	for (const currentTable of tables) relationByName.set(currentTable.physicalName, {
+		kind: "table",
+		id: currentTable.id
+	});
+	for (const view of views) relationByName.set(view.physicalName, {
+		kind: "view",
+		id: view.id
+	});
+	const columnRows = await query(connection, mysqlColumnsQuery, [options.namespace], options, diagnostics, "columns");
+	for (const currentTable of tables) currentTable.columns = columnRows.filter((row) => text(row.table_name) === currentTable.physicalName).map((row) => column(row, currentTable, options.namespace));
+	for (const view of views) view.columns = columnRows.filter((row) => text(row.table_name) === view.physicalName).map((row) => column(row, view, options.namespace));
+	const keyRows = await query(connection, mysqlKeyUsageQuery, [options.namespace], options, diagnostics, "constraints");
+	for (const currentTable of tables) currentTable.constraints = constraints(currentTable, keyRows.filter((row) => text(row.table_name) === currentTable.physicalName), tableByName, options.namespace, diagnostics);
+	const checkRows = await query(connection, mysqlChecksQuery, [options.namespace], options, diagnostics, "checks");
+	const constraintsByTable = /* @__PURE__ */ new Map();
+	for (const currentTable of tables) constraintsByTable.set(currentTable.physicalName, [...currentTable.constraints]);
+	for (const row of checkRows) {
+		const currentTable = tableByName.get(text(row.table_name) ?? "");
+		if (!currentTable) continue;
+		const physicalName = text(row.constraint_name) ?? `check_${currentTable.physicalName}`;
+		const check = {
+			kind: "check",
+			id: stableId(physicalName),
+			identitySource: "physical-name",
+			physicalName,
+			expression: sql(text(row.check_clause) ?? "true", options.namespace, currentTable, physicalName),
+			dialect: text(row.enforced)?.toUpperCase() === "NO" ? {
+				dialect: "mysql",
+				version: 1,
+				data: { enforced: false }
+			} : void 0
+		};
+		constraintsByTable.get(currentTable.physicalName)?.push(check);
+	}
+	for (const currentTable of tables) currentTable.constraints = constraintsByTable.get(currentTable.physicalName) ?? [];
+	const statRows = await query(connection, mysqlStatisticsQuery, [options.namespace], options, diagnostics, "statistics");
+	const grouped = /* @__PURE__ */ new Map();
+	for (const row of statRows) {
+		const key = `${text(row.table_name) ?? ""}\u0000${text(row.index_name) ?? ""}`;
+		const group = grouped.get(key) ?? [];
+		group.push(row);
+		grouped.set(key, group);
+	}
+	for (const rows of grouped.values()) {
+		const currentTable = tableByName.get(text(rows[0].table_name) ?? "");
+		if (!currentTable) continue;
+		const mappedIndex = mapIndex(rows, currentTable, options.namespace, diagnostics);
+		if (mappedIndex) currentTable.indexes = [...currentTable.indexes, mappedIndex];
+	}
+	const routineRows = await query(connection, mysqlRoutinesQuery, [options.namespace], options, diagnostics, "routines");
+	const routineParameterRows = await query(connection, mysqlRoutineParametersQuery, [options.namespace], options, diagnostics, "routine-parameters");
+	const routineParameters = /* @__PURE__ */ new Map();
+	for (const row of routineParameterRows) {
+		const name = text(row.routine_name) ?? "unknown";
+		const group = routineParameters.get(name) ?? [];
+		group.push(row);
+		routineParameters.set(name, group);
+	}
+	const routines = routineRows.map((row) => {
+		const routine = routineObject(row, routineParameters.get(text(row.routine_name) ?? "") ?? [], options.namespace);
+		if (routine.comment) comments.push(routine.comment);
+		relationByName.set(routine.physicalName, {
+			kind: "routine",
+			id: routine.id
+		});
+		return routine;
+	});
+	const triggerRows = await query(connection, mysqlTriggersQuery, [options.namespace], options, diagnostics, "triggers");
+	const triggers = [];
+	for (const rows of groupRows(triggerRows, (row) => text(row.trigger_name) ?? "unknown")) {
+		const mapped = triggerObject(rows, relationByName, options.namespace, diagnostics);
+		if (mapped.kind === "trigger") triggers.push(mapped);
+		else deferredObjects.push(mapped);
+	}
+	const partitionRows = await query(connection, mysqlPartitionsQuery, [options.namespace], options, diagnostics, "partitions");
+	const partitions = [];
+	for (const row of partitionRows) {
+		const mapped = partitionObject(row, tableByName, options.namespace, diagnostics);
+		if (mapped.kind === "partition") {
+			partitions.push(mapped);
+			if (mapped.comment) comments.push(mapped.comment);
+		} else deferredObjects.push(mapped);
+	}
+	const collationRows = await query(connection, mysqlCollationsQuery, [options.namespace, options.namespace], options, diagnostics, "collations");
+	const usedCollations = new Set([...tableRows.map((row) => text(row.table_collation)), ...columnRows.map((row) => text(row.collation_name))].filter((value) => value !== void 0));
+	const collations = collationRows.filter((row) => {
+		const name = text(row.collation_name);
+		return name !== void 0 && usedCollations.has(name);
+	}).map((row) => collationObject(row, options.namespace));
+	const eventRows = await query(connection, mysqlEventsQuery, [options.namespace], options, diagnostics, "events");
+	for (const row of eventRows) {
+		const event = opaqueEvent(row, options.namespace);
+		opaqueObjects.push(event);
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "warning",
+			code: "unmodeled-object",
+			message: `MySQL event ${event.physicalName} is retained as opaque data`,
+			path: ["opaqueObjects", event.physicalName],
+			physicalReference: event.reference,
+			remediation: "Inspect the event definition before treating it as migration input."
+		}));
+		const eventComment = text(row.event_comment);
+		if (eventComment !== void 0 && eventComment !== "") comments.push(objectComment({
+			kind: "opaque-object",
+			id: event.id
+		}, eventComment, event.reference, options.namespace));
+	}
+	for (const currentTable of tables) {
+		const tableComment = text(tableRows.find((row) => text(row.table_name) === currentTable.physicalName)?.table_comment);
+		if (tableComment !== void 0 && tableComment !== "") comments.push(objectComment({
+			kind: "table",
+			id: currentTable.id
+		}, tableComment, currentTable.reference, options.namespace));
+		for (const currentColumn of currentTable.columns) {
+			const columnComment = text(columnRows.find((row) => text(row.table_name) === currentTable.physicalName && text(row.column_name) === currentColumn.physicalName)?.column_comment);
+			if (columnComment !== void 0 && columnComment !== "") comments.push(objectComment({
+				kind: "column",
+				id: currentColumn.id
+			}, columnComment, currentColumn.reference, options.namespace));
+		}
+	}
+	for (const view of views) {
+		const viewComment = text(tableRows.find((row) => text(row.table_name) === view.physicalName)?.table_comment);
+		if (viewComment !== void 0 && viewComment !== "") comments.push(objectComment({
+			kind: view.kind,
+			id: view.id
+		}, viewComment, view.reference, options.namespace));
+		for (const currentColumn of view.columns) {
+			const columnComment = text(columnRows.find((row) => text(row.table_name) === view.physicalName && text(row.column_name) === currentColumn.physicalName)?.column_comment);
+			if (columnComment !== void 0 && columnComment !== "") comments.push(objectComment({
+				kind: "column",
+				id: currentColumn.id
+			}, columnComment, currentColumn.reference, options.namespace));
+		}
+	}
+	const capabilities = {
+		generatedColumns: server.capabilities.generatedColumns,
+		identityMetadata: server.capabilities.identityMetadata,
+		checkConstraints: server.capabilities.checkConstraints,
+		checkConstraintEnforcement: server.capabilities.checkConstraintEnforcement,
+		expressionDecompilation: server.capabilities.expressionDecompilation,
+		indexExpressions: server.capabilities.indexExpressions,
+		indexPredicates: server.capabilities.indexPredicates,
+		indexIncludedColumns: server.capabilities.indexIncludedColumns,
+		namespaces: server.capabilities.namespaces,
+		visibility: server.capabilities.visibility
+	};
+	const serverCapabilities = {
+		...server.capabilities,
+		views: true,
+		materializedViews: false,
+		sequences: false,
+		enums: false,
+		domains: false,
+		collations: true,
+		routines: true,
+		triggers: true,
+		partitions: true,
+		policies: false,
+		extensions: false,
+		comments: true,
+		ownership: false,
+		scheduledEvents: true,
+		tableEngines: true,
+		generatedColumnModes: true,
+		selectedNamespace: options.namespace,
+		productFamily: server.product === "mariadb" ? "mariadb" : "mysql8"
+	};
+	const namespace = {
+		kind: "mysql-database",
+		name: options.namespace,
+		reference: reference("namespace", options.namespace, options.namespace, "INFORMATION_SCHEMA.SCHEMATA", "SCHEMA_NAME"),
+		dialect: extension({
+			selectedNamespace: options.namespace,
+			views: true,
+			materializedViews: false,
+			sequences: false,
+			routines: true,
+			triggers: true,
+			partitions: true,
+			collations: true,
+			comments: true,
+			ownership: false,
+			policies: false,
+			extensions: false
+		})
+	};
+	return Object.freeze({
+		dialect: "mysql",
+		server: {
+			...server,
+			capabilities: serverCapabilities
+		},
+		namespace,
+		tables: Object.freeze(tables),
+		views: Object.freeze(views),
+		collations: Object.freeze(collations),
+		routines: Object.freeze(routines),
+		triggers: Object.freeze(triggers),
+		partitions: Object.freeze(partitions),
+		deferredObjects: Object.freeze(deferredObjects),
+		opaqueObjects: Object.freeze(opaqueObjects),
+		comments: Object.freeze(comments),
+		ownership: Object.freeze([]),
+		capabilities,
+		diagnostics: Object.freeze(diagnostics)
+	});
+}
+async function query(connection, textValue, parameters, options, diagnostics, operation) {
+	try {
+		return await connection.query({
+			text: textValue,
+			parameters
+		}, { signal: options.signal });
+	} catch {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "query-failed",
+			message: `MySQL catalog query failed while reading ${operation}`,
+			path: [operation],
+			remediation: "Check Information Schema permissions and the selected database."
+		}));
+		return [];
+	}
+}
+function serverInfo(row, diagnostics) {
+	const rawVersion = text(row?.version) ?? "unknown";
+	const comment = text(row?.version_comment) ?? "";
+	const mariadb = /mariadb/i.test(rawVersion) || /mariadb/i.test(comment);
+	const parts = rawVersion.match(/(\d+)\.(\d+)(?:\.(\d+))?/);
+	const major = parts ? Number(parts[1]) : void 0;
+	const minor = parts ? Number(parts[2]) : void 0;
+	if (mariadb) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "error",
+		code: "unsupported-product",
+		message: "MariaDB requires a dedicated catalog adapter and is not treated as MySQL",
+		path: ["server", "product"]
+	}));
+	const supported = !mariadb && major === 8 && ((minor ?? 0) > 0 || (minor ?? 0) === 0 && Number(parts?.[3] ?? 0) >= 16);
+	if (!supported && !mariadb) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "error",
+		code: "unsupported-server",
+		message: "MySQL introspection requires MySQL 8.0 or newer",
+		path: ["server", "version"]
+	}));
+	return {
+		product: mariadb ? "mariadb" : "mysql",
+		rawVersion,
+		parsedVersion: major === void 0 ? void 0 : {
+			major,
+			minor,
+			patch: parts?.[3] ? Number(parts[3]) : void 0
+		},
+		capabilities: {
+			generatedColumns: supported,
+			identityMetadata: supported,
+			checkConstraints: supported,
+			checkConstraintEnforcement: supported ? "enforced" : "unknown",
+			expressionDecompilation: false,
+			indexExpressions: supported,
+			indexPredicates: false,
+			indexIncludedColumns: false,
+			namespaces: true,
+			visibility: "complete",
+			mysql8: supported
+		}
+	};
+}
+function table(row, namespace) {
+	const physicalName = text(row.table_name) ?? "unnamed_table";
+	return {
+		kind: "table",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		reference: reference("table", physicalName, namespace, "INFORMATION_SCHEMA.TABLES", "TABLE_NAME"),
+		columns: [],
+		constraints: [],
+		indexes: [],
+		dialect: extension({
+			...text(row.engine) === void 0 ? {} : { engine: text(row.engine) },
+			...text(row.table_collation) === void 0 ? {} : { collation: text(row.table_collation) },
+			...text(row.create_options) === void 0 ? {} : { createOptions: text(row.create_options) }
+		})
+	};
+}
+function deferred(row, namespace) {
+	const physicalName = text(row.table_name) ?? "unnamed_object";
+	return {
+		kind: "deferred-object",
+		id: stableId(`deferred:${text(row.table_type) ?? "other"}:${physicalName}`),
+		identitySource: "physical-name",
+		objectKind: text(row.table_type)?.toUpperCase() === "VIEW" || text(row.table_type)?.toUpperCase() === "SYSTEM VIEW" ? "view" : "other",
+		physicalName,
+		reference: reference("deferred-object", physicalName, namespace, "INFORMATION_SCHEMA.TABLES", "TABLE_NAME"),
+		dialect: extension({
+			...text(row.table_type) === void 0 ? {} : { tableType: text(row.table_type) },
+			...text(row.engine) === void 0 ? {} : { engine: text(row.engine) }
+		})
+	};
+}
+function column(row, table, namespace) {
+	const physicalName = text(row.column_name) ?? "unnamed_column";
+	const extra = text(row.extra) ?? "";
+	const generationExpression = text(row.generation_expression);
+	const generated = generationExpression !== void 0 && (/GENERATED/i.test(extra) || generationExpression !== "") ? {
+		kind: "generated",
+		mode: /VIRTUAL/i.test(extra) ? "virtual" : /STORED/i.test(extra) ? "stored" : "unknown",
+		expression: sql(generationExpression, namespace, table, physicalName)
+	} : void 0;
+	const identity = /auto_increment/i.test(extra) ? {
+		kind: "identity",
+		generation: "by-default",
+		options: {},
+		dialect: {
+			dialect: "mysql",
+			version: 1,
+			data: { autoIncrement: true }
+		}
+	} : void 0;
+	const onUpdateMatch = extra.match(/on update\s+(.+)$/i);
+	const defaultText = text(row.column_default);
+	const defaultValue = literal(defaultText, text(row.data_type));
+	return {
+		kind: "column",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		ordinalPosition: number(row.ordinal_position) ?? 0,
+		nullable: text(row.is_nullable)?.toUpperCase() !== "NO",
+		storage: { nativeType: text(row.column_type) ?? "unknown" },
+		default: defaultValue !== void 0 ? {
+			kind: "literal",
+			value: defaultValue
+		} : defaultText !== void 0 ? {
+			kind: "expression",
+			expression: sql(defaultText, namespace, table, physicalName)
+		} : void 0,
+		generated,
+		identity,
+		onUpdate: onUpdateMatch?.[1] ? sql(onUpdateMatch[1], namespace, table, physicalName) : void 0,
+		dialect: extension({
+			...text(row.data_type) === void 0 ? {} : { dataType: text(row.data_type) },
+			...text(row.character_set_name) === void 0 ? {} : { characterSet: text(row.character_set_name) },
+			...text(row.collation_name) === void 0 ? {} : { collation: text(row.collation_name) },
+			...extra === "" ? {} : { extra }
+		}),
+		reference: reference("column", physicalName, namespace, "INFORMATION_SCHEMA.COLUMNS", "COLUMN_NAME")
+	};
+}
+function constraints(table, rows, tableByName, namespace, diagnostics) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const key = text(row.constraint_name) ?? "unknown";
+		const group = grouped.get(key) ?? [];
+		group.push(row);
+		grouped.set(key, group);
+	}
+	const result = [];
+	for (const [physicalName, group] of grouped) {
+		const first = group[0];
+		const columns = group.sort((left, right) => (number(left.ordinal_position) ?? 0) - (number(right.ordinal_position) ?? 0)).map((row) => text(row.column_name) ?? "unknown");
+		const common = {
+			id: stableId(physicalName),
+			identitySource: "physical-name",
+			physicalName,
+			reference: reference("constraint", physicalName, namespace, "INFORMATION_SCHEMA.TABLE_CONSTRAINTS", "CONSTRAINT_NAME")
+		};
+		const type = text(first.constraint_type);
+		if (type === "PRIMARY KEY") {
+			result.push({
+				kind: "primary-key",
+				...common,
+				columns
+			});
+			continue;
+		}
+		if (type === "UNIQUE") {
+			result.push({
+				kind: "unique",
+				...common,
+				columns,
+				nulls: "distinct"
+			});
+			continue;
+		}
+		if (type !== "FOREIGN KEY") continue;
+		const targetTableName = text(first.referenced_table_name) ?? "unknown";
+		if (!tableByName.has(targetTableName)) diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "unresolved-reference",
+			message: `MySQL foreign key target ${targetTableName} was not found`,
+			path: [
+				table.id,
+				"constraints",
+				physicalName
+			]
+		}));
+		result.push({
+			kind: "foreign-key",
+			...common,
+			columns,
+			target: {
+				table: targetTableName,
+				columns: group.map((row) => text(row.referenced_column_name) ?? "unknown")
+			},
+			onUpdate: action(first.update_rule),
+			onDelete: action(first.delete_rule),
+			match: match(first.match_option),
+			dialect: text(first.enforced)?.toUpperCase() === "NO" ? {
+				dialect: "mysql",
+				version: 1,
+				data: { enforced: false }
+			} : void 0
+		});
+	}
+	return result;
+}
+function mapIndex(rows, table, namespace, diagnostics) {
+	const first = rows[0];
+	const physicalName = text(first.index_name);
+	if (!physicalName) return;
+	const terms = [];
+	for (const row of rows) {
+		const expression = text(row.expression);
+		const columnName = text(row.column_name);
+		if (!expression && !columnName) {
+			diagnostics.push(createIntrospectionDiagnostic({
+				severity: "error",
+				code: "unsupported-feature",
+				message: `MySQL index ${physicalName} has an unrepresented term`,
+				path: [
+					table.id,
+					"indexes",
+					physicalName
+				]
+			}));
+			continue;
+		}
+		terms.push(expression ? {
+			kind: "expression",
+			expression: sql(expression, namespace, table, physicalName),
+			position: number(row.seq_in_index) ?? 0
+		} : {
+			kind: "column",
+			column: columnName,
+			position: number(row.seq_in_index) ?? 0,
+			direction: text(row.collation) === "D" ? "DESC" : "ASC",
+			prefixLength: row.sub_part === null || row.sub_part === void 0 ? void 0 : {
+				kind: "literal",
+				value: number(row.sub_part) ?? text(row.sub_part) ?? ""
+			}
+		});
+		if (row.sub_part !== null && row.sub_part !== void 0) diagnostics.push(createIntrospectionDiagnostic({
+			severity: "warning",
+			code: "lossy-mapping",
+			message: `MySQL index prefix length for ${physicalName} is retained only in catalog rows`,
+			path: [
+				table.id,
+				"indexes",
+				physicalName
+			]
+		}));
+	}
+	return {
+		kind: "index",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		unique: number(first.non_unique) === 0,
+		terms,
+		method: text(first.index_type),
+		dialect: extension({
+			...text(first.index_type) === void 0 ? {} : { indexType: text(first.index_type) },
+			...text(first.is_visible) === void 0 ? {} : { visible: text(first.is_visible).toUpperCase() !== "NO" },
+			...text(first.comment) === void 0 ? {} : { comment: text(first.comment) },
+			...text(first.index_comment) === void 0 ? {} : { indexComment: text(first.index_comment) }
+		}),
+		reference: reference("index", physicalName, namespace, "INFORMATION_SCHEMA.STATISTICS", "INDEX_NAME")
+	};
+}
+function viewObject(tableRow, viewRow, namespace, diagnostics) {
+	const physicalName = text(tableRow.table_name) ?? "unnamed_view";
+	const physicalReference = reference("view", physicalName, namespace, "INFORMATION_SCHEMA.VIEWS", "TABLE_NAME");
+	const definition = text(viewRow?.view_definition);
+	if (definition === void 0 || definition.trim() === "") {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "expression-parse-failed",
+			message: `MySQL view ${physicalName} has no recoverable definition`,
+			path: [
+				"views",
+				physicalName,
+				"definition"
+			],
+			physicalReference,
+			remediation: "Grant the metadata privilege needed to read INFORMATION_SCHEMA.VIEWS.VIEW_DEFINITION."
+		}));
+		return {
+			kind: "deferred-object",
+			id: stableId(`view:${physicalName}`),
+			identitySource: "physical-name",
+			objectKind: "view",
+			physicalName,
+			reference: physicalReference,
+			dialect: extension({
+				reason: "definition-unavailable",
+				...text(viewRow?.definer) === void 0 ? {} : { definer: text(viewRow?.definer) }
+			})
+		};
+	}
+	const checkOption = normalizeCheckOption(viewRow?.check_option);
+	const securityType = text(viewRow?.security_type)?.toUpperCase();
+	return {
+		kind: "view",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		columns: [],
+		definition: sql(definition, namespace, {
+			kind: "view",
+			physicalName,
+			reference: physicalReference
+		}, physicalName),
+		...checkOption === void 0 ? {} : { checkOption },
+		...securityType === "INVOKER" ? { securityInvoker: true } : {},
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "mysql",
+			reference: physicalReference
+		},
+		dialect: extension({
+			...text(viewRow?.is_updatable) === void 0 ? {} : { isUpdatable: text(viewRow?.is_updatable) },
+			...securityType === void 0 ? {} : { securityType },
+			...text(viewRow?.definer) === void 0 ? {} : { definer: text(viewRow?.definer) }
+		})
+	};
+}
+function routineObject(row, parameterRows, namespace) {
+	const physicalName = text(row.routine_name) ?? "unnamed_routine";
+	const physicalReference = reference("routine", physicalName, namespace, "INFORMATION_SCHEMA.ROUTINES", "ROUTINE_NAME");
+	const parameters = parameterRows.filter((row) => (number(row.ordinal_position) ?? 0) > 0).sort((left, right) => (number(left.ordinal_position) ?? 0) - (number(right.ordinal_position) ?? 0)).map(routineParameter);
+	const definition = text(row.routine_definition);
+	const returnType = text(row.data_type);
+	const routine = {
+		kind: "routine",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		routineKind: text(row.routine_type)?.toUpperCase() === "FUNCTION" ? "function" : text(row.routine_type)?.toUpperCase() === "PROCEDURE" ? "procedure" : "unknown",
+		parameters,
+		...returnType === void 0 || returnType.toUpperCase() === "VOID" ? {} : { returnType: storage(row.data_type, row.dtd_identifier) },
+		...text(row.external_language) === void 0 && text(row.routine_body) === void 0 ? {} : { language: text(row.external_language) ?? text(row.routine_body) ?? "unknown" },
+		...definition === void 0 ? {} : { body: sql(definition, namespace, {
+			kind: "routine",
+			physicalName,
+			reference: physicalReference
+		}, physicalName) },
+		volatility: "unknown",
+		...text(row.security_type) === void 0 ? {} : { security: routineSecurity(row.security_type) },
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "mysql",
+			reference: physicalReference
+		},
+		dialect: extension({
+			...text(row.is_deterministic) === void 0 ? {} : { deterministic: text(row.is_deterministic).toUpperCase() === "YES" },
+			...text(row.sql_data_access) === void 0 ? {} : { sqlDataAccess: text(row.sql_data_access) },
+			...text(row.sql_mode) === void 0 ? {} : { sqlMode: text(row.sql_mode) }
+		})
+	};
+	const commentText = text(row.routine_comment);
+	if (commentText === void 0 || commentText === "") return routine;
+	return {
+		...routine,
+		comment: objectComment({
+			kind: "routine",
+			id: routine.id
+		}, commentText, physicalReference, namespace)
+	};
+}
+function routineParameter(row) {
+	const parameterName = text(row.parameter_name);
+	return {
+		...parameterName === void 0 ? {} : { name: parameterName },
+		...routineParameterMode(row.parameter_mode) === void 0 ? {} : { mode: routineParameterMode(row.parameter_mode) },
+		storage: storage(row.data_type, row.dtd_identifier),
+		ordinalPosition: number(row.ordinal_position) ?? 0
+	};
+}
+function triggerObject(rows, relations, namespace, diagnostics) {
+	const first = rows[0];
+	const physicalName = text(first.trigger_name) ?? "unnamed_trigger";
+	const physicalReference = reference("trigger", physicalName, namespace, "INFORMATION_SCHEMA.TRIGGERS", "TRIGGER_NAME");
+	const tableName = text(first.table_name);
+	const target = tableName === void 0 ? void 0 : relations.get(tableName);
+	const body = text(first.action_statement);
+	if (target === void 0 || body === void 0 || body.trim() === "") {
+		if (target === void 0) diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "unresolved-reference",
+			message: `MySQL trigger ${physicalName} target ${tableName ?? "unknown"} was not found`,
+			path: [
+				"triggers",
+				physicalName,
+				"table"
+			],
+			physicalReference
+		}));
+		if (body === void 0 || body.trim() === "") diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "expression-parse-failed",
+			message: `MySQL trigger ${physicalName} has no recoverable body`,
+			path: [
+				"triggers",
+				physicalName,
+				"body"
+			],
+			physicalReference
+		}));
+		return {
+			kind: "deferred-object",
+			id: stableId(`trigger:${physicalName}`),
+			identitySource: "physical-name",
+			objectKind: "trigger",
+			physicalName,
+			reference: physicalReference,
+			dialect: extension({
+				...tableName === void 0 ? {} : { tableName },
+				...body === void 0 ? {} : { actionStatement: body }
+			})
+		};
+	}
+	const timing = triggerTiming(first.action_timing);
+	const events = [...new Set(rows.map((row) => triggerEvent(row.event_manipulation)).filter((value) => value !== void 0))];
+	return {
+		kind: "trigger",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		table: target,
+		timing,
+		events,
+		orientation: triggerOrientation(first.action_orientation),
+		...text(first.action_condition) === void 0 ? {} : { condition: sql(text(first.action_condition), namespace, {
+			kind: "trigger",
+			physicalName,
+			reference: physicalReference
+		}, physicalName) },
+		body: sql(body, namespace, {
+			kind: "trigger",
+			physicalName,
+			reference: physicalReference
+		}, physicalName),
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "mysql",
+			reference: physicalReference
+		},
+		dialect: extension({
+			...text(first.definer) === void 0 ? {} : { definer: text(first.definer) },
+			...text(first.sql_mode) === void 0 ? {} : { sqlMode: text(first.sql_mode) },
+			...number(first.action_order) === void 0 ? {} : { actionOrder: number(first.action_order) }
+		})
+	};
+}
+function partitionObject(row, tables, namespace, diagnostics) {
+	const tableName = text(row.table_name) ?? "unknown";
+	const partitionName = text(row.partition_name);
+	const subpartitionName = text(row.subpartition_name);
+	const physicalName = partitionName === void 0 ? tableName : subpartitionName === void 0 ? partitionName : `${partitionName}/${subpartitionName}`;
+	const physicalReference = reference("partition", physicalName, namespace, "INFORMATION_SCHEMA.PARTITIONS", "PARTITION_NAME");
+	const parent = tables.get(tableName);
+	if (parent === void 0) {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "unresolved-reference",
+			message: `MySQL partition ${physicalName} parent table ${tableName} was not found`,
+			path: [
+				"partitions",
+				physicalName,
+				"parent"
+			],
+			physicalReference
+		}));
+		return {
+			kind: "deferred-object",
+			id: stableId(`partition:${tableName}:${physicalName}`),
+			identitySource: "physical-name",
+			objectKind: "partition",
+			physicalName,
+			reference: physicalReference,
+			dialect: extension({ tableName })
+		};
+	}
+	const method = text(row.subpartition_method) ?? text(row.partition_method) ?? "UNKNOWN";
+	const strategy = partitionStrategy(method);
+	if (strategy === "unknown") diagnostics.push(createIntrospectionDiagnostic({
+		severity: "warning",
+		code: "unsupported-feature",
+		message: `MySQL partition method ${method} is retained with an unknown normalized strategy`,
+		path: [
+			"partitions",
+			physicalName,
+			"strategy"
+		],
+		physicalReference
+	}));
+	const boundText = text(row.partition_description) ?? text(row.subpartition_expression) ?? text(row.partition_expression);
+	const expression = text(row.partition_expression);
+	const partition = {
+		kind: "partition",
+		id: stableId(`partition:${tableName}:${physicalName}`),
+		identitySource: "physical-name",
+		physicalName,
+		parent: {
+			kind: "table",
+			id: parent.id
+		},
+		strategy,
+		...expression === void 0 ? {} : { keyColumns: partitionKeyColumns(expression) },
+		...boundText === void 0 ? {} : { bound: sql(boundText, namespace, parent, physicalName) },
+		reference: physicalReference,
+		dialect: extension({
+			...text(row.partition_method) === void 0 ? {} : { partitionMethod: text(row.partition_method) },
+			...text(row.subpartition_method) === void 0 ? {} : { subpartitionMethod: text(row.subpartition_method) },
+			...text(row.subpartition_name) === void 0 ? {} : { subpartitionName: text(row.subpartition_name) },
+			...text(row.tablespace_name) === void 0 ? {} : { tablespace: text(row.tablespace_name) }
+		})
+	};
+	const commentText = text(row.partition_comment);
+	if (commentText === void 0 || commentText === "") return partition;
+	return {
+		...partition,
+		comment: objectComment({
+			kind: "partition",
+			id: partition.id
+		}, commentText, physicalReference, namespace)
+	};
+}
+function collationObject(row, namespace) {
+	const physicalName = text(row.collation_name) ?? "unknown_collation";
+	return {
+		kind: "collation",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		reference: reference("collation", physicalName, namespace, "INFORMATION_SCHEMA.COLLATIONS", "COLLATION_NAME"),
+		dialect: extension({
+			...text(row.character_set_name) === void 0 ? {} : { characterSet: text(row.character_set_name) },
+			...number(row.collation_id) === void 0 ? {} : { id: number(row.collation_id) },
+			...text(row.is_default) === void 0 ? {} : { isDefault: text(row.is_default) === "Yes" },
+			...text(row.is_compiled) === void 0 ? {} : { isCompiled: text(row.is_compiled) === "Yes" },
+			...number(row.sort_length) === void 0 ? {} : { sortLength: number(row.sort_length) },
+			...text(row.pad_attribute) === void 0 ? {} : { padAttribute: text(row.pad_attribute) }
+		})
+	};
+}
+function opaqueEvent(row, namespace) {
+	const physicalName = text(row.event_name) ?? "unnamed_event";
+	const physicalReference = reference("opaque-object", physicalName, namespace, "INFORMATION_SCHEMA.EVENTS", "EVENT_NAME");
+	const definition = text(row.event_definition) ?? text(row.event_body);
+	return {
+		kind: "opaque-object",
+		id: stableId(`event:${physicalName}`),
+		identitySource: "physical-name",
+		objectKind: "event",
+		physicalName,
+		data: {
+			...text(row.event_type) === void 0 ? {} : { eventType: text(row.event_type) },
+			...text(row.status) === void 0 ? {} : { status: text(row.status) },
+			...text(row.execute_at) === void 0 ? {} : { executeAt: text(row.execute_at) },
+			...text(row.interval_value) === void 0 ? {} : { intervalValue: text(row.interval_value) },
+			...text(row.interval_field) === void 0 ? {} : { intervalField: text(row.interval_field) },
+			...text(row.definer) === void 0 ? {} : { definer: text(row.definer) }
+		},
+		...definition === void 0 ? {} : { sql: sql(definition, namespace, {
+			kind: "opaque-object",
+			physicalName,
+			reference: physicalReference
+		}, physicalName) },
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "mysql",
+			reference: physicalReference
+		},
+		dialect: extension({ objectKind: "event" })
+	};
+}
+function objectComment(object, comment, physicalReference, namespace) {
+	return {
+		kind: "comment",
+		id: stableId(`${object.kind}_${object.id}_comment`),
+		object,
+		text: comment,
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "mysql",
+			reference: physicalReference,
+			path: ["namespace", namespace]
+		}
+	};
+}
+function groupRows(rows, keyOf) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const key = keyOf(row);
+		const group = groups.get(key) ?? [];
+		group.push(row);
+		groups.set(key, group);
+	}
+	return [...groups.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([, group]) => group);
+}
+function extension(data) {
+	return {
+		dialect: "mysql",
+		version: 1,
+		data
+	};
+}
+function storage(dataType, declaration) {
+	return { nativeType: text(declaration) ?? text(dataType) ?? "unknown" };
+}
+function normalizeCheckOption(value) {
+	const normalized = text(value)?.toLowerCase();
+	return normalized === "none" || normalized === void 0 ? normalized === void 0 ? void 0 : "none" : normalized === "local" ? "local" : normalized === "cascaded" ? "cascaded" : void 0;
+}
+function routineSecurity(value) {
+	return text(value)?.toLowerCase() === "invoker" ? "invoker" : text(value)?.toLowerCase() === "definer" ? "definer" : "unknown";
+}
+function routineParameterMode(value) {
+	const normalized = text(value)?.toLowerCase();
+	return normalized === "in" ? "in" : normalized === "out" ? "out" : normalized === "inout" ? "inout" : void 0;
+}
+function triggerTiming(value) {
+	const normalized = text(value)?.toLowerCase();
+	return normalized === "before" ? "before" : normalized === "after" ? "after" : "unknown";
+}
+function triggerEvent(value) {
+	const normalized = text(value)?.toLowerCase();
+	return normalized === "insert" || normalized === "update" || normalized === "delete" ? normalized : void 0;
+}
+function triggerOrientation(value) {
+	const normalized = text(value)?.toLowerCase();
+	return normalized === "row" ? "row" : normalized === "statement" ? "statement" : void 0;
+}
+function partitionStrategy(value) {
+	const normalized = value.toLowerCase();
+	return normalized === "range" ? "range" : normalized === "list" ? "list" : normalized === "hash" ? "hash" : "unknown";
+}
+function partitionKeyColumns(expression) {
+	return expression.split(",").map((value) => value.trim()).filter((value) => /^[A-Za-z_][A-Za-z0-9_$]*$/.test(value));
+}
+function sql(textValue, namespace, table, name) {
+	return {
+		kind: "sql",
+		dialect: "mysql",
+		text: textValue,
+		provenance: {
+			kind: "catalog",
+			dialect: "mysql",
+			reference: table.reference ?? reference(table.kind, name, namespace, "INFORMATION_SCHEMA", "TABLE_NAME", table.physicalName)
+		}
+	};
+}
+function reference(kind, name, namespace, relation, key, value = name) {
+	return {
+		kind,
+		name,
+		namespace,
+		catalog: {
+			relation,
+			key,
+			value
+		}
+	};
+}
+function literal(value, dataType) {
+	if (value === void 0) return;
+	if (value.toUpperCase() === "NULL") return null;
+	if (value.toUpperCase() === "TRUE") return true;
+	if (value.toUpperCase() === "FALSE") return false;
+	if (/^-?(?:\d+\.?\d*|\.\d+)$/.test(value)) return Number(value);
+	if (/^'(?:''|[^'])*'$/.test(value)) return value.slice(1, -1).replace(/''/g, "'");
+	if (value === "" || /^(?:char|varchar|text|tinytext|mediumtext|longtext|enum|set)$/i.test(dataType ?? "")) return value;
+}
+function emptyCatalog(namespace, diagnostics) {
+	return {
+		dialect: "mysql",
+		server: {
+			product: "mysql",
+			rawVersion: "unknown",
+			capabilities: {
+				generatedColumns: false,
+				identityMetadata: false,
+				checkConstraints: false,
+				checkConstraintEnforcement: "unknown",
+				expressionDecompilation: false,
+				indexExpressions: false,
+				indexPredicates: false,
+				indexIncludedColumns: false,
+				namespaces: true,
+				visibility: "unknown"
+			}
+		},
+		namespace: {
+			kind: "mysql-database",
+			name: namespace
+		},
+		tables: [],
+		deferredObjects: [],
+		diagnostics
+	};
+}
+function stableId(value) {
+	if (value && !/[.\\\u0000-\u001f\u007f]/.test(value)) return value;
+	let hash = 2166136261;
+	for (const character of value) {
+		hash ^= character.charCodeAt(0);
+		hash = Math.imul(hash, 16777619);
+	}
+	return `introspected_${(hash >>> 0).toString(16)}`;
+}
+function text(value) {
+	return value === null || value === void 0 ? void 0 : String(value);
+}
+function number(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const result = Number(value);
+		return Number.isFinite(result) ? result : void 0;
+	}
+}
+function action(value) {
+	const normalized = text(value)?.toLowerCase();
+	return normalized === "cascade" ? "cascade" : normalized === "restrict" ? "restrict" : normalized === "set null" ? "set-null" : normalized === "set default" ? "set-default" : "no-action";
+}
+function match(value) {
+	return text(value)?.toLowerCase() === "full" ? "full" : "simple";
+}
+//#endregion
+export { mysqlChecksQuery, mysqlCollationsQuery, mysqlColumnsQuery, mysqlEventsQuery, mysqlKeyUsageQuery, mysqlPartitionsQuery, mysqlRoutineParametersQuery, mysqlRoutinesQuery, mysqlServerQuery, mysqlStatisticsQuery, mysqlTablesQuery, mysqlTriggersQuery, mysqlViewsQuery, readCatalog };