qubu 0.4.2 → 0.5.0

package/dist/mysql-B_cYzzX2.mjs

@@ -1,585 +0,0 @@
-import { P as isValidSchemaObjectName, r as isColumnReference } from "./column-hqKr7-1I.mjs";
-import { _ as isUnsafeSchemaSql, m as validateConstraintDialect, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-BRMLYwDp.mjs";
-import { t as createSchemaDialect } from "./dialect-wUKrnPMB.mjs";
-import { a as toSnapshotJsonValue } from "./canonical-BXUguqfo.mjs";
-import { c as createSchemaSnapshot, p as tryCreateSchemaSnapshot } from "./sqlite-Cg0nwYEH.mjs";
-import { postgresDialect } from "./postgres.mjs";
-import { mysqlDialect } from "./mysql.mjs";
-//#region src/snapshot/postgres.ts
-/** PostgreSQL's v1 snapshot extension identity. */
-const postgresSnapshotDialect = Object.freeze({
-	name: "postgresql",
-	version: 1
-});
-var PostgresSnapshotDialectError = class extends TypeError {
-	code = "dialect-mismatch";
-};
-const postgresStorageTypes = Object.freeze({
-	integer: "INTEGER",
-	numeric: "NUMERIC",
-	text: "TEXT",
-	boolean: "BOOLEAN",
-	date: "DATE",
-	timestamp: "TIMESTAMP",
-	uuid: "UUID",
-	json: "JSONB",
-	bigint: "BIGINT",
-	binary: "BYTEA"
-});
-/** PostgreSQL's query dialect plus its schema metadata behavior. */
-const postgresSchemaDialect = createSchemaDialect(postgresDialect(), {
-	version: 1,
-	validate: validatePostgresSchema,
-	encodeStorage(storage, context) {
-		return encodePostgresStorage(storage, context.dialect);
-	},
-	encodeExpression(expression, context) {
-		return encodePostgresExpression(expression, context.mode, context.dialect);
-	},
-	encodeDialectExtension(extension, context) {
-		return encodePostgresExtension(extension, context.dialect);
-	}
-});
-/** Snapshot adapter retaining the historical adapter-shaped entry point. */
-const postgresSnapshotAdapter = Object.freeze({ dialect: postgresSchemaDialect });
-/** Create a canonical PostgreSQL schema snapshot. */
-function createPostgresSchemaSnapshot(schema, options = {}) {
-	return createSchemaSnapshot(schema, {
-		...options,
-		adapter: postgresSnapshotAdapter
-	});
-}
-/** Return PostgreSQL capability diagnostics without throwing. */
-function tryCreatePostgresSchemaSnapshot(schema, options = {}) {
-	return tryCreateSchemaSnapshot(schema, {
-		...options,
-		adapter: postgresSnapshotAdapter
-	});
-}
-function encodePostgresStorage(storage, dialect) {
-	if (storage.kind === "native") {
-		if (storage.dialect !== dialect.name) throw new TypeError(`PostgreSQL storage cannot encode a native declaration owned by "${storage.dialect}"`);
-		if (storage.type.trim().length === 0) throw new TypeError("PostgreSQL native storage declarations cannot be empty");
-		return {
-			kind: "native",
-			dialect: dialect.name,
-			type: storage.type
-		};
-	}
-	const type = postgresStorageTypes[storage.type];
-	if (type === void 0) throw new TypeError(`Unsupported portable storage type for PostgreSQL: ${String(storage.type)}`);
-	return {
-		kind: "native",
-		dialect: dialect.name,
-		type
-	};
-}
-function encodePostgresExpression(expression, mode, dialect) {
-	if (isUnsafeSchemaSql(expression) && expression.schemaSqlDialect !== dialect.name) throw new PostgresSnapshotDialectError(`Schema SQL is tagged for "${expression.schemaSqlDialect}" but the PostgreSQL schema dialect is "${dialect.name}"`);
-	const rendered = renderSchemaExpression(expression, {
-		mode,
-		dialect
-	});
-	if (rendered.parameters.length !== 0) throw new TypeError("PostgreSQL schema expressions must be parameter-free");
-	return {
-		kind: "expression",
-		expressionKind: expression.expressionKind,
-		sql: rendered.text,
-		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
-	};
-}
-function encodePostgresExtension(extension, dialect) {
-	if (extension.dialect !== dialect.name) throw new TypeError(`PostgreSQL schema extensions require dialect "${dialect.name}"`);
-	const data = Object.fromEntries(Object.entries(extension).filter(([key]) => key !== "dialect").sort(([left], [right]) => left.localeCompare(right)));
-	return {
-		dialect: dialect.name,
-		version: dialect.schema.version,
-		data: sortSnapshotJson$1(toSnapshotJsonValue(data))
-	};
-}
-function sortSnapshotJson$1(value) {
-	if (Array.isArray(value)) return value.map(sortSnapshotJson$1);
-	if (typeof value !== "object" || value === null) return value;
-	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortSnapshotJson$1(child)]));
-}
-function validatePostgresSchema(schema, context) {
-	const diagnostics = [];
-	const tableEntries = Object.entries(schema.registry).sort(([left], [right]) => compareIds$1(left, right));
-	const relationNames = /* @__PURE__ */ new Map();
-	if (schema.namespace !== void 0) validatePostgresName(schema.namespace, ["namespace"], "PostgreSQL namespace", diagnostics);
-	for (const [id, entry] of tableEntries) {
-		const tablePath = ["tables", id];
-		validatePostgresName(entry.physicalName, [...tablePath, "physicalName"], "PostgreSQL table", diagnostics);
-		addRelationName(relationNames, entry.physicalName, [...tablePath, "physicalName"], "table", diagnostics);
-	}
-	for (const [id, entry] of tableEntries) validatePostgresTable(id, entry, context, relationNames, diagnostics);
-	return Object.freeze(diagnostics);
-}
-function validatePostgresTable(tableId, entry, context, relationNames, diagnostics) {
-	const table = entry.table;
-	const tablePath = ["tables", tableId];
-	const definitions = table.definitions;
-	for (const [columnId, definition] of Object.entries(definitions).sort(([left], [right]) => compareIds$1(left, right))) {
-		validatePostgresName(table.sqlNames[columnId] ?? columnId, [
-			...tablePath,
-			"columns",
-			columnId,
-			"physicalName"
-		], "PostgreSQL column", diagnostics);
-		if (definition.onUpdate !== void 0) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "MySQL ON UPDATE expressions are not supported by PostgreSQL",
-			path: [
-				...tablePath,
-				"columns",
-				columnId,
-				"onUpdate"
-			]
-		});
-		const generated = definition.generatedColumn;
-		if (generated !== void 0 && generated.kind === "expression" && generated.mode === "virtual") diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "PostgreSQL v1 snapshots support stored generated columns only; virtual generated columns are not supported",
-			path: [
-				...tablePath,
-				"columns",
-				columnId,
-				"generatedColumn",
-				"mode"
-			]
-		});
-	}
-	const metadata = table;
-	const constraintNames = /* @__PURE__ */ new Map();
-	const constraints = Object.entries(metadata.constraints);
-	for (const [constraintId, constraint] of constraints.sort(([left], [right]) => compareIds$1(left, right))) {
-		const constraintPath = [
-			...tablePath,
-			"constraints",
-			constraintId
-		];
-		const physicalName = constraint.physicalName ?? constraintId;
-		validatePostgresName(physicalName, [...constraintPath, "physicalName"], "PostgreSQL constraint", diagnostics);
-		addScopedName$1(constraintNames, physicalName, [...constraintPath, "physicalName"], "constraint", diagnostics);
-		appendMetadataDiagnostics$1(diagnostics, validateConstraintDialect(constraint, context.dialect.name, constraintPath));
-		if (constraint.kind === "check" && constraint.deferrable === true) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "PostgreSQL CHECK constraints cannot be DEFERRABLE",
-			path: [...constraintPath, "deferrable"]
-		});
-		if (constraint.kind === "foreign-key" && constraint.match === "partial") diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "PostgreSQL does not implement MATCH PARTIAL foreign keys",
-			path: [...constraintPath, "match"]
-		});
-		if (constraint.kind === "unique-constraint" && constraint.nulls === "not-distinct") diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "PostgreSQL NULLS NOT DISTINCT requires a server-version policy; the v1 adapter does not assume PostgreSQL 15 or newer",
-			path: [...constraintPath, "nulls"]
-		});
-	}
-	const indexes = Object.entries(metadata.indexes);
-	for (const [indexId, index] of indexes.sort(([left], [right]) => compareIds$1(left, right))) {
-		const indexPath = [
-			...tablePath,
-			"indexes",
-			indexId
-		];
-		const physicalName = index.physicalName ?? indexId;
-		validatePostgresName(physicalName, [...indexPath, "physicalName"], "PostgreSQL index", diagnostics);
-		addRelationName(relationNames, physicalName, [...indexPath, "physicalName"], "index", diagnostics);
-		appendMetadataDiagnostics$1(diagnostics, validateIndexDialect(index, context.dialect.name, indexPath));
-	}
-}
-function validatePostgresName(name, path, kind, diagnostics) {
-	if (!isValidSchemaObjectName(name) || name.length === 0) diagnostics.push({
-		code: "invalid-schema",
-		message: `${kind} name "${name}" is not a valid unqualified identifier`,
-		path
-	});
-	if (new TextEncoder().encode(name).length > 63) diagnostics.push({
-		code: "unsupported-dialect-option",
-		message: `${kind} name exceeds PostgreSQL's 63-byte identifier limit`,
-		path
-	});
-}
-function addRelationName(names, name, path, kind, diagnostics) {
-	addScopedName$1(names, name, path, kind, diagnostics);
-}
-function addScopedName$1(names, name, path, kind, diagnostics) {
-	const previousPath = names.get(name);
-	if (previousPath !== void 0) {
-		diagnostics.push({
-			code: "invalid-schema",
-			message: `PostgreSQL ${kind} name "${name}" collides with another relation or metadata object`,
-			path,
-			relatedPaths: [previousPath]
-		});
-		return;
-	}
-	names.set(name, path);
-}
-function appendMetadataDiagnostics$1(diagnostics, issues) {
-	for (const issue of issues) {
-		if (issue.code === "dialect-mismatch") continue;
-		diagnostics.push({
-			code: issue.code === "unsupported-dialect-option" ? "unsupported-dialect-option" : "invalid-schema",
-			message: issue.message,
-			path: issue.path,
-			...issue.relatedPaths === void 0 ? {} : { relatedPaths: issue.relatedPaths }
-		});
-	}
-}
-function compareIds$1(left, right) {
-	return left < right ? -1 : left > right ? 1 : 0;
-}
-//#endregion
-//#region src/snapshot/mysql.ts
-/** MySQL's v1 snapshot extension identity. */
-const mysqlSnapshotDialect = Object.freeze({
-	name: "mysql",
-	version: 1
-});
-var MysqlSnapshotDialectError = class extends TypeError {
-	code = "dialect-mismatch";
-};
-const mysqlStorageTypes = Object.freeze({
-	integer: "INT",
-	numeric: "DECIMAL",
-	text: "TEXT",
-	boolean: "BOOLEAN",
-	date: "DATE",
-	timestamp: "DATETIME",
-	uuid: "CHAR(36)",
-	json: "JSON",
-	bigint: "BIGINT",
-	binary: "VARBINARY"
-});
-/** MySQL's query dialect plus its schema metadata behavior. */
-const mysqlSchemaDialect = createSchemaDialect(mysqlDialect(), {
-	version: 1,
-	validate: validateMysqlSchema,
-	encodeStorage(storage, context) {
-		return encodeMysqlStorage(storage, context.dialect);
-	},
-	encodeExpression(expression, context) {
-		return encodeMysqlExpression(expression, context.mode, context.dialect);
-	},
-	encodeDialectExtension(extension, context) {
-		return encodeMysqlExtension(extension, context.dialect);
-	}
-});
-/** Snapshot adapter retaining the historical adapter-shaped entry point. */
-const mysqlSnapshotAdapter = Object.freeze({ dialect: mysqlSchemaDialect });
-/** Create a canonical MySQL schema snapshot. */
-function createMysqlSchemaSnapshot(schema, options = {}) {
-	return createSchemaSnapshot(schema, {
-		...options,
-		adapter: mysqlSnapshotAdapter
-	});
-}
-/** Return MySQL capability diagnostics without throwing. */
-function tryCreateMysqlSchemaSnapshot(schema, options = {}) {
-	return tryCreateSchemaSnapshot(schema, {
-		...options,
-		adapter: mysqlSnapshotAdapter
-	});
-}
-function encodeMysqlStorage(storage, dialect) {
-	if (storage.kind === "native") {
-		if (storage.dialect !== dialect.name) throw new MysqlSnapshotDialectError(`MySQL storage cannot encode a native declaration owned by "${storage.dialect}"`);
-		if (storage.type.trim().length === 0) throw new TypeError("MySQL native storage declarations cannot be empty");
-		return {
-			kind: "native",
-			dialect: dialect.name,
-			type: storage.type
-		};
-	}
-	const type = mysqlStorageTypes[storage.type];
-	if (type === void 0) throw new TypeError(`Unsupported portable storage type for MySQL: ${String(storage.type)}`);
-	return {
-		kind: "native",
-		dialect: dialect.name,
-		type
-	};
-}
-function encodeMysqlExpression(expression, mode, dialect) {
-	if (isUnsafeSchemaSql(expression) && expression.schemaSqlDialect !== dialect.name) throw new MysqlSnapshotDialectError(`Schema SQL is tagged for "${expression.schemaSqlDialect}" but the MySQL schema dialect is "${dialect.name}"`);
-	const rendered = renderSchemaExpression(expression, {
-		mode,
-		dialect
-	});
-	if (rendered.parameters.length !== 0) throw new TypeError("MySQL schema expressions must be parameter-free");
-	return {
-		kind: "expression",
-		expressionKind: expression.expressionKind,
-		sql: rendered.text,
-		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
-	};
-}
-function encodeMysqlExtension(extension, dialect) {
-	if (extension.dialect !== dialect.name) throw new MysqlSnapshotDialectError(`MySQL schema extensions require dialect "${dialect.name}"`);
-	const data = Object.fromEntries(Object.entries(extension).filter(([key]) => key !== "dialect").sort(([left], [right]) => left.localeCompare(right)));
-	return {
-		dialect: dialect.name,
-		version: dialect.schema.version,
-		data: sortSnapshotJson(toSnapshotJsonValue(data))
-	};
-}
-function sortSnapshotJson(value) {
-	if (Array.isArray(value)) return value.map(sortSnapshotJson);
-	if (typeof value !== "object" || value === null) return value;
-	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortSnapshotJson(child)]));
-}
-function validateMysqlSchema(schema, context) {
-	const diagnostics = [];
-	const tableEntries = Object.entries(schema.registry).sort(([left], [right]) => compareIds(left, right));
-	const relationNames = /* @__PURE__ */ new Map();
-	if (schema.namespace !== void 0) validateMysqlName(schema.namespace, ["namespace"], "MySQL database/schema", diagnostics);
-	for (const [id, entry] of tableEntries) {
-		const tablePath = ["tables", id];
-		validateMysqlName(entry.physicalName, [...tablePath, "physicalName"], "MySQL table", diagnostics);
-		addScopedName(relationNames, entry.physicalName, [...tablePath, "physicalName"], "table", diagnostics);
-	}
-	for (const [id, entry] of tableEntries) validateMysqlTable(id, entry, context, diagnostics);
-	return Object.freeze(diagnostics);
-}
-function validateMysqlTable(tableId, entry, context, diagnostics) {
-	const table = entry.table;
-	const tablePath = ["tables", tableId];
-	const definitions = table.definitions;
-	const metadata = table;
-	for (const [columnId, definition] of Object.entries(definitions).sort(([left], [right]) => compareIds(left, right))) {
-		const columnPath = [
-			...tablePath,
-			"columns",
-			columnId
-		];
-		validateMysqlName(table.sqlNames[columnId] ?? columnId, [...columnPath, "physicalName"], "MySQL column", diagnostics);
-		if (definition.onUpdate !== void 0 && definition.generatedColumn) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "MySQL generated columns cannot also declare ON UPDATE",
-			path: [...columnPath, "onUpdate"]
-		});
-		const extension = definition.identity?.dialect;
-		const autoIncrement = extension?.dialect === mysqlSnapshotDialect.name ? extension.autoIncrement : void 0;
-		if (extension?.dialect === mysqlSnapshotDialect.name && autoIncrement !== void 0 && typeof autoIncrement !== "boolean") diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "MySQL identity autoIncrement must be boolean",
-			path: [
-				...columnPath,
-				"identity",
-				"dialect",
-				"autoIncrement"
-			]
-		});
-		if (autoIncrement === true) validateMysqlAutoIncrement(columnId, definition, metadata, columnPath, diagnostics);
-	}
-	const constraintNames = /* @__PURE__ */ new Map();
-	const constraints = Object.entries(metadata.constraints);
-	for (const [constraintId, constraint] of constraints.sort(([left], [right]) => compareIds(left, right))) {
-		const constraintPath = [
-			...tablePath,
-			"constraints",
-			constraintId
-		];
-		const physicalName = constraint.physicalName ?? constraintId;
-		validateMysqlName(physicalName, [...constraintPath, "physicalName"], "MySQL constraint", diagnostics);
-		addScopedName(constraintNames, physicalName, [...constraintPath, "physicalName"], "constraint", diagnostics);
-		appendMetadataDiagnostics(diagnostics, validateConstraintDialect(constraint, context.dialect.name, constraintPath));
-		if (constraint.kind === "foreign-key" && (constraint.match === "full" || constraint.match === "partial")) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "MySQL v1 snapshots support MATCH SIMPLE foreign keys only",
-			path: [...constraintPath, "match"]
-		});
-		if (constraint.kind === "foreign-key" && (constraint.onUpdate === "set-default" || constraint.onDelete === "set-default")) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "MySQL does not support SET DEFAULT foreign-key actions",
-			path: [...constraintPath, constraint.onUpdate === "set-default" ? "onUpdate" : "onDelete"]
-		});
-		if (constraint.kind === "unique-constraint" && constraint.nulls === "not-distinct") diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "MySQL ordinary UNIQUE constraints use distinct NULL semantics in v1",
-			path: [...constraintPath, "nulls"]
-		});
-		if (constraint.dialect?.dialect === mysqlSnapshotDialect.name && "enforced" in constraint.dialect && constraint.dialect.enforced !== void 0 && typeof constraint.dialect.enforced !== "boolean") diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "MySQL constraint enforced must be boolean",
-			path: [
-				...constraintPath,
-				"dialect",
-				"enforced"
-			]
-		});
-	}
-	const indexes = Object.entries(metadata.indexes);
-	const tableIndexNames = /* @__PURE__ */ new Map();
-	for (const [indexId, index] of indexes.sort(([left], [right]) => compareIds(left, right))) {
-		const indexPath = [
-			...tablePath,
-			"indexes",
-			indexId
-		];
-		const physicalName = index.physicalName ?? indexId;
-		validateMysqlName(physicalName, [...indexPath, "physicalName"], "MySQL index", diagnostics);
-		addScopedName(tableIndexNames, physicalName, [...indexPath, "physicalName"], "index", diagnostics);
-		appendMetadataDiagnostics(diagnostics, validateIndexDialect(index, context.dialect.name, indexPath));
-		if (index.predicate !== void 0) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "MySQL does not support partial-index predicates",
-			path: [...indexPath, "predicate"]
-		});
-		for (const [termIndex, term] of index.terms.entries()) if (isOrderTerm(term) && term.nulls !== void 0) diagnostics.push({
-			code: "unsupported-dialect-option",
-			message: "MySQL index terms do not support NULLS FIRST/LAST syntax",
-			path: [
-				...indexPath,
-				"terms",
-				termIndex,
-				"nulls"
-			]
-		});
-		const extension = index.dialect;
-		if (extension?.dialect === mysqlSnapshotDialect.name) {
-			const mysqlExtension = extension;
-			if (mysqlExtension.algorithm !== void 0 && ![
-				"default",
-				"inplace",
-				"copy"
-			].includes(String(mysqlExtension.algorithm))) diagnostics.push({
-				code: "unsupported-dialect-option",
-				message: "MySQL index algorithm is invalid",
-				path: [
-					...indexPath,
-					"dialect",
-					"algorithm"
-				]
-			});
-			if (mysqlExtension.lock !== void 0 && ![
-				"default",
-				"none",
-				"shared",
-				"exclusive"
-			].includes(String(mysqlExtension.lock))) diagnostics.push({
-				code: "unsupported-dialect-option",
-				message: "MySQL index lock mode is invalid",
-				path: [
-					...indexPath,
-					"dialect",
-					"lock"
-				]
-			});
-			if (mysqlExtension.using !== void 0 && ![
-				"btree",
-				"hash",
-				"rtree"
-			].includes(String(mysqlExtension.using))) diagnostics.push({
-				code: "unsupported-dialect-option",
-				message: "MySQL index access method is invalid",
-				path: [
-					...indexPath,
-					"dialect",
-					"using"
-				]
-			});
-			if (mysqlExtension.parser !== void 0 && (typeof mysqlExtension.parser !== "string" || mysqlExtension.parser.trim().length === 0)) diagnostics.push({
-				code: "unsupported-dialect-option",
-				message: "MySQL index parser must be a non-empty string",
-				path: [
-					...indexPath,
-					"dialect",
-					"parser"
-				]
-			});
-		}
-	}
-}
-function validateMysqlAutoIncrement(columnId, definition, metadata, columnPath, diagnostics) {
-	if (definition.nullable) diagnostics.push({
-		code: "unsupported-dialect-option",
-		message: "MySQL AUTO_INCREMENT columns must be non-nullable",
-		path: [...columnPath, "nullable"]
-	});
-	if (definition.generatedColumn !== void 0) diagnostics.push({
-		code: "unsupported-dialect-option",
-		message: "MySQL AUTO_INCREMENT columns cannot be generated columns",
-		path: [...columnPath, "generatedColumn"]
-	});
-	const declaration = mysqlDeclaration(definition.storage);
-	if (declaration === void 0 || !isMysqlIntegerDeclaration(declaration)) diagnostics.push({
-		code: "unsupported-dialect-option",
-		message: "MySQL AUTO_INCREMENT requires an integer-family physical storage declaration",
-		path: [...columnPath, "storage"]
-	});
-	if (!hasMysqlAutoIncrementKey(columnId, metadata)) diagnostics.push({
-		code: "unsupported-dialect-option",
-		message: "MySQL AUTO_INCREMENT columns must be the first column of a primary, unique, or ordinary index key",
-		path: [
-			...columnPath,
-			"identity",
-			"dialect",
-			"autoIncrement"
-		]
-	});
-}
-function mysqlDeclaration(storage) {
-	if (storage === void 0) return;
-	return storage.kind === "native" ? storage.type : mysqlStorageTypes[storage.type];
-}
-function isMysqlIntegerDeclaration(declaration) {
-	const base = declaration.trim().toUpperCase().split(/\s+/u)[0] ?? "";
-	return /^(?:TINYINT|SMALLINT|MEDIUMINT|INT|INTEGER|BIGINT)(?:\(\d+\))?$/u.test(base);
-}
-function hasMysqlAutoIncrementKey(columnId, metadata) {
-	for (const constraint of Object.values(metadata.constraints)) if ((constraint.kind === "primary-key" || constraint.kind === "unique" || constraint.kind === "unique-constraint") && isColumnReference(constraint.columns[0]) && constraint.columns[0].fieldName === columnId) return true;
-	for (const index of Object.values(metadata.indexes)) {
-		const first = index.terms[0];
-		const expression = isOrderTerm(first) ? first.expression : first;
-		if (isColumnReference(expression) && expression.fieldName === columnId) return true;
-	}
-	return false;
-}
-function validateMysqlName(name, path, kind, diagnostics) {
-	if (!isValidSchemaObjectName(name) || name.length === 0) diagnostics.push({
-		code: "invalid-schema",
-		message: `${kind} name "${name}" is not a valid unqualified identifier`,
-		path
-	});
-	if ([...name].length > 64) diagnostics.push({
-		code: "unsupported-dialect-option",
-		message: `${kind} name exceeds MySQL's 64-character identifier limit`,
-		path
-	});
-}
-function addScopedName(names, name, path, kind, diagnostics) {
-	const previousPath = names.get(name);
-	if (previousPath !== void 0) {
-		diagnostics.push({
-			code: "invalid-schema",
-			message: `MySQL ${kind} name "${name}" collides with another ${kind}`,
-			path,
-			relatedPaths: [previousPath]
-		});
-		return;
-	}
-	names.set(name, path);
-}
-function appendMetadataDiagnostics(diagnostics, issues) {
-	for (const issue of issues) {
-		if (issue.code === "dialect-mismatch") continue;
-		diagnostics.push({
-			code: issue.code === "unsupported-dialect-option" ? "unsupported-dialect-option" : "invalid-schema",
-			message: issue.message,
-			path: issue.path,
-			...issue.relatedPaths === void 0 ? {} : { relatedPaths: issue.relatedPaths }
-		});
-	}
-}
-function isOrderTerm(value) {
-	return typeof value === "object" && value !== null && "orderKind" in value && value.orderKind === "term" && "expression" in value;
-}
-function compareIds(left, right) {
-	return left < right ? -1 : left > right ? 1 : 0;
-}
-//#endregion
-export { tryCreateMysqlSchemaSnapshot as a, postgresSnapshotAdapter as c, mysqlSnapshotDialect as i, postgresSnapshotDialect as l, mysqlSchemaDialect as n, createPostgresSchemaSnapshot as o, mysqlSnapshotAdapter as r, postgresSchemaDialect as s, createMysqlSchemaSnapshot as t, tryCreatePostgresSchemaSnapshot as u };