@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/schema-sql/MSSQL.js

@@ -0,0 +1,214 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, Database } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { autoNameIgnoreCase, getBracket, isDelimitedPart, primaryKeyColumns, splitNameParts, tableNamePart, unquoteNamePart } from "../tableName.js";
+import { SchemaSQLHeader } from "./options.js";
+import { commentToWrite, formatNames, formatReferentialActions, formatSize, formatSpace, primaryKey, referentialActionSupport, selectIndexColumns, toForeignKeyPairs, toOrderName, toSchemaEntities, toStringLiteral, unique, uniqueColumns } from "./utils.js";
+//#region src/utils/schema-sql/MSSQL.ts
+var ACTION_SUPPORT = referentialActionSupport(Database.MSSQL);
+var DEFAULT_SCHEMA = "dbo";
+function createSchema(state, tableIds, { written, logicalNameAsComment } = {}) {
+	const fkNames = [];
+	const indexNames = [];
+	const stringBuffer = [""];
+	const { tables, relationships, indexes } = toSchemaEntities(state, tableIds);
+	tables.forEach((table) => {
+		written?.tables.push(table);
+		formatTable(state, {
+			table,
+			buffer: stringBuffer
+		});
+		stringBuffer.push("");
+		formatUnique(state, {
+			table,
+			buffer: stringBuffer
+		});
+		formatComment(state, {
+			table,
+			buffer: stringBuffer,
+			logicalNameAsComment
+		});
+	});
+	relationships.forEach((relationship) => {
+		if (formatRelation(state, {
+			relationship,
+			buffer: stringBuffer,
+			fkNames
+		})) stringBuffer.push("");
+	});
+	indexes.forEach((index) => {
+		formatIndex(state, {
+			index,
+			buffer: stringBuffer,
+			indexNames
+		});
+		stringBuffer.push("");
+	});
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	const { settings: { bracketType }, collections } = state;
+	const bracket = getBracket(bracketType);
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	buffer.push(`CREATE TABLE ${bracket}${table.name}${bracket}`);
+	buffer.push(`(`);
+	const pk = primaryKey(columns);
+	const spaceSize = formatSize(columns);
+	columns.forEach((column, i) => {
+		if (pk) formatColumn(state, {
+			column,
+			isComma: true,
+			spaceSize,
+			buffer
+		});
+		else formatColumn(state, {
+			column,
+			isComma: columns.length !== i + 1,
+			spaceSize,
+			buffer
+		});
+	});
+	if (pk) {
+		const pkColumns = primaryKeyColumns(columns);
+		const pkName = `PK_${tableNamePart(table.name, bracketType)}`;
+		buffer.push(`  CONSTRAINT ${bracket}${pkName}${bracket} PRIMARY KEY (${formatNames(pkColumns, bracket)})`);
+	}
+	buffer.push(`)\nGO`);
+}
+function formatUnique({ settings: { bracketType }, collections }, { buffer, table }) {
+	const bracket = getBracket(bracketType);
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	if (!unique(columns)) return;
+	uniqueColumns(columns).forEach((column) => {
+		buffer.push(`ALTER TABLE ${bracket}${table.name}${bracket}`);
+		buffer.push(`  ADD CONSTRAINT ${bracket}UQ_${tableNamePart(table.name, bracketType)}_${column.name}${bracket} UNIQUE (${bracket}${column.name}${bracket})\nGO`);
+		buffer.push("");
+	});
+}
+function formatColumn({ settings: { bracketType } }, { buffer, column, isComma, spaceSize }) {
+	const bracket = getBracket(bracketType);
+	const stringBuffer = [];
+	stringBuffer.push(`  ${bracket}${column.name}${bracket}` + formatSpace(spaceSize.name - column.name.length));
+	stringBuffer.push(`${column.dataType}` + formatSpace(spaceSize.dataType - column.dataType.length));
+	if (bHas(column.options, ColumnOption.notNull)) stringBuffer.push(`NOT NULL`);
+	if (bHas(column.options, ColumnOption.autoIncrement)) stringBuffer.push(`IDENTITY(1,1)`);
+	else if (column.default.trim() !== "") stringBuffer.push(`DEFAULT ${column.default}`);
+	buffer.push(stringBuffer.join(" ") + `${isComma ? "," : ""}`);
+}
+var REGULAR_PART = /^[\p{L}_@#][\p{L}\p{N}_@#$]*$/u;
+function isOneName(part) {
+	return isDelimitedPart(part) || REGULAR_PART.test(part);
+}
+function databasePrefix(name, bracket) {
+	if (bracket) return "";
+	const [, , database = ""] = splitNameParts(name).reverse();
+	return isOneName(database) ? `${database}.` : "";
+}
+function formatLevels(name, bracket) {
+	const [table, schema = ""] = bracket ? [name] : splitNameParts(name).reverse();
+	const level0 = unquoteNamePart(schema) || DEFAULT_SCHEMA;
+	const level1 = bracket ? table : unquoteNamePart(table);
+	return {
+		procedure: `${databasePrefix(name, bracket)}sys.sp_addextendedproperty`,
+		levels: `'schema', ${toStringLiteral(level0)}, 'table', ${toStringLiteral(level1)}`
+	};
+}
+var toDescription = (comment) => `N${toStringLiteral(comment)}`;
+function formatComment({ settings: { bracketType }, collections }, { table, buffer, logicalNameAsComment }) {
+	const { procedure, levels } = formatLevels(table.name, getBracket(bracketType));
+	const tableComment = commentToWrite(table, logicalNameAsComment);
+	if (tableComment !== "") {
+		buffer.push(`EXECUTE ${procedure} 'MS_Description',`);
+		buffer.push(`  ${toDescription(tableComment)}, ${levels}\nGO`);
+		buffer.push("");
+	}
+	query(collections).collection("tableColumnEntities").selectByIds(table.columnIds).forEach((column) => {
+		const comment = commentToWrite(column, logicalNameAsComment);
+		if (comment !== "") {
+			buffer.push(`EXECUTE ${procedure} 'MS_Description',`);
+			buffer.push(`  ${toDescription(comment)}, ${levels}, 'column', ${toStringLiteral(column.name)}\nGO`);
+			buffer.push("");
+		}
+	});
+}
+function formatRelation(state, { buffer, relationship, fkNames }) {
+	const { settings: { bracketType } } = state;
+	const columns = toForeignKeyPairs(state, relationship);
+	if (!columns) return false;
+	const { startTable, endTable } = columns;
+	const bracket = getBracket(bracketType);
+	buffer.push(`ALTER TABLE ${bracket}${endTable.name}${bracket}`);
+	const startName = tableNamePart(startTable.name, bracketType);
+	const endName = tableNamePart(endTable.name, bracketType);
+	const fkName = autoNameIgnoreCase(fkNames, `FK_${startName}_TO_${endName}`);
+	fkNames.push({
+		id: uuid25(),
+		name: fkName
+	});
+	buffer.push(`  ADD CONSTRAINT ${bracket}${fkName}${bracket}`);
+	buffer.push(`    FOREIGN KEY (${formatNames(columns.end, bracket)})`);
+	buffer.push(`    REFERENCES ${bracket}${startTable.name}${bracket} (${formatNames(columns.start, bracket)})`, ...formatReferentialActions(relationship, ACTION_SUPPORT).map((clause) => `    ${clause}`));
+	buffer[buffer.length - 1] += "\nGO";
+	return true;
+}
+function formatIndex({ settings: { bracketType }, collections }, { buffer, index, indexNames }) {
+	const bracket = getBracket(bracketType);
+	const table = query(collections).collection("tableEntities").selectById(index.tableId);
+	if (!table) return;
+	const columnNames = selectIndexColumns(collections, table, index).map(({ indexColumn, column }) => ({ name: `${bracket}${column.name}${bracket} ${toOrderName(indexColumn.orderType)}` }));
+	if (columnNames.length !== 0) {
+		let indexName = index.name;
+		if (index.name.trim() === "") {
+			const tableName = tableNamePart(table.name, bracketType);
+			indexName = autoNameIgnoreCase(indexNames, `IDX_${tableName}`);
+			indexNames.push({
+				id: uuid25(),
+				name: indexName
+			});
+		}
+		if (index.unique) buffer.push(`CREATE UNIQUE INDEX ${bracket}${indexName}${bracket}`);
+		else buffer.push(`CREATE INDEX ${bracket}${indexName}${bracket}`);
+		buffer.push(`  ON ${bracket}${table.name}${bracket} (${formatNames(columnNames)})\nGO`);
+	}
+}
+function formatHeader({ settings: { bracketType } }, header, name) {
+	const bracket = getBracket(bracketType);
+	const database = `${bracket}${name}${bracket}`;
+	const use = `USE ${database}\nGO`;
+	return header === SchemaSQLHeader.createAndUse ? `IF DB_ID(N${toStringLiteral(name)}) IS NULL\n  CREATE DATABASE ${database}\nGO\n\n${use}` : use;
+}
+function formatDropBlock({ settings: { bracketType } }, { tables }) {
+	if (tables.length === 0) return "";
+	const bracket = getBracket(bracketType);
+	const quote = (name) => `${bracket}${name}${bracket}`;
+	return [
+		"BEGIN TRY",
+		"  BEGIN TRANSACTION",
+		"",
+		"  DECLARE @sql NVARCHAR(MAX) = N''",
+		...tables.flatMap(({ name }) => {
+			const database = databasePrefix(name, bracket);
+			const objectId = `OBJECT_ID(N${toStringLiteral(quote(name))}, N'U')`;
+			const select = [
+				`SELECT @sql += N${toStringLiteral(`ALTER TABLE ${quote(name)} DROP CONSTRAINT `)} + QUOTENAME(name) + N';'`,
+				`  FROM ${database}sys.foreign_keys`,
+				`  WHERE parent_object_id = ${objectId}`
+			];
+			return database ? [`  IF ${objectId} IS NOT NULL`, ...select.map((line) => `    ${line}`)] : select.map((line) => `  ${line}`);
+		}),
+		"  EXECUTE sp_executesql @sql",
+		"",
+		`  DROP TABLE IF EXISTS ${tables.map(({ name }) => quote(name)).join(", ")}`,
+		"",
+		"  COMMIT TRANSACTION",
+		"END TRY",
+		"BEGIN CATCH",
+		"  IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION;",
+		"  THROW;",
+		"END CATCH",
+		"GO"
+	].join("\n");
+}
+//#endregion
+export { createSchema, formatDropBlock, formatHeader, formatIndex, formatTable, formatUnique };

package/dist/utils/schema-sql/MariaDB.js

@@ -0,0 +1,143 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, Database } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { autoNameIgnoreCase, getBracket, primaryKeyColumns, tableNamePart } from "../tableName.js";
+import { commentToWrite, formatDefault, formatNames, formatReferentialActions, formatSize, formatSpace, ifNotExists, primaryKey, referentialActionSupport, selectIndexColumns, toForeignKeyPairs, toOrderName, toSchemaEntities, toStringLiteral, unique, uniqueColumns } from "./utils.js";
+import { formatDropBlock, formatHeader } from "./MySQL.js";
+//#region src/utils/schema-sql/MariaDB.ts
+var ACTION_SUPPORT = referentialActionSupport(Database.MariaDB);
+function createSchema(state, tableIds, { statements, written, logicalNameAsComment } = {}) {
+	const fkNames = [];
+	const indexNames = [];
+	const stringBuffer = [""];
+	const { tables, relationships, indexes } = toSchemaEntities(state, tableIds);
+	tables.forEach((table) => {
+		written?.tables.push(table);
+		formatTable(state, {
+			table,
+			buffer: stringBuffer,
+			statements,
+			logicalNameAsComment
+		});
+		stringBuffer.push("");
+		formatUnique(state, {
+			table,
+			buffer: stringBuffer,
+			statements
+		});
+	});
+	relationships.forEach((relationship) => {
+		if (formatRelation(state, {
+			relationship,
+			buffer: stringBuffer,
+			fkNames,
+			statements
+		})) stringBuffer.push("");
+	});
+	indexes.forEach((index) => {
+		formatIndex(state, {
+			index,
+			buffer: stringBuffer,
+			indexNames,
+			statements
+		});
+		stringBuffer.push("");
+	});
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table, statements, logicalNameAsComment }) {
+	const { settings: { bracketType }, collections } = state;
+	const bracket = getBracket(bracketType);
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	buffer.push(`CREATE TABLE${ifNotExists(statements)} ${bracket}${table.name}${bracket}`);
+	buffer.push(`(`);
+	const pk = primaryKey(columns);
+	const spaceSize = formatSize(columns);
+	columns.forEach((column, i) => {
+		if (pk) formatColumn(state, {
+			column,
+			isComma: true,
+			spaceSize,
+			buffer,
+			logicalNameAsComment
+		});
+		else formatColumn(state, {
+			column,
+			isComma: columns.length !== i + 1,
+			spaceSize,
+			buffer,
+			logicalNameAsComment
+		});
+	});
+	if (pk) {
+		const pkColumns = primaryKeyColumns(columns);
+		buffer.push(`  PRIMARY KEY (${formatNames(pkColumns, bracket)})`);
+	}
+	const comment = commentToWrite(table, logicalNameAsComment);
+	if (comment === "") buffer.push(`);`);
+	else buffer.push(`) COMMENT ${toStringLiteral(comment)};`);
+}
+function formatUnique({ settings: { bracketType }, collections }, { buffer, table, statements }) {
+	const bracket = getBracket(bracketType);
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	if (!unique(columns)) return;
+	uniqueColumns(columns).forEach((column) => {
+		buffer.push(`ALTER TABLE ${bracket}${table.name}${bracket}`);
+		buffer.push(`  ADD CONSTRAINT ${bracket}UQ_${tableNamePart(table.name, bracketType)}_${column.name}${bracket} UNIQUE${ifNotExists(statements)} (${bracket}${column.name}${bracket});`);
+		buffer.push("");
+	});
+}
+function formatColumn({ settings: { bracketType } }, { buffer, column, isComma, spaceSize, logicalNameAsComment }) {
+	const bracket = getBracket(bracketType);
+	const stringBuffer = [];
+	stringBuffer.push(`  ${bracket}${column.name}${bracket}` + formatSpace(spaceSize.name - column.name.length));
+	stringBuffer.push(`${column.dataType}` + formatSpace(spaceSize.dataType - column.dataType.length));
+	stringBuffer.push(`${bHas(column.options, ColumnOption.notNull) ? "NOT NULL" : "NULL    "}`);
+	if (bHas(column.options, ColumnOption.autoIncrement)) stringBuffer.push(`AUTO_INCREMENT`);
+	else if (column.default.trim() !== "") stringBuffer.push(`DEFAULT ${formatDefault(column.default, Database.MariaDB)}`);
+	const comment = commentToWrite(column, logicalNameAsComment);
+	if (comment !== "") stringBuffer.push(`COMMENT ${toStringLiteral(comment)}`);
+	buffer.push(stringBuffer.join(" ") + `${isComma ? "," : ""}`);
+}
+function formatRelation(state, { buffer, relationship, fkNames, statements }) {
+	const { settings: { bracketType } } = state;
+	const columns = toForeignKeyPairs(state, relationship);
+	if (!columns) return false;
+	const { startTable, endTable } = columns;
+	const bracket = getBracket(bracketType);
+	buffer.push(`ALTER TABLE ${bracket}${endTable.name}${bracket}`);
+	const startName = tableNamePart(startTable.name, bracketType);
+	const endName = tableNamePart(endTable.name, bracketType);
+	const fkName = autoNameIgnoreCase(fkNames, `FK_${startName}_TO_${endName}`);
+	fkNames.push({
+		id: uuid25(),
+		name: fkName
+	});
+	buffer.push(`  ADD CONSTRAINT ${bracket}${fkName}${bracket}`);
+	buffer.push(`    FOREIGN KEY${ifNotExists(statements)} (${formatNames(columns.end, bracket)})`);
+	buffer.push(`    REFERENCES ${bracket}${startTable.name}${bracket} (${formatNames(columns.start, bracket)})`, ...formatReferentialActions(relationship, ACTION_SUPPORT).map((clause) => `    ${clause}`));
+	buffer[buffer.length - 1] += ";";
+	return true;
+}
+function formatIndex({ settings: { bracketType }, collections }, { buffer, index, indexNames, statements }) {
+	const bracket = getBracket(bracketType);
+	const table = query(collections).collection("tableEntities").selectById(index.tableId);
+	if (!table) return;
+	const columnNames = selectIndexColumns(collections, table, index).map(({ indexColumn, column }) => ({ name: `${bracket}${column.name}${bracket} ${toOrderName(indexColumn.orderType)}` }));
+	if (columnNames.length !== 0) {
+		let indexName = index.name;
+		if (index.name.trim() === "") {
+			const tableName = tableNamePart(table.name, bracketType);
+			indexName = autoNameIgnoreCase(indexNames, `IDX_${tableName}`);
+			indexNames.push({
+				id: uuid25(),
+				name: indexName
+			});
+		}
+		buffer.push(`CREATE ${index.unique ? "UNIQUE " : ""}INDEX${ifNotExists(statements)} ${bracket}${indexName}${bracket}`);
+		buffer.push(`  ON ${bracket}${table.name}${bracket} (${formatNames(columnNames)});`);
+	}
+}
+//#endregion
+export { createSchema, formatDropBlock, formatHeader, formatIndex, formatTable, formatUnique };

package/dist/utils/schema-sql/MySQL.js

@@ -0,0 +1,224 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, Database } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { autoNameIgnoreCase, getBracket, primaryKeyColumns, tableNamePart } from "../tableName.js";
+import { SchemaSQLHeader, SchemaSQLStatements } from "./options.js";
+import { commentToWrite, formatDefault, formatNames, formatReferentialActions, formatSize, formatSpace, ifNotExists, primaryKey, referentialActionSupport, selectIndexColumns, toForeignKeyPairs, toOrderName, toSchemaEntities, toStringLiteral, unique, uniqueColumns } from "./utils.js";
+//#region src/utils/schema-sql/MySQL.ts
+var ACTION_SUPPORT = referentialActionSupport(Database.MySQL);
+var FOREIGN_KEY_CHECKS_OFF = "SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0;";
+var FOREIGN_KEY_CHECKS_RESTORE = "SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;";
+function createSchema(state, tableIds, { statements, written, logicalNameAsComment } = {}) {
+	if (statements === SchemaSQLStatements.ifNotExists) return createInlineSchema(state, tableIds, written, logicalNameAsComment);
+	const fkNames = [];
+	const indexNames = [];
+	const stringBuffer = [""];
+	const { tables, relationships, indexes } = toSchemaEntities(state, tableIds);
+	tables.forEach((table) => {
+		written?.tables.push(table);
+		formatTable(state, {
+			table,
+			buffer: stringBuffer,
+			logicalNameAsComment
+		});
+		stringBuffer.push("");
+		formatUnique(state, {
+			table,
+			buffer: stringBuffer
+		});
+	});
+	relationships.forEach((relationship) => {
+		if (formatRelation(state, {
+			relationship,
+			buffer: stringBuffer,
+			fkNames
+		})) stringBuffer.push("");
+	});
+	indexes.forEach((index) => {
+		formatIndex(state, {
+			index,
+			buffer: stringBuffer,
+			indexNames
+		});
+		stringBuffer.push("");
+	});
+	return stringBuffer.join("\n");
+}
+function createInlineSchema(state, tableIds, written, logicalNameAsComment) {
+	const { settings: { bracketType }, collections } = state;
+	const { tables, relationships, indexes } = toSchemaEntities(state, tableIds);
+	if (tables.length === 0) return "";
+	const fkNames = [];
+	const foreignKeys = /* @__PURE__ */ new Map();
+	relationships.forEach((relationship) => {
+		const foreignKey = toForeignKey(state, relationship, fkNames);
+		if (!foreignKey) return;
+		const [constraint, ...clauses] = foreignKey.lines;
+		const held = foreignKeys.get(foreignKey.table.id) ?? [];
+		held.push([`  ${constraint}`, ...clauses]);
+		foreignKeys.set(foreignKey.table.id, held);
+	});
+	const indexNames = [];
+	const tableIndexes = /* @__PURE__ */ new Map();
+	indexes.forEach((index) => {
+		const target = toIndex(state, index, indexNames);
+		if (!target) return;
+		const held = tableIndexes.get(target.table.id) ?? [];
+		held.push([`  ${index.unique ? "UNIQUE " : ""}INDEX ${target.name} (${target.columns})`]);
+		tableIndexes.set(target.table.id, held);
+	});
+	const stringBuffer = [
+		"",
+		FOREIGN_KEY_CHECKS_OFF,
+		""
+	];
+	tables.forEach((table) => {
+		written?.tables.push(table);
+		const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+		writeTable(state, stringBuffer, table, SchemaSQLStatements.ifNotExists, [
+			...uniqueColumns(columns).map((column) => [`  ${uniqueConstraint(bracketType, table, column)}`]),
+			...tableIndexes.get(table.id) ?? [],
+			...foreignKeys.get(table.id) ?? []
+		], logicalNameAsComment);
+		stringBuffer.push("");
+	});
+	stringBuffer.push(FOREIGN_KEY_CHECKS_RESTORE, "");
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table, statements, logicalNameAsComment }) {
+	writeTable(state, buffer, table, statements, [], logicalNameAsComment);
+}
+function writeTable(state, buffer, table, statements, elements, logicalNameAsComment) {
+	const { settings: { bracketType }, collections } = state;
+	const bracket = getBracket(bracketType);
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	buffer.push(`CREATE TABLE${ifNotExists(statements)} ${bracket}${table.name}${bracket}`);
+	buffer.push(`(`);
+	const pk = primaryKey(columns);
+	const spaceSize = formatSize(columns);
+	const more = elements.length !== 0;
+	columns.forEach((column, i) => {
+		formatColumn(state, {
+			column,
+			isComma: pk || more || columns.length !== i + 1,
+			spaceSize,
+			buffer,
+			logicalNameAsComment
+		});
+	});
+	if (pk) {
+		const pkColumns = primaryKeyColumns(columns);
+		buffer.push(`  PRIMARY KEY (${formatNames(pkColumns, bracket)})${more ? "," : ""}`);
+	}
+	elements.forEach((lines, i) => {
+		buffer.push(...lines);
+		if (i !== elements.length - 1) buffer[buffer.length - 1] += ",";
+	});
+	const comment = commentToWrite(table, logicalNameAsComment);
+	if (comment === "") buffer.push(`);`);
+	else buffer.push(`) COMMENT ${toStringLiteral(comment)};`);
+}
+function uniqueConstraint(bracketType, table, column) {
+	const bracket = getBracket(bracketType);
+	return `CONSTRAINT ${bracket}UQ_${tableNamePart(table.name, bracketType)}_${column.name}${bracket} UNIQUE (${bracket}${column.name}${bracket})`;
+}
+function formatUnique({ settings: { bracketType }, collections }, { buffer, table }) {
+	const bracket = getBracket(bracketType);
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	if (!unique(columns)) return;
+	uniqueColumns(columns).forEach((column) => {
+		buffer.push(`ALTER TABLE ${bracket}${table.name}${bracket}`);
+		buffer.push(`  ADD ${uniqueConstraint(bracketType, table, column)};`);
+		buffer.push("");
+	});
+}
+function formatColumn({ settings: { bracketType } }, { buffer, column, isComma, spaceSize, logicalNameAsComment }) {
+	const bracket = getBracket(bracketType);
+	const stringBuffer = [];
+	stringBuffer.push(`  ${bracket}${column.name}${bracket}` + formatSpace(spaceSize.name - column.name.length));
+	stringBuffer.push(`${column.dataType}` + formatSpace(spaceSize.dataType - column.dataType.length));
+	stringBuffer.push(`${bHas(column.options, ColumnOption.notNull) ? "NOT NULL" : "NULL    "}`);
+	if (bHas(column.options, ColumnOption.autoIncrement)) stringBuffer.push(`AUTO_INCREMENT`);
+	else if (column.default.trim() !== "") stringBuffer.push(`DEFAULT ${formatDefault(column.default, Database.MySQL, column.dataType)}`);
+	const comment = commentToWrite(column, logicalNameAsComment);
+	if (comment !== "") stringBuffer.push(`COMMENT ${toStringLiteral(comment)}`);
+	buffer.push(stringBuffer.join(" ") + `${isComma ? "," : ""}`);
+}
+function toForeignKey(state, relationship, fkNames) {
+	const { settings: { bracketType } } = state;
+	const columns = toForeignKeyPairs(state, relationship);
+	if (!columns) return null;
+	const { startTable, endTable } = columns;
+	const bracket = getBracket(bracketType);
+	const startName = tableNamePart(startTable.name, bracketType);
+	const endName = tableNamePart(endTable.name, bracketType);
+	const fkName = autoNameIgnoreCase(fkNames, `FK_${startName}_TO_${endName}`);
+	fkNames.push({
+		id: uuid25(),
+		name: fkName
+	});
+	return {
+		table: endTable,
+		lines: [
+			`CONSTRAINT ${bracket}${fkName}${bracket}`,
+			`    FOREIGN KEY (${formatNames(columns.end, bracket)})`,
+			`    REFERENCES ${bracket}${startTable.name}${bracket} (${formatNames(columns.start, bracket)})`,
+			...formatReferentialActions(relationship, ACTION_SUPPORT).map((clause) => `    ${clause}`)
+		]
+	};
+}
+function formatRelation(state, { buffer, relationship, fkNames }) {
+	const foreignKey = toForeignKey(state, relationship, fkNames);
+	if (!foreignKey) return false;
+	const bracket = getBracket(state.settings.bracketType);
+	const [constraint, ...clauses] = foreignKey.lines;
+	buffer.push(`ALTER TABLE ${bracket}${foreignKey.table.name}${bracket}`, `  ADD ${constraint}`, ...clauses);
+	buffer[buffer.length - 1] += ";";
+	return true;
+}
+function toIndex({ settings: { bracketType }, collections }, index, indexNames) {
+	const bracket = getBracket(bracketType);
+	const table = query(collections).collection("tableEntities").selectById(index.tableId);
+	if (!table) return null;
+	const columnNames = selectIndexColumns(collections, table, index).map(({ indexColumn, column }) => ({ name: `${bracket}${column.name}${bracket} ${toOrderName(indexColumn.orderType)}` }));
+	if (columnNames.length === 0) return null;
+	let indexName = index.name;
+	if (index.name.trim() === "") {
+		const tableName = tableNamePart(table.name, bracketType);
+		indexName = autoNameIgnoreCase(indexNames, `IDX_${tableName}`);
+		indexNames.push({
+			id: uuid25(),
+			name: indexName
+		});
+	}
+	return {
+		table,
+		name: `${bracket}${indexName}${bracket}`,
+		columns: formatNames(columnNames)
+	};
+}
+function formatIndex(state, { buffer, index, indexNames }) {
+	const target = toIndex(state, index, indexNames);
+	if (!target) return;
+	const bracket = getBracket(state.settings.bracketType);
+	buffer.push(`CREATE ${index.unique ? "UNIQUE " : ""}INDEX ${target.name}`);
+	buffer.push(`  ON ${bracket}${target.table.name}${bracket} (${target.columns});`);
+}
+function formatHeader({ settings: { bracketType } }, header, name) {
+	const bracket = getBracket(bracketType);
+	const database = `${bracket}${name}${bracket}`;
+	const use = `USE ${database};`;
+	return header === SchemaSQLHeader.createAndUse ? `CREATE DATABASE IF NOT EXISTS ${database};\n${use}` : use;
+}
+function formatDropBlock({ settings: { bracketType } }, { tables }) {
+	if (tables.length === 0) return "";
+	const bracket = getBracket(bracketType);
+	return [
+		FOREIGN_KEY_CHECKS_OFF,
+		tables.map((table) => `DROP TABLE IF EXISTS ${bracket}${table.name}${bracket};`).join("\n"),
+		FOREIGN_KEY_CHECKS_RESTORE
+	].join("\n\n");
+}
+//#endregion
+export { createSchema, formatDropBlock, formatHeader, formatIndex, formatTable, formatUnique };