@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/generator-code/sqlalchemy.js

@@ -0,0 +1,1250 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnOption, Database } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { autoName, orderByNameASC } from "../tableName.js";
+import { referentialActionSupport } from "../schema-sql/utils.js";
+import { isIntegerFamily } from "../schema-sql/SQLite.js";
+import { getNameCase, getPrimitiveType, hasNRelationship, hasOneRelationship, referentialActionEntries } from "./utils.js";
+import { BINARY_TYPES, JSON_TYPES, POSTGRES_TIME_TZ_TYPES, TIMESTAMP_TZ_TYPES, UUID_TYPES, getColumnType, isMySQLFamily } from "./columnTypes.js";
+//#region src/utils/generator-code/sqlalchemy.ts
+var SQLALCHEMY_NAMES = [
+	"ARRAY",
+	"BINARY",
+	"BigInteger",
+	"Boolean",
+	"CHAR",
+	"Date",
+	"DateTime",
+	"Double",
+	"Enum",
+	"Float",
+	"ForeignKey",
+	"ForeignKeyConstraint",
+	"Index",
+	"Integer",
+	"Interval",
+	"JSON",
+	"LargeBinary",
+	"NCHAR",
+	"NVARCHAR",
+	"Numeric",
+	"REAL",
+	"SmallInteger",
+	"String",
+	"Text",
+	"Time",
+	"UUID",
+	"Uuid",
+	"VARBINARY",
+	"text"
+];
+var DIALECT_NAMES = {
+	mssql: [
+		"MONEY",
+		"NTEXT",
+		"SMALLMONEY",
+		"TIMESTAMP"
+	],
+	mysql: [
+		"BIGINT",
+		"BIT",
+		"DATETIME",
+		"DECIMAL",
+		"DOUBLE",
+		"FLOAT",
+		"INET4",
+		"INET6",
+		"INTEGER",
+		"LONGBLOB",
+		"LONGTEXT",
+		"MEDIUMBLOB",
+		"MEDIUMINT",
+		"MEDIUMTEXT",
+		"SET",
+		"SMALLINT",
+		"TIME",
+		"TIMESTAMP",
+		"TINYBLOB",
+		"TINYINT",
+		"TINYTEXT",
+		"VARCHAR",
+		"YEAR"
+	],
+	oracle: [
+		"DATE",
+		"NCLOB",
+		"NVARCHAR2",
+		"RAW",
+		"TIMESTAMP"
+	],
+	postgresql: [
+		"BIT",
+		"CIDR",
+		"DATEMULTIRANGE",
+		"DATERANGE",
+		"INET",
+		"INT4MULTIRANGE",
+		"INT4RANGE",
+		"INT8MULTIRANGE",
+		"INT8RANGE",
+		"INTERVAL",
+		"JSONB",
+		"JSONPATH",
+		"MACADDR",
+		"MACADDR8",
+		"MONEY",
+		"NUMMULTIRANGE",
+		"NUMRANGE",
+		"OID",
+		"REGCLASS",
+		"REGCONFIG",
+		"Range",
+		"TIME",
+		"TIMESTAMP",
+		"TSMULTIRANGE",
+		"TSQUERY",
+		"TSRANGE",
+		"TSTZMULTIRANGE",
+		"TSTZRANGE",
+		"TSVECTOR",
+		"UUID"
+	]
+};
+var ORM_NAMES = [
+	"DeclarativeBase",
+	"Mapped",
+	"mapped_column",
+	"relationship"
+];
+var STDLIB_PLAIN_NAMES = ["uuid"];
+var STDLIB_FROM_NAMES = {
+	datetime: [
+		"date",
+		"datetime",
+		"time",
+		"timedelta"
+	],
+	decimal: ["Decimal"],
+	typing: [
+		"Any",
+		"List",
+		"Optional",
+		"Set"
+	]
+};
+var BUILTIN_NAMES = [
+	"bool",
+	"bytes",
+	"float",
+	"int",
+	"str"
+];
+var BASE_CLASS_NAME = "Base";
+var MODULE_SCOPE_NAMES = /* @__PURE__ */ new Set([
+	BASE_CLASS_NAME,
+	...SQLALCHEMY_NAMES,
+	...Object.values(DIALECT_NAMES).flatMap((names) => [...names]),
+	...ORM_NAMES,
+	...STDLIB_PLAIN_NAMES,
+	...Object.values(STDLIB_FROM_NAMES).flatMap((names) => [...names]),
+	...BUILTIN_NAMES
+]);
+var convertTypeMap = {
+	int: "Integer",
+	long: "BigInteger",
+	float: "Float",
+	double: "Double",
+	decimal: "Numeric",
+	boolean: "Boolean",
+	string: "String",
+	lob: "Text",
+	date: "Date",
+	dateTime: "DateTime",
+	time: "Time"
+};
+var annotationMap = {
+	int: "int",
+	long: "int",
+	float: "float",
+	double: "float",
+	decimal: "Decimal",
+	boolean: "bool",
+	string: "str",
+	lob: "str",
+	date: "date",
+	dateTime: "datetime",
+	time: "time"
+};
+var LINE_LIMIT = 88;
+var INDENT = "    ";
+var OWNING = "owning";
+var INVERSE = "inverse";
+function createCode(state) {
+	const { doc: { tableIds }, collections } = state;
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC);
+	if (tables.length === 0) return "";
+	const stringBuffer = [""];
+	const classBuffer = [];
+	const context = createClassContext(state);
+	tables.forEach((table) => {
+		classBuffer.push("");
+		classBuffer.push("");
+		formatClass(state, {
+			buffer: classBuffer,
+			table
+		}, context);
+	});
+	formatImports(stringBuffer, context.imports);
+	formatBase(stringBuffer);
+	classBuffer.forEach((line) => stringBuffer.push(line));
+	stringBuffer.push("");
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	const classBuffer = [];
+	const context = createClassContext(state);
+	formatClass(state, {
+		buffer: classBuffer,
+		table
+	}, context);
+	formatImports(buffer, context.imports);
+	formatBase(buffer);
+	buffer.push("");
+	buffer.push("");
+	classBuffer.forEach((line) => buffer.push(line));
+}
+function formatBase(buffer) {
+	buffer.push("");
+	buffer.push("");
+	buffer.push(`class ${BASE_CLASS_NAME}(DeclarativeBase):`);
+	buffer.push(`${INDENT}pass`);
+}
+function formatClass(state, { buffer, table }, context) {
+	const { collections } = state;
+	const { imports } = context;
+	const naming = getNaming(state, context, table);
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(naming.columnIds);
+	const foreignKeys = /* @__PURE__ */ new Map();
+	const entries = [];
+	context.relationships.filter(({ relationship }) => relationship.end.tableId === table.id).forEach(({ relationship, startTable, startColumns, endColumns }) => {
+		const parentNaming = getNaming(state, context, startTable);
+		const actions = referentialActionEntries(relationship, referentialActionSupport(state.settings.database)).map(({ key, sql }) => `${key.toLowerCase()}="${sql}"`);
+		if (endColumns.length === 1) {
+			addSqlalchemy(imports, "ForeignKey");
+			const target = `${startTable.name}.${columnKey(parentNaming, startColumns[0])}`;
+			const carrier = columnRef(naming, endColumns[0]);
+			const args = [pythonString(target), ...actions];
+			const values = foreignKeys.get(carrier) ?? [];
+			values.push(`ForeignKey(${args.join(", ")})`);
+			foreignKeys.set(carrier, values);
+			return;
+		}
+		addSqlalchemy(imports, "ForeignKeyConstraint");
+		entries.push({
+			head: "ForeignKeyConstraint(",
+			args: [
+				formatStringList(endColumns.map((column) => columnKey(naming, column))),
+				formatStringList(startColumns.map((column) => `${startTable.name}.${columnKey(parentNaming, column)}`)),
+				...actions
+			]
+		});
+	});
+	createIndexEntries(state, table, naming, context).forEach((entry) => entries.push(entry));
+	buffer.push(`class ${naming.className}(${BASE_CLASS_NAME}):`);
+	if (table.comment.trim() !== "") {
+		buffer.push(`${INDENT}"""${formatDocstring(table.comment)}"""`);
+		buffer.push("");
+	}
+	buffer.push(`${INDENT}__tablename__ = ${pythonString(table.name)}`);
+	formatTableArgs(buffer, entries, table.comment);
+	const bodyBuffer = [];
+	const { database } = state.settings;
+	const isSoleKey = columns.filter((column) => bHas(column.options, ColumnOption.primaryKey)).length === 1;
+	const typedColumns = columns.map((column) => {
+		const dataType = isSqliteIntegerKey(column, database, isSoleKey) ? SQLITE_ROWID_TYPE : column.dataType;
+		const columnType = getColumnType(dataType, database);
+		return {
+			column,
+			columnType,
+			type: getSqlalchemyType(columnType, database, imports)
+		};
+	});
+	const autoIncrementKey = typedColumns.filter(({ column }) => bHas(column.options, ColumnOption.primaryKey)).find((typed) => isNumberedByDatabase(typed, database, isSoleKey) || isSoleKey && typed.type.isNumeric && typed.columnType.isSerial);
+	typedColumns.forEach((typed) => {
+		const { column } = typed;
+		const isPrimaryKey = bHas(column.options, ColumnOption.primaryKey);
+		formatColumn(state, {
+			buffer: bodyBuffer,
+			column
+		}, {
+			imports,
+			attribute: naming.columnNames.get(column.id) ?? column.name,
+			key: columnKey(naming, column),
+			foreignKeys: foreignKeys.get(column.id) ?? [],
+			typed,
+			isSoleKey,
+			isAutoIncrement: isPrimaryKey ? typed === autoIncrementKey : isNumberedByDatabase(typed, database, isSoleKey)
+		});
+	});
+	const relationBuffer = [];
+	formatRelation(state, {
+		buffer: relationBuffer,
+		table
+	}, context);
+	if (relationBuffer.length !== 0 && bodyBuffer.length !== 0) bodyBuffer.push("");
+	relationBuffer.forEach((line) => bodyBuffer.push(line));
+	if (bodyBuffer.length !== 0) {
+		buffer.push("");
+		bodyBuffer.forEach((line) => buffer.push(line));
+	}
+}
+function formatColumn({ settings: { database } }, { buffer, column }, { imports, attribute, key, foreignKeys, typed: { columnType, type: { expression, annotation, isNumeric, call } }, isSoleKey, isAutoIncrement }) {
+	const isPrimaryKey = bHas(column.options, ColumnOption.primaryKey);
+	const isNotNull = bHas(column.options, ColumnOption.notNull);
+	const isRowid = database === Database.SQLite && columnType.element.trim().toLowerCase() === "integer";
+	const isGeneratedKey = isPrimaryKey && isSoleKey && isNumeric && !isRowid;
+	const hasServerDefault = !isAutoIncrement && !bHas(column.options, ColumnOption.autoIncrement) && column.default.trim() !== "";
+	const isUnique = bHas(column.options, ColumnOption.unique) || isMySQLFamily(database) && columnType.isSerial;
+	const isOptional = !isPrimaryKey && !isNotNull;
+	const args = [];
+	if (attribute !== column.name) args.push(pythonString(column.name));
+	args.push(call ?? expression);
+	foreignKeys.forEach((foreignKey) => args.push(foreignKey));
+	if (key !== column.name) args.push(`key=${pythonString(key)}`);
+	if (isPrimaryKey) args.push("primary_key=True");
+	if (isAutoIncrement) args.push("autoincrement=True");
+	else if (isGeneratedKey) args.push("autoincrement=False");
+	if (!isPrimaryKey && isNotNull) args.push("nullable=False");
+	if (isUnique) args.push("unique=True");
+	if (hasServerDefault) {
+		addSqlalchemy(imports, "text");
+		args.push({
+			head: "server_default=text(",
+			args: [pythonString(column.default)]
+		});
+	}
+	if (column.comment.trim() !== "") args.push(`comment=${pythonString(column.comment)}`);
+	addOrm(imports, "Mapped");
+	addOrm(imports, "mapped_column");
+	if (isOptional) addStdlibFrom(imports, "typing", "Optional");
+	formatAssignment(buffer, attribute, isOptional ? `Optional[${annotation}]` : annotation, "mapped_column(", args);
+}
+function formatRelation(state, { buffer, table }, context) {
+	const { imports } = context;
+	const naming = getNaming(state, context, table);
+	context.relationships.filter(({ relationship }) => relationship.end.tableId === table.id).forEach((resolved) => {
+		const { relationship, startTable, endColumns } = resolved;
+		const attribute = naming.relationshipNames.get(relationshipKey(relationship, OWNING));
+		if (!attribute) return;
+		const parentNaming = getNaming(state, context, startTable);
+		const annotation = carriedColumns(state, naming, endColumns).every((column) => bHas(column.options, ColumnOption.primaryKey) || bHas(column.options, ColumnOption.notNull)) ? `"${parentNaming.className}"` : `Optional["${parentNaming.className}"]`;
+		addOrm(imports, "relationship");
+		formatAssignment(buffer, attribute, annotation, "relationship(", relationArguments(state, context, resolved, INVERSE));
+	});
+	context.relationships.filter(({ relationship }) => relationship.start.tableId === table.id).forEach((resolved) => {
+		const { relationship, endTable } = resolved;
+		const attribute = naming.relationshipNames.get(relationshipKey(relationship, INVERSE));
+		if (!attribute) return;
+		const childNaming = getNaming(state, context, endTable);
+		const isMany = hasNRelationship(relationship.relationshipType);
+		addStdlibFrom(imports, "typing", isMany ? "List" : "Optional");
+		const annotation = isMany ? `List["${childNaming.className}"]` : `Optional["${childNaming.className}"]`;
+		addOrm(imports, "relationship");
+		formatAssignment(buffer, attribute, annotation, "relationship(", relationArguments(state, context, resolved, OWNING));
+	});
+}
+function relationArguments(state, context, resolved, backPopulatesSide) {
+	const { relationship, startTable, startColumns, endTable, endColumns } = resolved;
+	const args = [];
+	const backPopulates = getNaming(state, context, backPopulatesSide === OWNING ? endTable : startTable).relationshipNames.get(relationshipKey(relationship, backPopulatesSide));
+	if (backPopulates) args.push(`back_populates="${backPopulates}"`);
+	if (context.ambiguous.has(pairKey(relationship))) {
+		const childNaming = getNaming(state, context, endTable);
+		const names = endColumns.map((column) => `${childNaming.className}.${childNaming.columnNames.get(column.id) ?? column.name}`);
+		args.push(`foreign_keys="[${names.join(", ")}]"`);
+	}
+	if (isSelfReferential(relationship) && backPopulatesSide === INVERSE) {
+		const parentNaming = getNaming(state, context, startTable);
+		const names = startColumns.map((column) => `${parentNaming.className}.${parentNaming.columnNames.get(column.id) ?? column.name}`);
+		args.push(`remote_side="[${names.join(", ")}]"`);
+	}
+	return args;
+}
+function createIndexEntries(state, table, naming, { imports, indexNames }) {
+	const { doc: { indexIds }, collections } = state;
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	const entries = [];
+	query(collections).collection("indexEntities").selectByIds(indexIds).filter((index) => index.tableId === table.id).forEach((index) => {
+		const columns = query(collections).collection("indexColumnEntities").selectByIds(index.indexColumnIds).map((indexColumn) => columnCollection.selectById(indexColumn.columnId)).filter((column) => column !== void 0);
+		if (columns.length === 0) return;
+		let indexName = index.name;
+		if (index.name.trim() === "") {
+			indexName = autoName(indexNames, "", `IDX_${table.name}`);
+			indexNames.push({
+				id: index.id,
+				name: indexName
+			});
+		}
+		const args = [pythonString(indexName)];
+		columns.forEach((column) => args.push(pythonString(columnKey(naming, column))));
+		if (index.unique) args.push("unique=True");
+		addSqlalchemy(imports, "Index");
+		entries.push({
+			head: "Index(",
+			args
+		});
+	});
+	return entries;
+}
+function formatTableArgs(buffer, entries, comment) {
+	const commentArg = comment.trim() === "" ? null : `"comment": ${pythonString(comment)}`;
+	if (entries.length === 0) {
+		if (commentArg !== null) formatCall(buffer, INDENT, "__table_args__ = {", [commentArg], "}");
+		return;
+	}
+	const single = `${INDENT}__table_args__ = (${callText(entries[0])},)`;
+	if (entries.length === 1 && commentArg === null && lineWidth(single) <= LINE_LIMIT) {
+		buffer.push(single);
+		return;
+	}
+	buffer.push(`${INDENT}__table_args__ = (`);
+	entries.forEach((entry) => {
+		formatCall(buffer, `${INDENT}${INDENT}`, entry.head, entry.args, "),");
+	});
+	if (commentArg !== null) formatCall(buffer, `${INDENT}${INDENT}`, "{", [commentArg], "},");
+	buffer.push(`${INDENT})`);
+}
+function formatCall(buffer, indent, head, args, tail) {
+	const line = `${indent}${head}${args.map(callText).join(", ")}${tail}`;
+	if (lineWidth(line) <= LINE_LIMIT) {
+		buffer.push(line);
+		return;
+	}
+	buffer.push(`${indent}${head}`);
+	args.forEach((arg) => {
+		if (typeof arg === "string") {
+			buffer.push(`${indent}${INDENT}${arg},`);
+			return;
+		}
+		formatCall(buffer, `${indent}${INDENT}`, arg.head, arg.args, "),");
+	});
+	buffer.push(`${indent}${tail}`);
+}
+function formatAssignment(buffer, attribute, annotation, head, args) {
+	const target = `${attribute}: Mapped[${annotation}]`;
+	const opening = `${INDENT}${target} = ${head}`;
+	const line = `${opening}${args.map(callText).join(", ")})`;
+	const wrapped = `${INDENT}${target} = (`;
+	if (lineWidth(line) <= LINE_LIMIT || lineWidth(opening) <= LINE_LIMIT) {
+		formatCall(buffer, INDENT, `${target} = ${head}`, args, ")");
+		return;
+	}
+	if (lineWidth(wrapped) <= LINE_LIMIT) {
+		buffer.push(wrapped);
+		formatCall(buffer, `${INDENT}${INDENT}`, head, args, ")");
+		buffer.push(`${INDENT})`);
+		return;
+	}
+	buffer.push(`${INDENT}${attribute}: Mapped[`);
+	buffer.push(`${INDENT}${INDENT}${annotation}`);
+	formatCall(buffer, INDENT, `] = ${head}`, args, ")");
+}
+var WIDE_RANGES = [
+	[4352, 4447],
+	[11904, 11929],
+	[11931, 12019],
+	[12032, 12245],
+	[12272, 12283],
+	[12288, 12329],
+	[12334, 12350],
+	[12353, 12438],
+	[12443, 12543],
+	[12549, 12591],
+	[12593, 12686],
+	[12688, 12771],
+	[12784, 12830],
+	[12832, 12871],
+	[12880, 19903],
+	[19968, 42124],
+	[42128, 42182],
+	[43360, 43388],
+	[44032, 55203],
+	[63744, 64255],
+	[65040, 65049],
+	[65072, 65106],
+	[65108, 65126],
+	[65128, 65131],
+	[65281, 65376],
+	[65504, 65510],
+	[131072, 196605],
+	[196608, 262141]
+];
+var PRINTABLE_ASCII = /^[\x20-\x7e]*$/;
+function lineWidth(line) {
+	if (PRINTABLE_ASCII.test(line)) return line.length;
+	let width = 0;
+	for (const char of line) {
+		const code = char.codePointAt(0);
+		width += WIDE_RANGES.some(([first, last]) => first <= code && code <= last) ? 2 : 1;
+	}
+	return width;
+}
+function callText(arg) {
+	return typeof arg === "string" ? arg : `${arg.head}${arg.args.join(", ")})`;
+}
+function formatImports(buffer, imports) {
+	const stdlibBuffer = [];
+	const sqlalchemyBuffer = [];
+	Array.from(imports.stdlibPlain).sort().forEach((name) => stdlibBuffer.push(`import ${name}`));
+	Array.from(imports.stdlibFrom.keys()).sort().forEach((module) => {
+		formatFromImport(stdlibBuffer, module, imports.stdlibFrom.get(module));
+	});
+	if (imports.sqlalchemy.size !== 0) formatFromImport(sqlalchemyBuffer, "sqlalchemy", imports.sqlalchemy);
+	Array.from(imports.dialects.keys()).sort().forEach((dialect) => {
+		formatFromImport(sqlalchemyBuffer, `sqlalchemy.dialects.${dialect}`, imports.dialects.get(dialect));
+	});
+	formatFromImport(sqlalchemyBuffer, "sqlalchemy.orm", imports.orm);
+	stdlibBuffer.forEach((line) => buffer.push(line));
+	if (stdlibBuffer.length !== 0) buffer.push("");
+	sqlalchemyBuffer.forEach((line) => buffer.push(line));
+}
+function formatFromImport(buffer, module, names) {
+	const sorted = sortImportNames(names);
+	const line = `from ${module} import ${sorted.join(", ")}`;
+	if (line.length <= LINE_LIMIT) {
+		buffer.push(line);
+		return;
+	}
+	buffer.push(`from ${module} import (`);
+	sorted.forEach((name) => buffer.push(`${INDENT}${name},`));
+	buffer.push(")");
+}
+var CONSTANT = /^(?=.*[A-Z])[A-Z0-9_]{2,}$/;
+function importGroup(name) {
+	return CONSTANT.test(name) ? 0 : 1;
+}
+function sortImportNames(names) {
+	return Array.from(names).sort((a, b) => {
+		const group = importGroup(a) - importGroup(b);
+		if (group !== 0) return group;
+		return a < b ? -1 : a > b ? 1 : 0;
+	});
+}
+function createImportSet() {
+	const imports = {
+		stdlibPlain: /* @__PURE__ */ new Set(),
+		stdlibFrom: /* @__PURE__ */ new Map(),
+		sqlalchemy: /* @__PURE__ */ new Set(),
+		dialects: /* @__PURE__ */ new Map(),
+		orm: /* @__PURE__ */ new Set()
+	};
+	addOrm(imports, "DeclarativeBase");
+	return imports;
+}
+function addSqlalchemy(imports, name) {
+	imports.sqlalchemy.add(name);
+}
+function addDialect(imports, dialect, name) {
+	const names = imports.dialects.get(dialect) ?? /* @__PURE__ */ new Set();
+	names.add(name);
+	imports.dialects.set(dialect, names);
+}
+function addOrm(imports, name) {
+	imports.orm.add(name);
+}
+function addStdlibPlain(imports, name) {
+	imports.stdlibPlain.add(name);
+}
+function addStdlibFrom(imports, module, name) {
+	const names = imports.stdlibFrom.get(module) ?? /* @__PURE__ */ new Set();
+	names.add(name);
+	imports.stdlibFrom.set(module, names);
+}
+var textTypes = /* @__PURE__ */ new Set([
+	"clob",
+	"long varchar",
+	"longtext",
+	"mediumtext",
+	"nclob",
+	"ntext",
+	"text",
+	"tinytext"
+]);
+var mysqlIntegerTypes = /* @__PURE__ */ new Map([
+	["bigint", ["BIGINT", "BigInteger"]],
+	["int", ["INTEGER", "Integer"]],
+	["int1", ["TINYINT", null]],
+	["int2", ["SMALLINT", "SmallInteger"]],
+	["int3", ["MEDIUMINT", null]],
+	["int4", ["INTEGER", "Integer"]],
+	["int8", ["BIGINT", "BigInteger"]],
+	["integer", ["INTEGER", "Integer"]],
+	["mediumint", ["MEDIUMINT", null]],
+	["middleint", ["MEDIUMINT", null]],
+	["smallint", ["SMALLINT", "SmallInteger"]],
+	["tinyint", ["TINYINT", null]]
+]);
+var mysqlSizedTypes = /* @__PURE__ */ new Map([
+	["clob", ["LONGTEXT", "str"]],
+	["long", ["MEDIUMTEXT", "str"]],
+	["long char varying", ["MEDIUMTEXT", "str"]],
+	["long character varying", ["MEDIUMTEXT", "str"]],
+	["long varbinary", ["MEDIUMBLOB", "bytes"]],
+	["long varchar", ["MEDIUMTEXT", "str"]],
+	["long varcharacter", ["MEDIUMTEXT", "str"]],
+	["longblob", ["LONGBLOB", "bytes"]],
+	["longtext", ["LONGTEXT", "str"]],
+	["mediumblob", ["MEDIUMBLOB", "bytes"]],
+	["mediumtext", ["MEDIUMTEXT", "str"]],
+	["tinyblob", ["TINYBLOB", "bytes"]],
+	["tinytext", ["TINYTEXT", "str"]]
+]);
+var intervalDatabases = /* @__PURE__ */ new Set([
+	Database.Databricks,
+	Database.Oracle,
+	Database.PostgreSQL
+]);
+var mysqlDecimalTypes = /* @__PURE__ */ new Set([
+	"dec",
+	"decimal",
+	"fixed",
+	"numeric"
+]);
+var mysqlYearTypes = /* @__PURE__ */ new Set(["sql_tsi_year", "year"]);
+var characterTypes = /* @__PURE__ */ new Set(["char", "character"]);
+var nationalCharacterTypes = /* @__PURE__ */ new Set([
+	"national char",
+	"national character",
+	"nchar"
+]);
+var mysqlNationalVaryingTypes = /* @__PURE__ */ new Set([
+	"national char varying",
+	"national character varying",
+	"national varchar",
+	"national varcharacter",
+	"nchar varchar",
+	"nchar varcharacter",
+	"nchar varying",
+	"nvarchar"
+]);
+var mssqlBinaryReadTypes = /* @__PURE__ */ new Set([
+	"geography",
+	"geometry",
+	"hierarchyid",
+	"sql_variant"
+]);
+var oracleObjectTypes = /* @__PURE__ */ new Set([
+	"anydata",
+	"bfile",
+	"uritype",
+	"vector"
+]);
+var mssqlNationalVaryingTypes = /* @__PURE__ */ new Set([
+	"national char varying",
+	"national character varying",
+	"nvarchar"
+]);
+var oracleNationalVaryingTypes = /* @__PURE__ */ new Set([
+	"national char varying",
+	"national character varying",
+	"nchar varying",
+	"nvarchar2"
+]);
+var postgresSmallintTypes = /* @__PURE__ */ new Set([
+	"int2",
+	"serial2",
+	"smallint",
+	"smallserial"
+]);
+var postgresTimeTypes = /* @__PURE__ */ new Set(["time", "time without time zone"]);
+var postgresTimestampTypes = /* @__PURE__ */ new Set(["timestamp", "timestamp without time zone"]);
+var postgresArrayTypes = /* @__PURE__ */ new Set([
+	"bigint",
+	"bool",
+	"boolean",
+	"bpchar",
+	"bytea",
+	"char",
+	"character",
+	"character varying",
+	"cidr",
+	"date",
+	"daterange",
+	"dec",
+	"decimal",
+	"double precision",
+	"float",
+	"float4",
+	"float8",
+	"inet",
+	"int",
+	"int2",
+	"int4",
+	"int4range",
+	"int8",
+	"int8range",
+	"integer",
+	"json",
+	"jsonb",
+	"macaddr",
+	"name",
+	"numeric",
+	"numrange",
+	"oid",
+	"real",
+	"smallint",
+	"text",
+	"time",
+	"time with time zone",
+	"time without time zone",
+	"timestamp",
+	"timestamp with time zone",
+	"timestamp without time zone",
+	"timestamptz",
+	"timetz",
+	"tsrange",
+	"tstzrange",
+	"uuid",
+	"varchar"
+]);
+var postgresNamedTypes = /* @__PURE__ */ new Map([
+	["cidr", ["CIDR", "str"]],
+	["inet", ["INET", "str"]],
+	["jsonpath", ["JSONPATH", "str"]],
+	["macaddr", ["MACADDR", "str"]],
+	["macaddr8", ["MACADDR8", "str"]],
+	["oid", ["OID", "int"]],
+	["regclass", ["REGCLASS", "str"]],
+	["regconfig", ["REGCONFIG", "str"]],
+	["tsquery", ["TSQUERY", "str"]],
+	["tsvector", ["TSVECTOR", "str"]]
+]);
+var postgresRangeTypes = /* @__PURE__ */ new Map([
+	["datemultirange", ["DATEMULTIRANGE", "date"]],
+	["daterange", ["DATERANGE", "date"]],
+	["int4multirange", ["INT4MULTIRANGE", "int"]],
+	["int4range", ["INT4RANGE", "int"]],
+	["int8multirange", ["INT8MULTIRANGE", "int"]],
+	["int8range", ["INT8RANGE", "int"]],
+	["nummultirange", ["NUMMULTIRANGE", "Decimal"]],
+	["numrange", ["NUMRANGE", "Decimal"]],
+	["tsmultirange", ["TSMULTIRANGE", "datetime"]],
+	["tsrange", ["TSRANGE", "datetime"]],
+	["tstzmultirange", ["TSTZMULTIRANGE", "datetime"]],
+	["tstzrange", ["TSTZRANGE", "datetime"]]
+]);
+var INTEGER_AFFINITY = [
+	"BIGINT",
+	"BigInteger",
+	"INTEGER",
+	"Integer",
+	"MEDIUMINT",
+	"SMALLINT",
+	"SmallInteger",
+	"TINYINT"
+];
+var DECIMAL_AFFINITY = [
+	"DECIMAL",
+	"DOUBLE",
+	"Double",
+	"FLOAT",
+	"Float",
+	"Numeric",
+	"REAL"
+];
+var INTEGER_NAMES = new Set(INTEGER_AFFINITY);
+var NUMERIC_NAMES = /* @__PURE__ */ new Set([...INTEGER_AFFINITY, ...DECIMAL_AFFINITY]);
+var POSTGRES_IDENTITY_TYPES = /* @__PURE__ */ new Set([
+	"bigint",
+	"int",
+	"int2",
+	"int4",
+	"int8",
+	"integer",
+	"smallint"
+]);
+var DATABRICKS_IDENTITY_TYPES = /* @__PURE__ */ new Set(["bigint", "long"]);
+function isNumberedByDatabase({ column, columnType, type }, database, isSoleKey) {
+	if (!bHas(column.options, ColumnOption.autoIncrement) || !type.isNumeric) return false;
+	const name = column.dataType.trim().toLowerCase();
+	switch (database) {
+		case Database.PostgreSQL: return columnType.isSerial || POSTGRES_IDENTITY_TYPES.has(name);
+		case Database.SQLite: return isSqliteIntegerKey(column, database, isSoleKey);
+		case Database.Databricks: return DATABRICKS_IDENTITY_TYPES.has(name);
+		case Database.MySQL: return type.isInteger;
+		case Database.MariaDB: return type.isInteger || columnType.isFloat;
+		case Database.MSSQL: return type.isInteger || !columnType.isFloat && (columnType.scale ?? 0) === 0;
+	}
+	return true;
+}
+var SQLITE_ROWID_TYPE = "INTEGER";
+function isSqliteIntegerKey(column, database, isSoleKey) {
+	return database === Database.SQLite && isSoleKey && bHas(column.options, ColumnOption.primaryKey) && bHas(column.options, ColumnOption.autoIncrement) && isIntegerFamily(column.dataType);
+}
+var ZEROFILL = /(^|[^0-9a-z_])zerofill([^0-9a-z_]|$)/i;
+var ORACLE_DAY_TO_SECOND = /^\s*interval\s+day\s*(?:\(\s*(\d+)\s*\))?\s+to\s+second\s*(?:\(\s*(\d+)\s*\))?\s*$/i;
+function getSqlalchemyType(column, database, imports) {
+	if (column.arrayDepth === 0) return elementType(column, database, imports);
+	if (!column.isListed || !postgresArrayTypes.has(column.base) && column.scalar !== "interval") return coreType(imports, "String", "str");
+	const element = elementType(column, database, imports);
+	const dimensions = column.arrayDepth > 1 ? `, dimensions=${column.arrayDepth}` : "";
+	addSqlalchemy(imports, "ARRAY");
+	addStdlibFrom(imports, "typing", "List");
+	return {
+		expression: `ARRAY(${element.expression}${dimensions})`,
+		annotation: `${"List[".repeat(column.arrayDepth)}${element.annotation}${"]".repeat(column.arrayDepth)}`,
+		isNumeric: false,
+		isInteger: false
+	};
+}
+function elementType(column, database, imports) {
+	switch (database) {
+		case Database.MariaDB:
+		case Database.MySQL: return mysqlType(column, database, imports) ?? portableType(column, database, imports);
+		case Database.PostgreSQL: return postgresType(column, imports) ?? portableType(column, database, imports);
+		case Database.MSSQL: return mssqlType(column, imports) ?? portableType(column, database, imports);
+		case Database.Oracle: return oracleType(column, imports) ?? portableType(column, database, imports);
+	}
+	return portableType(column, database, imports);
+}
+function portableType(column, database, imports) {
+	const { base, element, args } = column;
+	if (textTypes.has(base)) return coreType(imports, "Text", "str");
+	if (BINARY_TYPES.has(base)) return coreType(imports, "LargeBinary", "bytes");
+	if (base === "jsonb" && database === Database.PostgreSQL) {
+		addStdlibFrom(imports, "typing", "Any");
+		return dialectType(imports, "postgresql", "JSONB", "Any");
+	}
+	if (JSON_TYPES.has(base)) {
+		addStdlibFrom(imports, "typing", "Any");
+		return coreType(imports, "JSON", "Any");
+	}
+	if (base === "uuid" && database === Database.PostgreSQL) {
+		addStdlibPlain(imports, "uuid");
+		return dialectType(imports, "postgresql", "UUID", "uuid.UUID", "(as_uuid=True)");
+	}
+	if (UUID_TYPES.has(base)) {
+		addStdlibPlain(imports, "uuid");
+		return coreType(imports, "Uuid", "uuid.UUID");
+	}
+	if (TIMESTAMP_TZ_TYPES.has(base)) return coreType(imports, "DateTime", "datetime", "(timezone=True)");
+	if (POSTGRES_TIME_TZ_TYPES.has(base)) return coreType(imports, "Time", "time", "(timezone=True)");
+	if (column.scalar === "interval" && intervalDatabases.has(database)) return coreType(imports, "Interval", "timedelta");
+	const primitiveType = getPrimitiveType(element, database);
+	const callable = convertTypeMap[primitiveType];
+	const annotation = annotationMap[primitiveType];
+	if (primitiveType === "string") return coreType(imports, callable, annotation, lengthArgument(column));
+	if (primitiveType === "decimal" && (args.length === 1 || args.length === 2)) return coreType(imports, callable, annotation, `(${args.join(", ")})`);
+	if (primitiveType === "decimal" && column.precision !== null && column.scale !== null) return coreType(imports, callable, annotation, `(${column.precision}, ${column.scale})`);
+	return coreType(imports, callable, annotation);
+}
+function lengthValue({ args, length }) {
+	const value = length ?? (args.length === 1 ? args[0] : null);
+	return value !== null && value > 0 ? value : null;
+}
+function lengthArgument(column) {
+	const value = lengthValue(column);
+	return value === null ? "" : `(${value})`;
+}
+function mysqlType(column, database, imports) {
+	const { base, args } = column;
+	const isMariaDB = database === Database.MariaDB;
+	const length = lengthArgument(column);
+	const fsp = args.length === 1 && args[0] > 0 ? `(fsp=${args[0]})` : "";
+	const integer = mysqlIntegerTypes.get(base);
+	const sized = mysqlSizedTypes.get(base);
+	if (column.enumMembers) return memberCall(coreType(imports, "Enum", "str"), column.enumMembers);
+	if (column.setMembers) {
+		addStdlibFrom(imports, "typing", "Set");
+		return {
+			...memberCall(dialectType(imports, "mysql", "SET", "str"), column.setMembers),
+			annotation: "Set[str]"
+		};
+	}
+	if (column.network === "ipv4") return dialectType(imports, "mysql", "INET4", "str");
+	if (column.network === "ipv6") return dialectType(imports, "mysql", "INET6", "str");
+	if (isMariaDB && base === "uuid") {
+		addStdlibPlain(imports, "uuid");
+		return coreType(imports, "UUID", "uuid.UUID");
+	}
+	if (base === "serial") return dialectType(imports, "mysql", "BIGINT", "int", "(unsigned=True)");
+	if (integer) return mysqlInteger(column, integer, imports);
+	if (base === "bit") return dialectType(imports, "mysql", "BIT", "int", length);
+	if (mysqlYearTypes.has(base)) return dialectType(imports, "mysql", "YEAR", "int");
+	if (mysqlDecimalTypes.has(base) && column.isUnsigned) return dialectType(imports, "mysql", "DECIMAL", "Decimal", `(${[...[column.precision, column.scale].filter((value) => value !== null), ...unsignedOptions(column)].join(", ")})`);
+	if (column.isFloat && column.isUnsigned) {
+		const isDouble = column.scalar === "f64";
+		const options = unsignedOptions(column);
+		return dialectType(imports, "mysql", isDouble ? "DOUBLE" : "FLOAT", "float", `(${(isDouble ? [...options, "asdecimal=False"] : options).join(", ")})`);
+	}
+	if (sized && (base !== "clob" || isMariaDB)) return dialectType(imports, "mysql", sized[0], sized[1]);
+	if (base === "text" && args.length === 1) return coreType(imports, "Text", "str", `(${args[0]})`);
+	if (base === "blob" && args.length === 1) return coreType(imports, "LargeBinary", "bytes", `(${args[0]})`);
+	if (base === "binary" || base === "char byte") return coreType(imports, "BINARY", "bytes", length);
+	if ((base === "varbinary" || isMariaDB && base === "raw") && length !== "") return coreType(imports, "VARBINARY", "bytes", length);
+	if (isMariaDB && base === "number" && column.precision === null) return coreType(imports, "Double", "float");
+	if (characterTypes.has(base)) return coreType(imports, "CHAR", "str", length);
+	if (nationalCharacterTypes.has(base)) return coreType(imports, "NCHAR", "str", length);
+	if (mysqlNationalVaryingTypes.has(base) && length !== "") return dialectType(imports, "mysql", "VARCHAR", "str", `(${lengthValue(column)}, charset="utf8mb3")`);
+	if (base === "timestamp") return dialectType(imports, "mysql", "TIMESTAMP", "datetime", fsp);
+	if (base === "datetime" && fsp !== "") return dialectType(imports, "mysql", "DATETIME", "datetime", fsp);
+	if (base === "time" && fsp !== "") return dialectType(imports, "mysql", "TIME", "time", fsp);
+	return null;
+}
+function mysqlInteger(column, [name, signed], imports) {
+	const { args, element } = column;
+	const options = unsignedOptions(column);
+	const width = args.length === 1 ? args[0] : null;
+	if (!column.isUnsigned && signed) return coreType(imports, signed, "int");
+	const values = width !== null && (ZEROFILL.test(element) || name === "TINYINT" && width === 1) ? [String(width), ...options] : options;
+	return dialectType(imports, "mysql", name, "int", values.length === 0 ? "" : `(${values.join(", ")})`);
+}
+function unsignedOptions({ element, isUnsigned }) {
+	if (ZEROFILL.test(element)) return ["unsigned=True", "zerofill=True"];
+	return isUnsigned ? ["unsigned=True"] : [];
+}
+function postgresType(column, imports) {
+	const { base, args } = column;
+	const precision = args.length === 1 ? args[0] : null;
+	const length = lengthArgument(column);
+	const named = postgresNamedTypes.get(base);
+	const range = postgresRangeTypes.get(base);
+	if (column.isTextInteger) return coreType(imports, "String", "str");
+	if (postgresSmallintTypes.has(base)) return coreType(imports, "SmallInteger", "int");
+	if (column.scalar === "f32") return coreType(imports, "REAL", "float");
+	if (characterTypes.has(base) || base === "bpchar" && length !== "") return coreType(imports, "CHAR", "str", length);
+	if (column.isBitString) {
+		const values = length === "" ? [] : [String(args[0])];
+		if (base !== "bit") values.push("varying=True");
+		return dialectType(imports, "postgresql", "BIT", "str", values.length === 0 ? "" : `(${values.join(", ")})`);
+	}
+	if (column.isMoney) return dialectType(imports, "postgresql", "MONEY", "str");
+	if (named) return dialectType(imports, "postgresql", named[0], named[1]);
+	if (range) {
+		const isMultirange = base.endsWith("multirange");
+		addDialect(imports, "postgresql", "Range");
+		if (isMultirange) addStdlibFrom(imports, "typing", "List");
+		return {
+			...dialectType(imports, "postgresql", range[0], range[1]),
+			annotation: isMultirange ? `List[Range[${range[1]}]]` : `Range[${range[1]}]`
+		};
+	}
+	if (column.scalar === "interval") return postgresInterval(base, precision, imports);
+	if (precision === null) return null;
+	if (postgresTimeTypes.has(base) || POSTGRES_TIME_TZ_TYPES.has(base)) return dialectType(imports, "postgresql", "TIME", "time", timePrecision(postgresTimeTypes.has(base), precision));
+	if (postgresTimestampTypes.has(base) || TIMESTAMP_TZ_TYPES.has(base)) return dialectType(imports, "postgresql", "TIMESTAMP", "datetime", timePrecision(postgresTimestampTypes.has(base), precision));
+	return null;
+}
+function timePrecision(isNaive, precision) {
+	return isNaive ? `(precision=${precision})` : `(timezone=True, precision=${precision})`;
+}
+function postgresInterval(base, precision, imports) {
+	const fields = base.slice(8).trim();
+	const values = [];
+	if (fields !== "") values.push(`fields="${fields}"`);
+	if (precision !== null) values.push(`precision=${precision}`);
+	if (values.length === 0) return coreType(imports, "Interval", "timedelta");
+	return dialectType(imports, "postgresql", "INTERVAL", "timedelta", `(${values.join(", ")})`);
+}
+function mssqlType(column, imports) {
+	const { base } = column;
+	const length = lengthArgument(column);
+	if (column.isRowVersion) return dialectType(imports, "mssql", "TIMESTAMP", "bytes");
+	if (mssqlBinaryReadTypes.has(base)) return coreType(imports, "String", "bytes");
+	if (base === "money") return dialectType(imports, "mssql", "MONEY", "Decimal");
+	if (base === "smallmoney") return dialectType(imports, "mssql", "SMALLMONEY", "Decimal");
+	if (mssqlNationalVaryingTypes.has(base)) return coreType(imports, "NVARCHAR", "str", length);
+	if (characterTypes.has(base)) return coreType(imports, "CHAR", "str", length);
+	if (nationalCharacterTypes.has(base)) return coreType(imports, "NCHAR", "str", length);
+	if (base === "ntext" || base === "national text") return dialectType(imports, "mssql", "NTEXT", "str");
+	if (base === "binary") return coreType(imports, "BINARY", "bytes", length);
+	if ((base === "varbinary" || base === "binary varying") && length !== "") return coreType(imports, "VARBINARY", "bytes", length);
+	return null;
+}
+function oracleType(column, imports) {
+	const { base, element } = column;
+	const length = lengthArgument(column);
+	if (oracleObjectTypes.has(base)) {
+		addStdlibFrom(imports, "typing", "Any");
+		return {
+			...portableType(column, Database.Oracle, imports),
+			annotation: "Any"
+		};
+	}
+	if (base === "date") return dialectType(imports, "oracle", "DATE", "datetime");
+	if (base === "timestamp") return dialectType(imports, "oracle", "TIMESTAMP", "datetime");
+	if (base === "timestamp with time zone") return dialectType(imports, "oracle", "TIMESTAMP", "datetime", "(timezone=True)");
+	if (base === "timestamp with local time zone") return dialectType(imports, "oracle", "TIMESTAMP", "datetime", "(local_timezone=True)");
+	if (oracleNationalVaryingTypes.has(base) && length !== "") return dialectType(imports, "oracle", "NVARCHAR2", "str", length);
+	if (characterTypes.has(base)) return coreType(imports, "CHAR", "str", length);
+	if (nationalCharacterTypes.has(base)) return coreType(imports, "NCHAR", "str", length);
+	if (base === "nclob") return dialectType(imports, "oracle", "NCLOB", "str");
+	if (base === "raw" && length !== "") return dialectType(imports, "oracle", "RAW", "bytes", length);
+	const daySecond = ORACLE_DAY_TO_SECOND.exec(element);
+	if (daySecond) {
+		const [, day, second] = daySecond;
+		const values = [day === void 0 ? null : `day_precision=${day}`, second === void 0 ? null : `second_precision=${second}`].filter((value) => value !== null);
+		return coreType(imports, "Interval", "timedelta", values.length === 0 ? "" : `(${values.join(", ")})`);
+	}
+	return null;
+}
+function coreType(imports, name, annotation, args = "") {
+	addSqlalchemy(imports, name);
+	addAnnotationImport(imports, annotation);
+	return {
+		expression: `${name}${args}`,
+		annotation,
+		isNumeric: NUMERIC_NAMES.has(name),
+		isInteger: INTEGER_NAMES.has(name)
+	};
+}
+function dialectType(imports, dialect, name, annotation, args = "") {
+	addDialect(imports, dialect, name);
+	addAnnotationImport(imports, annotation);
+	return {
+		expression: `${name}${args}`,
+		annotation,
+		isNumeric: NUMERIC_NAMES.has(name),
+		isInteger: INTEGER_NAMES.has(name)
+	};
+}
+function addAnnotationImport(imports, annotation) {
+	switch (annotation) {
+		case "Decimal":
+			addStdlibFrom(imports, "decimal", "Decimal");
+			break;
+		case "date":
+		case "datetime":
+		case "time":
+		case "timedelta": addStdlibFrom(imports, "datetime", annotation);
+	}
+}
+var PYTHON_ESCAPES = /* @__PURE__ */ new Map([
+	["\\", "\\\\"],
+	["\n", "\\n"],
+	["\r", "\\r"],
+	["	", "\\t"]
+]);
+function memberCall(type, members) {
+	const call = {
+		head: `${type.expression}(`,
+		args: members.map(pythonString)
+	};
+	return {
+		...type,
+		expression: callText(call),
+		call
+	};
+}
+function pythonString(value) {
+	const chars = Array.from(value);
+	const quote = chars.filter((char) => char === "\"").length > chars.filter((char) => char === "'").length ? "'" : "\"";
+	return `${quote}${escapeChars(chars, quote)}${quote}`;
+}
+function escapeChars(chars, quote) {
+	return chars.map((char) => {
+		if (char === quote) return `\\${char}`;
+		const escaped = PYTHON_ESCAPES.get(char);
+		if (escaped !== void 0) return escaped;
+		const code = char.charCodeAt(0);
+		return code < 32 || code === 127 ? `\\x${code.toString(16).padStart(2, "0")}` : char;
+	}).join("");
+}
+function createClassContext(state) {
+	const relationships = resolveRelationships(state);
+	const counts = /* @__PURE__ */ new Map();
+	const ambiguous = /* @__PURE__ */ new Set();
+	relationships.forEach(({ relationship }) => {
+		const key = pairKey(relationship);
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	});
+	counts.forEach((count, key) => {
+		if (count > 1) ambiguous.add(key);
+	});
+	const context = {
+		imports: createImportSet(),
+		indexNames: [],
+		relationships,
+		namings: /* @__PURE__ */ new Map(),
+		classNames: new Set(MODULE_SCOPE_NAMES),
+		ambiguous
+	};
+	query(state.collections).collection("tableEntities").selectByIds(state.doc.tableIds).sort(orderByNameASC).forEach((table) => getNaming(state, context, table));
+	return context;
+}
+function resolveRelationships(state) {
+	const { doc: { relationshipIds }, collections } = state;
+	const tableCollection = query(collections).collection("tableEntities");
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	return query(collections).collection("relationshipEntities").selectByIds(relationshipIds).map((relationship) => {
+		const startTable = tableCollection.selectById(relationship.start.tableId);
+		const endTable = tableCollection.selectById(relationship.end.tableId);
+		const startColumns = columnCollection.selectByIds(relationship.start.columnIds);
+		const endColumns = columnCollection.selectByIds(relationship.end.columnIds);
+		return !startTable || !endTable || endColumns.length === 0 || startColumns.length !== relationship.start.columnIds.length || endColumns.length !== relationship.end.columnIds.length || startColumns.length !== endColumns.length || !startColumns.every((column) => startTable.columnIds.includes(column.id)) || !endColumns.every((column) => endTable.columnIds.includes(column.id)) ? null : {
+			relationship,
+			startTable,
+			endTable,
+			startColumns,
+			endColumns
+		};
+	}).filter((resolved) => resolved !== null);
+}
+function getNaming(state, context, table) {
+	const cached = context.namings.get(table.id);
+	if (cached) return cached;
+	const naming = createTableNaming(state, table, context);
+	context.namings.set(table.id, naming);
+	return naming;
+}
+function createTableNaming(state, table, { relationships, classNames }) {
+	const { settings: { tableNameCase, columnNameCase }, collections } = state;
+	const used = new Set(MODULE_SCOPE_NAMES);
+	const declared = [];
+	const columnRefs = /* @__PURE__ */ new Map();
+	const columnNames = /* @__PURE__ */ new Map();
+	const columnKeys = /* @__PURE__ */ new Map();
+	const relationshipNames = /* @__PURE__ */ new Map();
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	const carriers = /* @__PURE__ */ new Map();
+	columns.forEach((column) => {
+		const carrier = carriers.get(column.name);
+		if (carrier !== void 0) {
+			columnRefs.set(column.id, carrier);
+			return;
+		}
+		carriers.set(column.name, column.id);
+		columnRefs.set(column.id, column.id);
+		declared.push(column);
+		columnNames.set(column.id, uniqueName(used, pyIdentifier(getNameCase(column.name, columnNameCase))));
+	});
+	assignColumnKeys(declared, columnNames, columnKeys);
+	columns.forEach((column) => {
+		const carrier = columnRefs.get(column.id);
+		if (carrier === void 0 || carrier === column.id) return;
+		const name = columnNames.get(carrier);
+		const key = columnKeys.get(carrier);
+		if (name !== void 0) columnNames.set(column.id, name);
+		if (key !== void 0) columnKeys.set(column.id, key);
+	});
+	relationships.filter(({ relationship }) => relationship.end.tableId === table.id).forEach(({ relationship, startTable }) => {
+		if (!hasOneRelationship(relationship.relationshipType) && !hasNRelationship(relationship.relationshipType)) return;
+		const name = isSelfReferential(relationship) ? `parent_${startTable.name}` : startTable.name;
+		relationshipNames.set(relationshipKey(relationship, OWNING), uniqueName(used, pyIdentifier(getNameCase(name, columnNameCase))));
+	});
+	relationships.filter(({ relationship }) => relationship.start.tableId === table.id).forEach(({ relationship, endTable }) => {
+		const name = hasNRelationship(relationship.relationshipType) ? getNameCase(`${endTable.name}List`, columnNameCase) : hasOneRelationship(relationship.relationshipType) ? getNameCase(endTable.name, columnNameCase) : null;
+		if (name === null) return;
+		relationshipNames.set(relationshipKey(relationship, INVERSE), uniqueName(used, pyIdentifier(name)));
+	});
+	return {
+		className: uniqueName(classNames, pyIdentifier(getNameCase(table.name, tableNameCase))),
+		columnIds: declared.map((column) => column.id),
+		columnRefs,
+		columnNames,
+		columnKeys,
+		relationshipNames
+	};
+}
+var DOT = ".";
+function assignColumnKeys(declared, columnNames, columnKeys) {
+	const used = /* @__PURE__ */ new Set();
+	declared.forEach((column) => {
+		if (!column.name.includes(DOT)) {
+			used.add(column.name);
+			columnKeys.set(column.id, column.name);
+		}
+	});
+	declared.forEach((column) => {
+		if (column.name.includes(DOT)) columnKeys.set(column.id, uniqueName(used, columnNames.get(column.id) ?? column.name));
+	});
+}
+function columnKey(naming, column) {
+	return naming.columnKeys.get(column.id) ?? column.name;
+}
+function columnRef(naming, column) {
+	return naming.columnRefs.get(column.id) ?? column.id;
+}
+function carriedColumns(state, naming, columns) {
+	const collection = query(state.collections).collection("tableColumnEntities");
+	return columns.map((column) => collection.selectById(columnRef(naming, column)) ?? column);
+}
+function relationshipKey(relationship, side) {
+	return `${relationship.id}:${side}`;
+}
+function isSelfReferential(relationship) {
+	return relationship.start.tableId === relationship.end.tableId;
+}
+function pairKey(relationship) {
+	const [first, second] = [relationship.start.tableId, relationship.end.tableId].sort();
+	return `${first}<->${second}`;
+}
+function uniqueName(used, name) {
+	let result = name;
+	let index = 2;
+	while (used.has(result)) {
+		result = `${name}_${index}`;
+		index += 1;
+	}
+	used.add(result);
+	return result;
+}
+var NON_IDENTIFIER = /[^0-9A-Za-z_]/g;
+var IDENTIFIER_START = /^[A-Za-z]/;
+var RESERVED = /* @__PURE__ */ new Set([
+	"False",
+	"None",
+	"True",
+	"and",
+	"as",
+	"assert",
+	"async",
+	"await",
+	"break",
+	"class",
+	"continue",
+	"def",
+	"del",
+	"elif",
+	"else",
+	"except",
+	"finally",
+	"for",
+	"from",
+	"global",
+	"if",
+	"import",
+	"in",
+	"is",
+	"lambda",
+	"metadata",
+	"nonlocal",
+	"not",
+	"or",
+	"pass",
+	"raise",
+	"return",
+	"self",
+	"try",
+	"while",
+	"with",
+	"yield"
+]);
+var SAFE_PREFIX = "x";
+function pyIdentifier(name) {
+	const value = name.replace(NON_IDENTIFIER, "_");
+	const identifier = IDENTIFIER_START.test(value) ? value : `${SAFE_PREFIX}${value}`;
+	return RESERVED.has(identifier) ? `${identifier}_` : identifier;
+}
+var NEWLINE = /\r\n|\r|\n/g;
+var PYTHON_SPACE = /^[ \x85\xa0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]+|[ \x85\xa0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]+$/g;
+function formatDocstring(comment) {
+	const value = escapeChars(Array.from(comment.replace(NEWLINE, " ")), "\"").replace(PYTHON_SPACE, "");
+	if (value === "") return " ";
+	return value.endsWith("\"") ? `${value} ` : value;
+}
+function formatStringList(names) {
+	return `[${names.map(pythonString).join(", ")}]`;
+}
+//#endregion
+export { createCode, formatTable };