@pvidaal07/heydb 0.0.0-stage → 2.0.0-beta.1

package/lib/engines/mysql/catalog.ts

@@ -0,0 +1,371 @@
+import { formatName } from "../../model/names.ts";
+import { sortSnapshot } from "../../model/order.ts";
+import type {
+	Column,
+	Database,
+	ForeignKey,
+	Index,
+	ReferentialAction,
+	Routine,
+	Snapshot,
+	Table,
+	Trigger,
+	Warning,
+} from "../../model/snapshot.ts";
+
+// Pure translation from MySQL/MariaDB catalog rows to a Snapshot. It never
+// talks to a server: introspect.ts runs the queries and hands the rows here,
+// so every rule below is tested with hand-written rows and no database.
+//
+// Row field names match the aliases used in introspect.ts queries.
+
+export interface MysqlCatalog {
+	/** Result of SELECT VERSION(), e.g. "8.0.36" or "10.6.18-MariaDB". */
+	readonly version: string;
+	readonly capturedAt: string;
+	/** Databases the caller asked for; null means "every visible database". */
+	readonly requestedDatabases: readonly string[] | null;
+	/** Databases actually captured (visible and requested). */
+	readonly databases: readonly string[];
+	readonly tables: readonly TableRow[];
+	readonly columns: readonly ColumnRow[];
+	readonly indexColumns: readonly IndexColumnRow[];
+	readonly foreignKeyColumns: readonly ForeignKeyColumnRow[];
+	readonly triggers: readonly TriggerRow[];
+	readonly routines: readonly RoutineRow[];
+	readonly views: readonly ViewRow[];
+	/** The current user's own privileges, global (databaseName null) or per database. */
+	readonly privileges: readonly PrivilegeRow[];
+}
+
+export interface TableRow {
+	readonly databaseName: string;
+	readonly tableName: string;
+	/** "BASE TABLE", "VIEW", or MariaDB's "SYSTEM VERSIONED". */
+	readonly tableType: string;
+	readonly storageEngine: string | null;
+	readonly tableRows: number | string | null;
+	readonly tableComment: string | null;
+}
+
+export interface ColumnRow {
+	readonly databaseName: string;
+	readonly tableName: string;
+	readonly columnName: string;
+	readonly position: number;
+	readonly columnType: string;
+	readonly isNullable: string;
+	readonly columnDefault: string | null;
+	readonly columnComment: string | null;
+	readonly extra: string | null;
+	readonly collation: string | null;
+	readonly generationExpression: string | null;
+}
+
+export interface IndexColumnRow {
+	readonly databaseName: string;
+	readonly tableName: string;
+	readonly indexName: string;
+	readonly sequence: number;
+	/** null for a functional index part (MySQL 8.0.13+). */
+	readonly columnName: string | null;
+	readonly nonUnique: number | string;
+	readonly indexType: string;
+}
+
+export interface ForeignKeyColumnRow {
+	readonly databaseName: string;
+	readonly tableName: string;
+	readonly constraintName: string;
+	readonly position: number;
+	readonly columnName: string;
+	readonly referencedDatabase: string;
+	readonly referencedTable: string;
+	readonly referencedColumn: string;
+	readonly updateRule: string;
+	readonly deleteRule: string;
+}
+
+export interface TriggerRow {
+	readonly databaseName: string;
+	readonly tableName: string;
+	readonly triggerName: string;
+	readonly timing: string;
+	readonly event: string;
+}
+
+export interface RoutineRow {
+	readonly databaseName: string;
+	readonly routineName: string;
+	readonly routineType: string;
+}
+
+export interface ViewRow {
+	readonly databaseName: string;
+	readonly tableName: string;
+	/** Empty (or null) when the user lacks SHOW VIEW on the view. */
+	readonly viewDefinition: string | null;
+}
+
+export interface PrivilegeRow {
+	readonly databaseName: string | null;
+	readonly privilege: string;
+}
+
+const REFERENTIAL_ACTIONS: readonly ReferentialAction[] = ["CASCADE", "SET NULL", "SET DEFAULT", "RESTRICT", "NO ACTION"];
+
+// INFORMATION_SCHEMA only lists the triggers and routines the user is allowed
+// to see. Without these privileges the lists come back empty with no error,
+// so heydb warns instead of presenting an incomplete picture as complete.
+const TRIGGER_PRIVILEGES = { global: ["TRIGGER"], database: ["TRIGGER"] };
+const ROUTINE_PRIVILEGES = {
+	global: ["SHOW_ROUTINE", "EXECUTE", "ALTER ROUTINE", "CREATE ROUTINE"],
+	// SHOW_ROUTINE (MySQL 8.0.20+) can only be granted globally.
+	database: ["EXECUTE", "ALTER ROUTINE", "CREATE ROUTINE"],
+};
+
+export function buildSnapshot(catalog: MysqlCatalog): Snapshot {
+	const isMariaDb = catalog.version.toLowerCase().includes("mariadb");
+	const captured = new Set(catalog.databases);
+	const inCapturedDatabase = (row: { databaseName: string }) => captured.has(row.databaseName);
+
+	// Group every kind of row by its table once, so building each table is a lookup.
+	const columnsByTable = groupBy(catalog.columns.filter(inCapturedDatabase), tableKey);
+	const indexesByTable = groupBy(catalog.indexColumns.filter(inCapturedDatabase), tableKey);
+	const foreignKeysByTable = groupBy(catalog.foreignKeyColumns.filter(inCapturedDatabase), tableKey);
+	const triggersByTable = groupBy(catalog.triggers.filter(inCapturedDatabase), tableKey);
+	const tablesByDatabase = groupBy(catalog.tables.filter(inCapturedDatabase), (row) => row.databaseName);
+	const routinesByDatabase = groupBy(catalog.routines.filter(inCapturedDatabase), (row) => row.databaseName);
+	const definitionsByView = new Map(catalog.views.map((row) => [tableKey(row), row.viewDefinition]));
+
+	const databases: Database[] = [...captured].sort().map((name) => ({
+		name,
+		schemas: [
+			{
+				name,
+				tables: (tablesByDatabase.get(name) ?? []).map((row) => {
+					const key = tableKey(row);
+					return buildTable(
+						row,
+						columnsByTable.get(key) ?? [],
+						indexesByTable.get(key) ?? [],
+						foreignKeysByTable.get(key) ?? [],
+						triggersByTable.get(key) ?? [],
+						definitionsByView.get(key) ?? null,
+						isMariaDb,
+					);
+				}),
+				routines: (routinesByDatabase.get(name) ?? []).map(buildRoutine),
+			},
+		],
+	}));
+
+	// Return the canonical order so every consumer sees the same snapshot,
+	// whatever order the server returned the rows in.
+	return sortSnapshot({
+		formatVersion: 1,
+		engine: { kind: isMariaDb ? "mariadb" : "mysql", version: catalog.version },
+		capturedAt: catalog.capturedAt,
+		databases,
+		warnings: [
+			...missingDatabaseWarnings(catalog.requestedDatabases, captured),
+			...hiddenObjectWarnings([...captured], catalog.privileges),
+			...hiddenViewDefinitionWarnings(databases),
+		],
+	});
+}
+
+function buildTable(
+	row: TableRow,
+	columnRows: readonly ColumnRow[],
+	indexRows: readonly IndexColumnRow[],
+	foreignKeyRows: readonly ForeignKeyColumnRow[],
+	triggerRows: readonly TriggerRow[],
+	viewDefinition: string | null,
+	isMariaDb: boolean,
+): Table {
+	const isView = row.tableType === "VIEW";
+	const primaryKeyRows = indexRows.filter((r) => r.indexName === "PRIMARY");
+	return {
+		name: row.tableName,
+		kind: isView ? "view" : "table",
+		// MySQL reports the comment "VIEW" for every view: it is not a real comment.
+		comment: isView ? "" : (row.tableComment ?? ""),
+		storageEngine: row.storageEngine,
+		rowEstimate: isView || row.tableRows === null ? null : Number(row.tableRows),
+		columns: [...columnRows].sort((a, b) => a.position - b.position).map((c) => buildColumn(c, isMariaDb)),
+		primaryKey: [...primaryKeyRows].sort((a, b) => a.sequence - b.sequence).map(indexPartName),
+		indexes: buildIndexes(indexRows.filter((r) => r.indexName !== "PRIMARY")),
+		foreignKeys: buildForeignKeys(foreignKeyRows),
+		triggers: buildTriggers(triggerRows),
+		// An empty definition is not an empty SELECT: the server hid it.
+		viewDefinition: isView && viewDefinition ? viewDefinition : null,
+	};
+}
+
+function buildColumn(row: ColumnRow, isMariaDb: boolean): Column {
+	const extra = (row.extra ?? "").toUpperCase();
+	const generatedKind = /\b(VIRTUAL|STORED|PERSISTENT) GENERATED\b/.exec(extra)?.[1];
+	return {
+		name: row.columnName,
+		position: row.position,
+		type: row.columnType,
+		nullable: row.isNullable === "YES",
+		// MariaDB 10.2.7+ reports "no default" as the text NULL; MySQL uses a real NULL.
+		default: isMariaDb && row.columnDefault === "NULL" ? null : row.columnDefault,
+		comment: row.columnComment ?? "",
+		autoIncrement: extra.includes("AUTO_INCREMENT"),
+		generated:
+			generatedKind === undefined
+				? null
+				: { expression: row.generationExpression ?? "", stored: generatedKind !== "VIRTUAL" },
+		collation: row.collation,
+	};
+}
+
+function buildIndexes(rows: readonly IndexColumnRow[]): Index[] {
+	return [...groupBy(rows, (r) => r.indexName)].map(([name, parts]) => {
+		const sorted = [...parts].sort((a, b) => a.sequence - b.sequence);
+		const first = sorted[0]!; // groupBy never creates empty groups
+		return {
+			name,
+			columns: sorted.map(indexPartName),
+			unique: Number(first.nonUnique) === 0,
+			method: first.indexType,
+		};
+	});
+}
+
+function indexPartName(row: IndexColumnRow): string {
+	return row.columnName ?? "(expression)";
+}
+
+function buildForeignKeys(rows: readonly ForeignKeyColumnRow[]): ForeignKey[] {
+	return [...groupBy(rows, (r) => r.constraintName)].map(([name, parts]) => {
+		const sorted = [...parts].sort((a, b) => a.position - b.position);
+		const first = sorted[0]!;
+		const where = `${first.databaseName}.${first.tableName}.${name}`;
+		return {
+			name,
+			columns: sorted.map((r) => r.columnName),
+			references: {
+				database: first.referencedDatabase,
+				schema: first.referencedDatabase,
+				table: first.referencedTable,
+				columns: sorted.map((r) => r.referencedColumn),
+			},
+			onDelete: referentialAction(first.deleteRule, where),
+			onUpdate: referentialAction(first.updateRule, where),
+		};
+	});
+}
+
+function referentialAction(rule: string, where: string): ReferentialAction {
+	const action = REFERENTIAL_ACTIONS.find((candidate) => candidate === rule.toUpperCase());
+	if (action === undefined) throw new Error(`unknown foreign key rule "${rule}" on ${where}`);
+	return action;
+}
+
+function buildTriggers(rows: readonly TriggerRow[]): Trigger[] {
+	// MySQL and MariaDB triggers fire on exactly one event each.
+	return rows.map((row) => ({
+		name: row.triggerName,
+		timing: row.timing.toUpperCase() === "AFTER" ? "AFTER" : "BEFORE",
+		events: [row.event.toUpperCase() as Trigger["events"][number]],
+	}));
+}
+
+function buildRoutine(row: RoutineRow): Routine {
+	return { name: row.routineName, kind: row.routineType.toUpperCase() === "FUNCTION" ? "function" : "procedure" };
+}
+
+function missingDatabaseWarnings(requested: readonly string[] | null, captured: ReadonlySet<string>): Warning[] {
+	return [...new Set(requested ?? [])]
+		.filter((name) => !captured.has(name))
+		.map((name) => ({
+			code: "database_not_visible",
+			message: `database "${name}" does not exist or the user has no privileges on it`,
+			target: name,
+		}));
+}
+
+function hiddenObjectWarnings(databases: readonly string[], privileges: readonly PrivilegeRow[]): Warning[] {
+	const has = (database: string, allowed: { global: string[]; database: string[] }) =>
+		privileges.some((p) => {
+			const privilege = p.privilege.toUpperCase();
+			if (p.databaseName === null) return allowed.global.includes(privilege);
+			return allowed.database.includes(privilege) && grantMatches(p.databaseName, database);
+		});
+
+	const warnings: Warning[] = [];
+	for (const database of databases) {
+		if (!has(database, TRIGGER_PRIVILEGES)) {
+			warnings.push({
+				code: "triggers_hidden",
+				message: `triggers in "${database}" are only listed with the TRIGGER privilege; the list may be incomplete`,
+				target: database,
+			});
+		}
+		if (!has(database, ROUTINE_PRIVILEGES)) {
+			warnings.push({
+				code: "routines_hidden",
+				message: `routines in "${database}" are only listed with the SHOW_ROUTINE, EXECUTE, ALTER ROUTINE or CREATE ROUTINE privilege; the list may be incomplete`,
+				target: database,
+			});
+		}
+	}
+	return warnings;
+}
+
+// Without SHOW VIEW on a view, INFORMATION_SCHEMA.VIEWS still lists it but with
+// an empty definition, so the warning is per view and needs no privilege check.
+function hiddenViewDefinitionWarnings(databases: readonly Database[]): Warning[] {
+	return databases.flatMap((database) =>
+		database.schemas.flatMap((schema) =>
+			schema.tables
+				.filter((table) => table.kind === "view" && table.viewDefinition === null)
+				.map((view) => ({
+					code: "view_definition_hidden",
+					message: `definition of view "${database.name}.${view.name}" is only visible with the SHOW VIEW privilege`,
+					target: formatName({ database: database.name, schema: schema.name, table: view.name }),
+				})),
+		),
+	);
+}
+
+// Database-level grants may use LIKE wildcards: "_" is any character, "%" any
+// sequence, and a backslash makes the next character literal. The grant
+// shop\_% covers "shop_es" but not "shopXes".
+function grantMatches(pattern: string, database: string): boolean {
+	let regex = "^";
+	for (let index = 0; index < pattern.length; index += 1) {
+		const char = pattern[index]!;
+		if (char === "\\" && index + 1 < pattern.length) {
+			index += 1;
+			regex += escapeRegExp(pattern[index]!);
+		} else if (char === "_") regex += ".";
+		else if (char === "%") regex += ".*";
+		else regex += escapeRegExp(char);
+	}
+	return new RegExp(`${regex}$`, "s").test(database);
+}
+
+function escapeRegExp(text: string): string {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function tableKey(row: { databaseName: string; tableName: string }): string {
+	// \u0000 cannot appear in identifiers, so the key is unambiguous.
+	return `${row.databaseName}\u0000${row.tableName}`;
+}
+
+function groupBy<T>(items: readonly T[], keyOf: (item: T) => string): Map<string, T[]> {
+	const groups = new Map<string, T[]>();
+	for (const item of items) {
+		const key = keyOf(item);
+		const group = groups.get(key);
+		if (group === undefined) groups.set(key, [item]);
+		else group.push(item);
+	}
+	return groups;
+}

package/lib/engines/mysql/introspect.ts

@@ -0,0 +1,186 @@
+import mysql, { type Connection, type RowDataPacket } from "mysql2/promise";
+
+import type { Snapshot } from "../../model/snapshot.ts";
+import {
+	buildSnapshot,
+	type ColumnRow,
+	type ForeignKeyColumnRow,
+	type IndexColumnRow,
+	type PrivilegeRow,
+	type RoutineRow,
+	type TableRow,
+	type TriggerRow,
+	type ViewRow,
+} from "./catalog.ts";
+
+// Reads the structure of a MySQL or MariaDB server through INFORMATION_SCHEMA.
+// One query per kind of object for ALL captured databases at once (never one
+// query per table), so the cost grows with the number of object kinds, not
+// with the number of tables. The rows go to catalog.ts, which builds the
+// snapshot without touching the server.
+
+export interface MysqlConnectionOptions {
+	readonly host: string;
+	readonly port: number;
+	readonly user: string;
+	/** The resolved password. Callers resolve secret references before this point. */
+	readonly password: string;
+	/** Databases to capture; null or omitted captures every visible user database. */
+	readonly databases?: readonly string[] | null;
+	readonly connectTimeoutMs?: number;
+}
+
+const SYSTEM_DATABASES = ["information_schema", "mysql", "performance_schema", "sys"];
+
+// GRANTEE looks like 'user'@'host'. An admin sees every user's privileges, so
+// filter to the account this session is authenticated as. CHAR(39) is a single
+// quote: writing it as "'" would break on servers running with ANSI_QUOTES,
+// where double quotes delimit names, not text.
+const CURRENT_GRANTEE =
+	"CONCAT(CHAR(39), SUBSTRING_INDEX(CURRENT_USER(), '@', 1), CHAR(39), '@', CHAR(39), SUBSTRING_INDEX(CURRENT_USER(), '@', -1), CHAR(39))";
+
+export async function introspectMysql(options: MysqlConnectionOptions): Promise<Snapshot> {
+	const connection = await connectReadOnly(options);
+	try {
+		const capturedAt = new Date().toISOString();
+		const [versionRows] = await connection.query<RowDataPacket[]>("SELECT VERSION() AS version");
+		const version = String(versionRows[0]?.version ?? "");
+
+		const requested = options.databases ?? null;
+		const visible = await visibleDatabases(connection);
+		const databases = requested === null ? visible : visible.filter((name) => requested.includes(name));
+
+		const empty = {
+			tables: [],
+			columns: [],
+			indexColumns: [],
+			foreignKeyColumns: [],
+			triggers: [],
+			routines: [],
+			views: [],
+			privileges: [],
+		};
+		const rows = databases.length === 0 ? empty : await readCatalog(connection, databases);
+
+		return buildSnapshot({ version, capturedAt, requestedDatabases: requested, databases, ...rows });
+	} finally {
+		await connection.end();
+	}
+}
+
+/**
+ * Opens a connection whose session is READ ONLY: even a user with write
+ * privileges cannot change data or tables through it (INSERT, UPDATE, DROP,
+ * CALL of a writing procedure all fail). It does not block SET GLOBAL; heydb
+ * only ever sends fixed SELECT statements. Defense in depth on top of
+ * recommending a read-only database user.
+ */
+export async function connectReadOnly(options: MysqlConnectionOptions): Promise<Connection> {
+	let connection: Connection;
+	try {
+		connection = await mysql.createConnection({
+			host: options.host,
+			port: options.port,
+			user: options.user,
+			password: options.password,
+			connectTimeout: options.connectTimeoutMs ?? 10_000,
+			multipleStatements: false,
+			supportBigNumbers: true,
+		});
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		throw new Error(`mysql: cannot connect to ${options.host}:${options.port} as ${options.user}: ${reason}`, {
+			cause: error,
+		});
+	}
+	try {
+		// A neutral sql_mode makes the output independent of how the server is
+		// configured: MariaDB prints generated-column expressions with " instead of `
+		// under ANSI_QUOTES, and NO_BACKSLASH_ESCAPES would break the driver's escaping
+		// of query parameters. It only affects this session.
+		await connection.query("SET SESSION sql_mode = ''");
+		await connection.query("SET SESSION TRANSACTION READ ONLY");
+	} catch (error) {
+		// Never leave a half-configured connection open: it would keep the process alive.
+		connection.destroy();
+		const reason = error instanceof Error ? error.message : String(error);
+		throw new Error(`mysql: cannot open a read-only session on ${options.host}:${options.port}: ${reason}`, {
+			cause: error,
+		});
+	}
+	return connection;
+}
+
+async function visibleDatabases(connection: Connection): Promise<string[]> {
+	const [rows] = await connection.query<RowDataPacket[]>(
+		"SELECT SCHEMA_NAME AS name FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME NOT IN (?) ORDER BY SCHEMA_NAME",
+		[SYSTEM_DATABASES],
+	);
+	return rows.map((row) => String(row.name));
+}
+
+async function readCatalog(connection: Connection, databases: readonly string[]) {
+	// mysql2 expands an array bound to "IN (?)" into a list of escaped values.
+	const select = async <T>(sql: string): Promise<T[]> => {
+		const [rows] = await connection.query<RowDataPacket[]>(sql, [databases]);
+		return rows as unknown as T[];
+	};
+
+	// One connection runs these one after another; Promise.all just waits for all of them.
+	const [tables, columns, indexColumns, foreignKeyColumns, triggers, routines, views, privileges] = await Promise.all([
+		select<TableRow>(`
+			SELECT TABLE_SCHEMA AS databaseName, TABLE_NAME AS tableName, TABLE_TYPE AS tableType,
+			       ENGINE AS storageEngine, TABLE_ROWS AS tableRows, TABLE_COMMENT AS tableComment
+			FROM INFORMATION_SCHEMA.TABLES
+			WHERE TABLE_SCHEMA IN (?)`),
+		select<ColumnRow>(`
+			SELECT TABLE_SCHEMA AS databaseName, TABLE_NAME AS tableName, COLUMN_NAME AS columnName,
+			       ORDINAL_POSITION AS position, COLUMN_TYPE AS columnType, IS_NULLABLE AS isNullable,
+			       COLUMN_DEFAULT AS columnDefault, COLUMN_COMMENT AS columnComment, EXTRA AS extra,
+			       COLLATION_NAME AS collation, GENERATION_EXPRESSION AS generationExpression
+			FROM INFORMATION_SCHEMA.COLUMNS
+			WHERE TABLE_SCHEMA IN (?)`),
+		select<IndexColumnRow>(`
+			SELECT TABLE_SCHEMA AS databaseName, TABLE_NAME AS tableName, INDEX_NAME AS indexName,
+			       SEQ_IN_INDEX AS sequence, COLUMN_NAME AS columnName, NON_UNIQUE AS nonUnique,
+			       INDEX_TYPE AS indexType
+			FROM INFORMATION_SCHEMA.STATISTICS
+			WHERE TABLE_SCHEMA IN (?)`),
+		select<ForeignKeyColumnRow>(`
+			SELECT k.TABLE_SCHEMA AS databaseName, k.TABLE_NAME AS tableName, k.CONSTRAINT_NAME AS constraintName,
+			       k.ORDINAL_POSITION AS position, k.COLUMN_NAME AS columnName,
+			       k.REFERENCED_TABLE_SCHEMA AS referencedDatabase, k.REFERENCED_TABLE_NAME AS referencedTable,
+			       k.REFERENCED_COLUMN_NAME AS referencedColumn,
+			       r.UPDATE_RULE AS updateRule, r.DELETE_RULE AS deleteRule
+			FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE k
+			JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS r
+			  ON r.CONSTRAINT_SCHEMA = k.CONSTRAINT_SCHEMA
+			 AND r.CONSTRAINT_NAME = k.CONSTRAINT_NAME
+			 AND r.TABLE_NAME = k.TABLE_NAME
+			WHERE k.TABLE_SCHEMA IN (?) AND k.REFERENCED_TABLE_NAME IS NOT NULL`),
+		select<TriggerRow>(`
+			SELECT EVENT_OBJECT_SCHEMA AS databaseName, EVENT_OBJECT_TABLE AS tableName,
+			       TRIGGER_NAME AS triggerName, ACTION_TIMING AS timing, EVENT_MANIPULATION AS event
+			FROM INFORMATION_SCHEMA.TRIGGERS
+			WHERE EVENT_OBJECT_SCHEMA IN (?)`),
+		select<RoutineRow>(`
+			SELECT ROUTINE_SCHEMA AS databaseName, ROUTINE_NAME AS routineName, ROUTINE_TYPE AS routineType
+			FROM INFORMATION_SCHEMA.ROUTINES
+			WHERE ROUTINE_SCHEMA IN (?)`),
+		select<ViewRow>(`
+			SELECT TABLE_SCHEMA AS databaseName, TABLE_NAME AS tableName, VIEW_DEFINITION AS viewDefinition
+			FROM INFORMATION_SCHEMA.VIEWS
+			WHERE TABLE_SCHEMA IN (?)`),
+		// For a non-admin user both views list only that user's own privileges.
+		select<PrivilegeRow>(`
+			SELECT NULL AS databaseName, PRIVILEGE_TYPE AS privilege
+			FROM INFORMATION_SCHEMA.USER_PRIVILEGES
+			WHERE GRANTEE = ${CURRENT_GRANTEE}
+			UNION ALL
+			SELECT TABLE_SCHEMA AS databaseName, PRIVILEGE_TYPE AS privilege
+			FROM INFORMATION_SCHEMA.SCHEMA_PRIVILEGES
+			WHERE GRANTEE = ${CURRENT_GRANTEE} AND TABLE_SCHEMA IN (?)`),
+	]);
+
+	return { tables, columns, indexColumns, foreignKeyColumns, triggers, routines, views, privileges };
+}