@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,148 @@
+import { uuid25 } from "../../uuid/dist/uuid25.js";
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, Database, ReferentialActionToSQL } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { autoName, getBracket, primaryKeyColumns } from "../tableName.js";
+import { SchemaSQLHeader, SchemaSQLStatements } from "./options.js";
+import { commentToWrite, formatNames, formatReferentialActions, formatSize, formatSpace, primaryKey, referentialActionSupport, selectIndexColumns, toForeignKeyPairs, toOrderName, toSchemaEntities, toStringLiteral } from "./utils.js";
+//#region src/utils/schema-sql/Snowflake.ts
+var ACTION_SUPPORT = referentialActionSupport(Database.Snowflake);
+var toBracket = (bracketType) => getBracket(bracketType) === "" ? "" : "\"";
+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("");
+	});
+	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, statements, logicalNameAsComment }) {
+	const { collections, settings: { bracketType } } = state;
+	const bracket = toBracket(bracketType);
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	const create = statements === SchemaSQLStatements.recreate ? "CREATE OR REPLACE TABLE" : "CREATE TABLE";
+	buffer.push(`${create} ${bracket}${table.name}${bracket}`);
+	buffer.push(`(`);
+	const pk = primaryKey(columns);
+	const spaceSize = formatSize(columns);
+	columns.forEach((column, i) => {
+		formatColumn(state, {
+			column,
+			isComma: pk || columns.length !== i + 1,
+			spaceSize,
+			buffer,
+			logicalNameAsComment
+		});
+	});
+	if (pk) {
+		const pkColumns = primaryKeyColumns(columns);
+		buffer.push(`  CONSTRAINT ${bracket}PK_${table.name}${bracket} PRIMARY KEY (${formatNames(pkColumns, bracket)})`);
+	}
+	const comment = commentToWrite(table, logicalNameAsComment);
+	if (comment === "") buffer.push(`);`);
+	else {
+		buffer.push(`)`);
+		buffer.push(`COMMENT = ${toStringLiteral(comment)};`);
+	}
+}
+function formatColumn({ settings: { bracketType } }, { buffer, column, isComma, spaceSize, logicalNameAsComment }) {
+	const bracket = toBracket(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.unique)) stringBuffer.push(`UNIQUE`);
+	const notNull = bHas(column.options, ColumnOption.notNull) || bHas(column.options, ColumnOption.primaryKey);
+	stringBuffer.push(notNull ? "NOT NULL" : "        ");
+	if (bHas(column.options, ColumnOption.autoIncrement)) stringBuffer.push(`AUTOINCREMENT`);
+	else if (column.default.trim() !== "") stringBuffer.push(`DEFAULT ${column.default}`);
+	const comment = commentToWrite(column, logicalNameAsComment);
+	if (comment !== "") stringBuffer.push(`COMMENT ${toStringLiteral(comment)}`);
+	buffer.push(stringBuffer.join(" ").trimEnd() + `${isComma ? "," : ""}`);
+}
+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 = toBracket(bracketType);
+	const leftOut = leftOutActions(relationship);
+	if (leftOut.length !== 0) buffer.push(`-- Snowflake creates no foreign key with a referential action other than NO ACTION, so ${leftOut.join(" and ")} ${leftOut.length === 1 ? "is" : "are"} left out.`);
+	buffer.push(`ALTER TABLE ${bracket}${endTable.name}${bracket}`);
+	let fkName = `FK_${startTable.name}_TO_${endTable.name}`;
+	fkName = autoName(fkNames, "", fkName);
+	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] += ";";
+	return true;
+}
+function leftOutActions({ onDelete, onUpdate }) {
+	const clauses = [];
+	if (ReferentialActionToSQL[onDelete] && !ACTION_SUPPORT.onDelete.includes(onDelete)) clauses.push(`ON DELETE ${ReferentialActionToSQL[onDelete]}`);
+	if (ReferentialActionToSQL[onUpdate] && !ACTION_SUPPORT.onUpdate.includes(onUpdate)) clauses.push(`ON UPDATE ${ReferentialActionToSQL[onUpdate]}`);
+	return clauses;
+}
+function formatIndex({ collections, settings: { bracketType } }, { buffer, index, indexNames }) {
+	const bracket = toBracket(bracketType);
+	const table = query(collections).collection("tableEntities").selectById(index.tableId);
+	if (!table) return;
+	const indexColumns = selectIndexColumns(collections, table, index);
+	const columns = indexColumns.map(({ column }) => column);
+	if (columns.length === 0) return;
+	let indexName = index.name;
+	if (index.name.trim() === "") {
+		indexName = `IDX_${table.name}`;
+		indexName = autoName(indexNames, "", indexName);
+		indexNames.push({
+			id: uuid25(),
+			name: indexName
+		});
+	}
+	if (index.unique) {
+		buffer.push(`ALTER TABLE ${bracket}${table.name}${bracket}`);
+		buffer.push(`  ADD CONSTRAINT ${bracket}${indexName}${bracket} UNIQUE (${formatNames(columns, bracket)});`);
+		return;
+	}
+	const sortedNames = indexColumns.map(({ indexColumn, column }) => ({ name: `${bracket}${column.name}${bracket} ${toOrderName(indexColumn.orderType)}` }));
+	buffer.push(`-- Snowflake has no secondary indexes. ${bracket}${indexName}${bracket} on ${bracket}${table.name}${bracket} (${formatNames(sortedNames)})`);
+	buffer.push(`-- ALTER TABLE ${bracket}${table.name}${bracket} CLUSTER BY (${formatNames(columns, bracket)});`);
+}
+function formatHeader({ settings: { bracketType } }, header, name) {
+	const bracket = toBracket(bracketType);
+	const schema = `${bracket}${name}${bracket}`;
+	const use = `USE SCHEMA ${schema};`;
+	return header === SchemaSQLHeader.createAndUse ? `CREATE SCHEMA IF NOT EXISTS ${schema};\n${use}` : use;
+}
+function formatDropBlock() {
+	return "";
+}
+//#endregion
+export { createSchema, formatDropBlock, formatHeader, formatIndex, formatTable };

package/dist/utils/schema-sql/index.d.ts

@@ -9,9 +9,12 @@ export type CreateSchemaSQLOptions = SchemaSQLOptions & {
     scripts?: boolean;
 };
 /**
- * The DDL of the document in a database, the document's own by default: the
- * header, the before script, the DROP block, the tables and the after script.
- * Given table ids, only those tables, their indexes and foreign keys.
+ * The DDL of the document in the bracket the state shows: the header, the
+ * before script, the DROP block, the tables and the after script. Given table
+ * ids, only those tables, their indexes and foreign keys.
+ *
+ * @param database Left out, the one the state shows: the document's, unless a
+ * readonly reader picked another on their screen.
  */
 export declare function createSchemaSQL(state: RootState, database?: number, tableIds?: readonly string[], options?: CreateSchemaSQLOptions): string;
 /** The names of the tables the DDL writes, all or those given, in its order. */

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

@@ -0,0 +1,238 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { Database } from "../../constants/schema.js";
+import { SchemaSQLHeader, SchemaSQLHeaderList, SchemaSQLStatements, SchemaSQLStatementsList, formatScript, resolveSchemaSQLOptions, schemaSQLSupport } from "./options.js";
+import { createWrittenObjects, toSchemaEntities } from "./utils.js";
+import { createSchema, formatDropBlock, formatHeader, formatIndex, formatTable, formatUnique } from "./Databricks.js";
+import { createSchema as createSchema$1, formatDropBlock as formatDropBlock$1, formatHeader as formatHeader$1, formatIndex as formatIndex$1, formatTable as formatTable$1, formatUnique as formatUnique$1 } from "./MySQL.js";
+import { createSchema as createSchema$2, formatIndex as formatIndex$2, formatTable as formatTable$2, formatUnique as formatUnique$2 } from "./MariaDB.js";
+import { createSchema as createSchema$3, formatDropBlock as formatDropBlock$2, formatHeader as formatHeader$2, formatIndex as formatIndex$3, formatTable as formatTable$3, formatUnique as formatUnique$3 } from "./MSSQL.js";
+import { createSchema as createSchema$4, formatDropBlock as formatDropBlock$3, formatHeader as formatHeader$3, formatIndex as formatIndex$4, formatTable as formatTable$4, formatUnique as formatUnique$4, oracleLongNames } from "./Oracle.js";
+import { createSchema as createSchema$5, formatDropBlock as formatDropBlock$4, formatHeader as formatHeader$4, formatIndex as formatIndex$5, formatTable as formatTable$5 } from "./PostgreSQL.js";
+import { createSchema as createSchema$6, formatDropBlock as formatDropBlock$5, formatHeader as formatHeader$5, formatIndex as formatIndex$6, formatTable as formatTable$6 } from "./Snowflake.js";
+import { createSchema as createSchema$7, formatDropBlock as formatDropBlock$6, formatHeader as formatHeader$6, formatIndex as formatIndex$7, formatTable as formatTable$7 } from "./SQLite.js";
+//#region src/utils/schema-sql/index.ts
+var WRITERS = {
+	[Database.Databricks]: {
+		createSchema,
+		formatHeader,
+		formatDropBlock
+	},
+	[Database.MariaDB]: {
+		createSchema: createSchema$2,
+		formatHeader: formatHeader$1,
+		formatDropBlock: formatDropBlock$1
+	},
+	[Database.MSSQL]: {
+		createSchema: createSchema$3,
+		formatHeader: formatHeader$2,
+		formatDropBlock: formatDropBlock$2
+	},
+	[Database.MySQL]: {
+		createSchema: createSchema$1,
+		formatHeader: formatHeader$1,
+		formatDropBlock: formatDropBlock$1
+	},
+	[Database.Oracle]: {
+		createSchema: createSchema$4,
+		formatHeader: formatHeader$3,
+		formatDropBlock: formatDropBlock$3
+	},
+	[Database.PostgreSQL]: {
+		createSchema: createSchema$5,
+		formatHeader: formatHeader$4,
+		formatDropBlock: formatDropBlock$4
+	},
+	[Database.Snowflake]: {
+		createSchema: createSchema$6,
+		formatHeader: formatHeader$5,
+		formatDropBlock: formatDropBlock$5
+	},
+	[Database.SQLite]: {
+		createSchema: createSchema$7,
+		formatHeader: formatHeader$6,
+		formatDropBlock: formatDropBlock$6
+	}
+};
+function withoutEdges(sql) {
+	return sql === "" ? "" : sql.slice(1, -1);
+}
+function createSchemaSQL(state, database, tableIds, options) {
+	const currentDatabase = database ? database : state.settings.database;
+	const writer = WRITERS[currentDatabase];
+	if (!writer) return "";
+	const { databaseName } = state.settings;
+	const resolved = resolveSchemaSQLOptions(currentDatabase, options, databaseName);
+	const written = createWrittenObjects();
+	const body = withoutEdges(writer.createSchema(state, tableIds, {
+		statements: resolved.statements,
+		written,
+		logicalNameAsComment: options?.logicalNameAsComment === true
+	}));
+	const scripts = options?.scripts ?? tableIds === void 0 ? state.settings.ddlScripts : void 0;
+	const before = formatScript(scripts?.before ?? "", currentDatabase);
+	const after = formatScript(scripts?.after ?? "", currentDatabase);
+	const header = resolved.headerName === "valid" ? resolved.header : SchemaSQLHeader.none;
+	const drop = resolved.statements === SchemaSQLStatements.recreate ? writer.formatDropBlock(state, written, header, databaseName) : "";
+	if (!before && !drop && !body && !after) return "";
+	return `\n${[
+		header === SchemaSQLHeader.none ? "" : writer.formatHeader(state, header, databaseName),
+		before,
+		drop,
+		after ? body.replace(/\n+$/, "") : body,
+		after
+	].filter(Boolean).join("\n\n")}\n`;
+}
+function schemaSQLTables(state, tableIds) {
+	return toSchemaEntities(state, tableIds).tables.map((table) => table.name);
+}
+function createSchemaSQLTable(state, table) {
+	const { settings, doc: { indexIds }, collections } = state;
+	const buffer = [""];
+	const database = settings.database;
+	const indexNames = [];
+	const indexes = query(collections).collection("indexEntities").selectByIds(indexIds).filter((index) => index.tableId === table.id);
+	switch (database) {
+		case Database.Databricks:
+			formatTable(state, {
+				buffer,
+				table
+			});
+			buffer.push("");
+			formatUnique(state, {
+				buffer,
+				table
+			});
+			indexes.forEach((index) => {
+				formatIndex(state, {
+					index,
+					buffer,
+					indexNames
+				});
+				buffer.push("");
+			});
+			break;
+		case Database.MariaDB:
+			formatTable$2(state, {
+				buffer,
+				table
+			});
+			buffer.push("");
+			formatUnique$2(state, {
+				buffer,
+				table
+			});
+			indexes.forEach((index) => {
+				formatIndex$2(state, {
+					index,
+					buffer,
+					indexNames
+				});
+				buffer.push("");
+			});
+			break;
+		case Database.MSSQL:
+			formatTable$3(state, {
+				buffer,
+				table
+			});
+			buffer.push("");
+			formatUnique$3(state, {
+				buffer,
+				table
+			});
+			indexes.forEach((index) => {
+				formatIndex$3(state, {
+					index,
+					buffer,
+					indexNames
+				});
+				buffer.push("");
+			});
+			break;
+		case Database.MySQL:
+			formatTable$1(state, {
+				buffer,
+				table
+			});
+			buffer.push("");
+			formatUnique$1(state, {
+				buffer,
+				table
+			});
+			indexes.forEach((index) => {
+				formatIndex$1(state, {
+					index,
+					buffer,
+					indexNames
+				});
+				buffer.push("");
+			});
+			break;
+		case Database.Oracle:
+			formatTable$4(state, {
+				buffer,
+				table
+			});
+			buffer.push("");
+			formatUnique$4(state, {
+				buffer,
+				table
+			});
+			indexes.forEach((index) => {
+				formatIndex$4(state, {
+					index,
+					buffer,
+					indexNames
+				});
+				buffer.push("");
+			});
+			break;
+		case Database.PostgreSQL:
+			formatTable$5(state, {
+				buffer,
+				table
+			});
+			buffer.push("");
+			indexes.forEach((index) => {
+				formatIndex$5(state, {
+					index,
+					buffer,
+					indexNames
+				});
+				buffer.push("");
+			});
+			break;
+		case Database.Snowflake:
+			formatTable$6(state, {
+				buffer,
+				table
+			});
+			buffer.push("");
+			indexes.forEach((index) => {
+				formatIndex$6(state, {
+					index,
+					buffer,
+					indexNames
+				});
+				buffer.push("");
+			});
+			break;
+		case Database.SQLite:
+			formatTable$7(state, {
+				buffer,
+				table
+			});
+			buffer.push("");
+			indexes.forEach((index) => {
+				formatIndex$7(state, {
+					index,
+					buffer,
+					indexNames
+				});
+				buffer.push("");
+			});
+	}
+	return buffer.join("\n");
+}
+//#endregion
+export { SchemaSQLHeader, SchemaSQLHeaderList, SchemaSQLStatements, SchemaSQLStatementsList, createSchemaSQL, createSchemaSQLTable, oracleLongNames, resolveSchemaSQLOptions, schemaSQLSupport, schemaSQLTables };

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

@@ -0,0 +1,97 @@
+import { Database } from "../../constants/schema.js";
+//#region src/utils/schema-sql/options.ts
+var SchemaSQLStatements = {
+	create: "create",
+	ifNotExists: "ifNotExists",
+	recreate: "recreate"
+};
+var SchemaSQLStatementsList = Object.values(SchemaSQLStatements);
+var SchemaSQLHeader = {
+	none: "none",
+	use: "use",
+	createAndUse: "createAndUse"
+};
+var SchemaSQLHeaderList = Object.values(SchemaSQLHeader);
+var HEADER_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var BOTH_HEADERS = [SchemaSQLHeader.use, SchemaSQLHeader.createAndUse];
+var SUPPORT = {
+	[Database.MySQL]: {
+		ifNotExists: true,
+		headers: BOTH_HEADERS
+	},
+	[Database.MariaDB]: {
+		ifNotExists: true,
+		headers: BOTH_HEADERS
+	},
+	[Database.PostgreSQL]: {
+		ifNotExists: true,
+		headers: [SchemaSQLHeader.createAndUse]
+	},
+	[Database.Oracle]: {
+		ifNotExists: false,
+		headers: [SchemaSQLHeader.use]
+	},
+	[Database.MSSQL]: {
+		ifNotExists: false,
+		headers: BOTH_HEADERS
+	},
+	[Database.SQLite]: {
+		ifNotExists: true,
+		headers: []
+	},
+	[Database.Snowflake]: {
+		ifNotExists: false,
+		headers: BOTH_HEADERS
+	},
+	[Database.Databricks]: {
+		ifNotExists: true,
+		headers: BOTH_HEADERS
+	}
+};
+var NO_SUPPORT = {
+	ifNotExists: false,
+	headers: []
+};
+function schemaSQLSupport(database) {
+	return SUPPORT[database] ?? NO_SUPPORT;
+}
+function isSchemaSQLStatements(value) {
+	return SchemaSQLStatementsList.includes(value);
+}
+function isSchemaSQLHeader(value) {
+	return SchemaSQLHeaderList.includes(value);
+}
+function resolveSchemaSQLOptions(database, options, databaseName) {
+	const support = schemaSQLSupport(database);
+	return {
+		statements: resolveStatements(support, options?.statements),
+		header: resolveHeader(support, options?.header),
+		headerName: toHeaderName(databaseName)
+	};
+}
+function resolveStatements({ ifNotExists }, asked) {
+	if (!isSchemaSQLStatements(asked)) return SchemaSQLStatements.create;
+	if (asked === SchemaSQLStatements.ifNotExists && !ifNotExists) return SchemaSQLStatements.create;
+	return asked;
+}
+function toHeaderName(databaseName) {
+	if (databaseName === "") return "empty";
+	return HEADER_NAME_PATTERN.test(databaseName) ? "valid" : "invalid";
+}
+function resolveHeader({ headers }, asked) {
+	if (!isSchemaSQLHeader(asked) || asked === SchemaSQLHeader.none) return SchemaSQLHeader.none;
+	if (headers.includes(asked)) return asked;
+	return asked === SchemaSQLHeader.createAndUse && headers.includes(SchemaSQLHeader.use) ? SchemaSQLHeader.use : SchemaSQLHeader.none;
+}
+var GO_LINE = /^GO(?:\s+\d+)?$/i;
+function formatScript(text, database) {
+	let script = text.replace(/\r\n?/g, "\n").replace(/^(?:[ \t]*\n)+/, "").trimEnd();
+	if (script === "") return "";
+	if (database === Database.MSSQL) {
+		const last = script.slice(script.lastIndexOf("\n") + 1).trim();
+		if (!GO_LINE.test(last)) script += "\nGO";
+	}
+	return script;
+}
+//#endregion
+export { HEADER_NAME_PATTERN, SchemaSQLHeader, SchemaSQLHeaderList, SchemaSQLStatements, SchemaSQLStatementsList, formatScript, isSchemaSQLHeader, isSchemaSQLStatements, resolveSchemaSQLOptions, schemaSQLSupport };

package/dist/utils/schema-sql/utils.d.ts

@@ -111,56 +111,14 @@ export interface MaxLength {
 export declare function formatSize(columns: Column[]): MaxLength;
 export declare function formatSpace(size: number): string;
 export declare function primaryKey(columns: Column[]): boolean;
-export declare function primaryKeyColumns(columns: Column[]): Column[];
 export declare function unique(columns: Column[]): boolean;
 export declare function uniqueColumns(columns: Column[]): Column[];
-export declare function getBracket(bracketType: number): string;
 /**
  * The words a CREATE TABLE or CREATE INDEX writes after its object type, and
  * MariaDB after UNIQUE and FOREIGN KEY, under ifNotExists; nothing otherwise.
  */
 export declare function ifNotExists(statements?: SchemaSQLStatements): string;
-/**
- * The parts of an unquoted name, split at each dot outside brackets or double
- * quotes as SQL Server reads it, so [sales.v2].users is two parts.
- */
-export declare function splitNameParts(name: string): string[];
-/** Whether a name part is written in one pair of brackets or double quotes. */
-export declare function isDelimitedPart(part: string): boolean;
-/** The name a part in brackets or double quotes holds; any other part as is. */
-export declare function unquoteNamePart(part: string): string;
-/**
- * A table name split at its last dot outside brackets or double quotes into
- * schema and table, both as written, where it is unquoted; quoted, the whole
- * name is one identifier and the schema is empty.
- */
-export declare function splitTableName(name: string, bracketType: number): [schema: string, table: string];
-/**
- * The part of a table name that automatic constraint and index names take, one
- * pair of brackets or quotes off where unquoted, so sales.users and
- * [sales].[users] give PK_users, which every database reads as one identifier.
- */
-export declare function tableNamePart(name: string, bracketType: number): string;
-/**
- * Whether a database's DDL builds automatic names from tableNamePart: the six
- * generators that read an unquoted dot as a schema do, while Databricks and
- * Snowflake write the whole table name into them.
- */
-export declare function splitsTableName(database: number): boolean;
-export declare function orderByNameASC<T extends {
-    name: string;
-}>(a: T, b: T): 0 | 1 | -1;
-export declare function autoName<T extends {
-    id: string;
-    name: string;
-}>(list: T[], id: string, name: string, num?: number): string;
-/**
- * autoName for an automatic foreign key or index name, also numbering a name
- * equal to an earlier one but for case, quoted or not, since the databases fold
- * an unquoted name and MySQL and MariaDB a quoted index name too.
- */
-export declare function autoNameIgnoreCase(names: Name[], name: string): string;
-export declare function toOrderName(orderType: number): "" | "ASC" | "DESC";
+export declare function toOrderName(orderType: number): "" | "DESC" | "ASC";
 /** The actions a vendor accepts after ON DELETE and after ON UPDATE. */
 export type ReferentialActionSupport = {
     onDelete: ReadonlyArray<number>;