@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,581 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { BracketType, ColumnOption, Database, ReferentialAction } from "../../constants/schema.js";
+import { bHas } from "../bit.js";
+import { isDelimitedPart, orderByNameASC, splitNameParts, unquoteNamePart } from "../tableName.js";
+import { referentialActionSupport, toForeignKeyPairs } from "../schema-sql/utils.js";
+import { isIntegerFamily } from "../schema-sql/SQLite.js";
+import { hasOneRelationship } from "./utils.js";
+import { stripIdWord } from "./graphql.js";
+import { getRustColumnType } from "./rustTypes.js";
+import { INDENT, toRustIdentifier } from "./rust.js";
+import { toSnakeCase, toUpperCamelCase } from "./heck.js";
+//#region src/utils/generator-code/seaorm.ts
+var PRELUDE_TYPES = {
+	bool: "bool",
+	i8: "i8",
+	i16: "i16",
+	i32: "i32",
+	i64: "i64",
+	u8: "u8",
+	u16: "u16",
+	u32: "u32",
+	u64: "u64",
+	f32: "f32",
+	f64: "f64",
+	decimal: "Decimal",
+	string: "String",
+	bytes: "Vec<u8>",
+	uuid: "Uuid",
+	json: "Json",
+	date: "Date",
+	time: "Time",
+	dateTime: "DateTime",
+	dateTimeUtc: "DateTimeUtc",
+	dateTimeOffset: "DateTimeWithTimeZone"
+};
+var SQLITE_TYPES = {
+	bool: "boolean",
+	i8: "tinyint",
+	i16: "smallint",
+	i32: "integer",
+	i64: "integer",
+	u8: "tinyint",
+	u16: "smallint",
+	u32: "integer",
+	u64: "integer",
+	f32: "float",
+	f64: "double",
+	decimal: "real_decimal",
+	string: "varchar",
+	bytes: "varbinary_blob",
+	uuid: "uuid_text",
+	json: "json_text",
+	date: "date_text",
+	time: "time_text",
+	dateTime: "datetime_text",
+	dateTimeUtc: "timestamp_with_timezone_text",
+	dateTimeOffset: "timestamp_with_timezone_text"
+};
+var POSTGRES_NATIVE_TYPES = /* @__PURE__ */ new Set([
+	"bigint",
+	"bool",
+	"boolean",
+	"bytea",
+	"character varying",
+	"date",
+	"decimal",
+	"double precision",
+	"float",
+	"float4",
+	"float8",
+	"int",
+	"int2",
+	"int4",
+	"int8",
+	"integer",
+	"json",
+	"numeric",
+	"real",
+	"smallint",
+	"time",
+	"time without time zone",
+	"timestamp",
+	"timestamp with time zone",
+	"timestamp without time zone",
+	"timestamptz",
+	"uuid",
+	"varchar"
+]);
+var POSTGRES_COLUMN_TYPES = /* @__PURE__ */ new Map([
+	["bit", "Bit(None)"],
+	["cidr", "Cidr"],
+	["inet", "Inet"],
+	["interval", "Interval(None, None)"],
+	["jsonb", "JsonBinary"],
+	["macaddr", "MacAddr"],
+	["money", "Money(None)"],
+	["text", "Text"]
+]);
+var MYSQL_NATIVE_TYPES = /* @__PURE__ */ new Set([
+	"bool",
+	"boolean",
+	"date",
+	"datetime",
+	"dec",
+	"decimal",
+	"double",
+	"double precision",
+	"fixed",
+	"float",
+	"float4",
+	"float8",
+	"json",
+	"numeric",
+	"real",
+	"time",
+	"timestamp"
+]);
+var MYSQL_INTEGER_TYPES = /* @__PURE__ */ new Set([
+	"bigint",
+	"int",
+	"int1",
+	"int2",
+	"int4",
+	"int8",
+	"integer",
+	"smallint",
+	"tinyint"
+]);
+var DECIMAL_TYPES = /* @__PURE__ */ new Set([
+	"dec",
+	"decimal",
+	"fixed",
+	"numeric"
+]);
+var VARCHAR_TYPES = /* @__PURE__ */ new Set(["character varying", "varchar"]);
+var CHAR_TYPES = /* @__PURE__ */ new Set(["char", "character"]);
+var UNSIGNED_SCALARS = /* @__PURE__ */ new Set([
+	"u8",
+	"u16",
+	"u32",
+	"u64"
+]);
+var BACKTICK_DATABASES = /* @__PURE__ */ new Set([
+	Database.Databricks,
+	Database.MariaDB,
+	Database.MySQL,
+	Database.SQLite
+]);
+var REFERENTIAL_ACTION_NAMES = {
+	[ReferentialAction.noAction]: "NoAction",
+	[ReferentialAction.cascade]: "Cascade",
+	[ReferentialAction.setNull]: "SetNull",
+	[ReferentialAction.setDefault]: "SetDefault",
+	[ReferentialAction.restrict]: "Restrict"
+};
+var NON_XID_CONTINUE = /[^\p{XID_Continue}]/gu;
+var XID_START = /^\p{XID_Start}$/u;
+var LEADING_UNDERSCORES = /^_+/;
+var ASCII_CAPITALS = /[A-Z]+/g;
+var BACKTICKED = /^`((?:[^`]|``)*)`$/;
+var ZEROFILL = /(^|[^0-9a-z_])zerofill([^0-9a-z_]|$)/i;
+var RAW_PREFIX = /^r#/;
+var SHADOWING_FIELDS = /* @__PURE__ */ new Set([
+	"parent_key",
+	"parent_key_for",
+	"parent_key_for_self_rev"
+]);
+var NUMERIC_AFFINITIES = /* @__PURE__ */ new Set([
+	"INTEGER",
+	"NUMERIC",
+	"REAL"
+]);
+var ATTRIBUTE_ITEMS_WIDTH = 70;
+var LINE_WIDTH = 100;
+function createCode(state) {
+	const context = createEntityContext(state);
+	const buffer = [""];
+	context.tables.forEach((table) => {
+		buffer.push(`pub mod ${getModule(context, table).name} {`);
+		formatEntity(state, context, table, buffer, INDENT);
+		buffer.push("}", "");
+	});
+	return buffer.join("\n");
+}
+function createTableCode(state, table) {
+	const buffer = [""];
+	formatEntity(state, createEntityContext(state), table, buffer, "");
+	buffer.push("");
+	return buffer.join("\n");
+}
+function formatEntity(state, context, table, buffer, indent) {
+	const naming = getNaming(state, context, table);
+	const columns = query(state.collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	const types = columns.map((column) => getEntityColumnType(column.dataType, state.settings.database));
+	const fieldIndent = `${indent}${INDENT}`;
+	const body = [];
+	columns.forEach((column, index) => {
+		const field = naming.fields.get(column.id);
+		const { type, columnType, selectAs, saveAs } = types[index];
+		const sqlName = sqlNamePart(state, column.name);
+		const items = [];
+		if (derivedColumnName(field) !== sqlName) items.push(`column_name = ${rustString(sqlName)}`);
+		if (isPrimaryKey(column)) {
+			items.push("primary_key");
+			if (!bHas(column.options, ColumnOption.autoIncrement)) items.push("auto_increment = false");
+		}
+		if (columnType !== null) items.push(`column_type = ${rustString(columnType)}`);
+		if (selectAs !== null) items.push(`select_as = ${rustString(selectAs)}`);
+		if (saveAs !== null) items.push(`save_as = ${rustString(saveAs)}`);
+		if (naming.uniqueIds.has(column.id)) items.push("unique");
+		const uniqueKey = naming.uniqueKeys.get(column.id);
+		if (uniqueKey !== void 0) items.push(`unique_key = ${rustString(uniqueKey)}`);
+		if (column.comment.trim() !== "") items.push(`comment = ${rustString(column.comment)}`);
+		formatAttribute(body, fieldIndent, items);
+		body.push(`${fieldIndent}pub ${field}: ${isNullable(column) ? `Option<${type}>` : type},`);
+	});
+	naming.relations.forEach((relation) => {
+		formatAttribute(body, fieldIndent, relationItems(state, context, naming, relation));
+		body.push(`${fieldIndent}pub ${relation.field}: ${relationType(relation)},`);
+	});
+	const derives = types.some(({ isFloat }) => isFloat) ? "Clone, Debug, PartialEq, DeriveEntityModel" : "Clone, Debug, PartialEq, Eq, DeriveEntityModel";
+	buffer.push(`${indent}use sea_orm::entity::prelude::*;`, "", `${indent}#[sea_orm::model]`, `${indent}#[derive(${derives})]`);
+	formatAttribute(buffer, indent, tableItems(state, table));
+	if (body.length === 0) buffer.push(`${indent}pub struct Model {}`);
+	else buffer.push(`${indent}pub struct Model {`, ...body, `${indent}}`);
+	buffer.push("", `${indent}impl ActiveModelBehavior for ActiveModel {}`);
+}
+function tableItems(state, table) {
+	const items = [];
+	const [schema, name] = sqlTableName(state, table.name);
+	if (schema !== null) items.push(`schema_name = ${rustString(schema)}`);
+	items.push(`table_name = ${rustString(name)}`);
+	if (table.comment.trim() !== "") items.push(`comment = ${rustString(table.comment)}`);
+	return items;
+}
+function relationItems(state, context, naming, { kind, resolved, variant, isExplicit }) {
+	const reverse = resolved.isSelf ? naming.relations.find((relation) => relation.resolved === resolved && relation.kind !== kind) : void 0;
+	const items = reverse ? [
+		"self_ref",
+		`relation_enum = "${variant}"`,
+		`relation_reverse = "${reverse.variant}"`
+	] : [kind, ...isExplicit ? [`relation_enum = "${variant}"`] : []];
+	if (kind !== "belongs_to") {
+		if (!reverse && resolved.isNamed) {
+			const child = getNaming(state, context, resolved.endTable).relations.find((relation) => relation.resolved === resolved && relation.kind === "belongs_to");
+			items.push(`via_rel = "${child.variant}"`);
+		}
+		return items;
+	}
+	const { database } = state.settings;
+	const support = referentialActionSupport(database);
+	const { onDelete, onUpdate } = resolved.relationship;
+	const fieldsOf = (table, columns) => {
+		const { fields } = getNaming(state, context, table);
+		const names = columns.map((column) => fields.get(column.id));
+		return names.length === 1 ? names[0] : `(${names.join(", ")})`;
+	};
+	items.push(`from = "${fieldsOf(resolved.endTable, resolved.end)}"`, `to = "${fieldsOf(resolved.startTable, resolved.start)}"`);
+	if (support.onUpdate.includes(onUpdate)) items.push(`on_update = "${REFERENTIAL_ACTION_NAMES[onUpdate]}"`);
+	if (support.onDelete.includes(onDelete)) items.push(`on_delete = "${REFERENTIAL_ACTION_NAMES[onDelete]}"`);
+	return items;
+}
+function relationType({ kind, target, isOptional }) {
+	switch (kind) {
+		case "belongs_to": return `BelongsTo<${isOptional ? `Option<${target}>` : target}>`;
+		case "has_one": return `HasOne<${target}>`;
+		default: return `HasMany<${target}>`;
+	}
+}
+function formatAttribute(buffer, indent, items) {
+	if (items.length === 0) return;
+	const line = `${indent}#[sea_orm(${items.join(", ")})]`;
+	if (items.length === 1 ? width(line) < LINE_WIDTH : width(items.join(", ")) <= ATTRIBUTE_ITEMS_WIDTH) {
+		buffer.push(line);
+		return;
+	}
+	buffer.push(`${indent}#[sea_orm(`);
+	items.forEach((item, index) => {
+		const comma = index === items.length - 1 ? "" : ",";
+		buffer.push(`${indent}${INDENT}${item}${comma}`);
+	});
+	buffer.push(`${indent})]`);
+}
+function width(text) {
+	return Array.from(text).length;
+}
+function createEntityContext(state) {
+	const context = {
+		tables: query(state.collections).collection("tableEntities").selectByIds(state.doc.tableIds).sort(orderByNameASC),
+		modules: /* @__PURE__ */ new Map(),
+		moduleNames: /* @__PURE__ */ new Set(),
+		relationships: resolveRelationships(state),
+		namings: /* @__PURE__ */ new Map()
+	};
+	context.tables.forEach((table) => getModule(context, table));
+	return context;
+}
+function resolveRelationships(state) {
+	const resolved = query(state.collections).collection("relationshipEntities").selectByIds(state.doc.relationshipIds).flatMap((relationship) => {
+		const pairs = toForeignKeyPairs(state, relationship);
+		return pairs ? [{
+			relationship,
+			...pairs,
+			isSelf: pairs.startTable.id === pairs.endTable.id,
+			isNamed: false
+		}] : [];
+	});
+	const counts = /* @__PURE__ */ new Map();
+	resolved.forEach(({ relationship }) => {
+		const key = pairKey(relationship);
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	});
+	resolved.forEach((item) => {
+		item.isNamed = item.isSelf || counts.get(pairKey(item.relationship)) > 1;
+	});
+	return resolved;
+}
+function pairKey({ start, end }) {
+	return [start.tableId, end.tableId].sort().join(":");
+}
+function getModule(context, table) {
+	const cached = context.modules.get(table.id);
+	if (cached) return cached;
+	const base = rustBase(table.name, "table");
+	const first = fieldName(base);
+	const name = claimName(base, first, (candidate) => !context.moduleNames.has(candidate));
+	const entityModule = {
+		name,
+		base: name === first ? base : name
+	};
+	context.moduleNames.add(name);
+	context.modules.set(table.id, entityModule);
+	return entityModule;
+}
+function getNaming(state, context, table) {
+	const cached = context.namings.get(table.id);
+	if (cached) return cached;
+	const columns = query(state.collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	const uniqueIndexes = uniqueIndexColumns(state, table);
+	const isSingleKey = columns.filter(isPrimaryKey).length === 1;
+	const uniqueIds = new Set(columns.filter((column) => bHas(column.options, ColumnOption.unique) && !(isSingleKey && isPrimaryKey(column) && foldsKeyUnique(state, column))).map((column) => column.id));
+	const composites = uniqueIndexes.filter(({ columnIds }) => columnIds.length > 1);
+	const keyedIds = new Set(composites.flatMap(({ columnIds }) => columnIds));
+	uniqueIndexes.filter(({ columnIds }) => columnIds.length === 1).forEach(({ columnIds }) => uniqueIds.add(columnIds[0]));
+	const used = /* @__PURE__ */ new Set();
+	const variants = /* @__PURE__ */ new Set();
+	const fields = /* @__PURE__ */ new Map();
+	columns.forEach((column) => {
+		const base = rustBase(column.name, "column");
+		const isUnique = uniqueIds.has(column.id) || keyedIds.has(column.id);
+		const isKey = isPrimaryKey(column);
+		const field = claimName(base, fieldName(base), (candidate) => !used.has(candidate) && !variants.has(columnVariant(candidate)) && !(isUnique && toUpperCamelCase(candidate) === "Self") && !(isKey && toUpperCamelCase(candidate) === "Column") && !SHADOWING_FIELDS.has(candidate));
+		used.add(field);
+		variants.add(columnVariant(field));
+		fields.set(column.id, field);
+	});
+	const naming = {
+		fields,
+		uniqueIds,
+		uniqueKeys: uniqueKeyNames(columns, composites, fields, uniqueIds),
+		relations: []
+	};
+	context.namings.set(table.id, naming);
+	naming.relations = relationFields(context, table, used);
+	return naming;
+}
+function uniqueIndexColumns({ doc: { indexIds }, collections }, table) {
+	const indexColumnCollection = query(collections).collection("indexColumnEntities");
+	return query(collections).collection("indexEntities").selectByIds(indexIds).filter((index) => index.tableId === table.id && index.unique).map((index) => ({
+		name: index.name,
+		columnIds: indexColumnCollection.selectByIds(index.indexColumnIds).map((indexColumn) => indexColumn.columnId).filter((columnId) => table.columnIds.includes(columnId))
+	})).filter(({ columnIds }) => columnIds.length > 0);
+}
+function uniqueKeyNames(columns, composites, fields, uniqueIds) {
+	const keys = /* @__PURE__ */ new Map();
+	const names = new Set(columns.filter((column) => uniqueIds.has(column.id)).map((column) => fields.get(column.id)));
+	composites.forEach(({ name, columnIds }) => {
+		if (columnIds.some((columnId) => keys.has(columnId))) return;
+		const base = rustBase(name.trim() === "" ? columnIds.map((columnId) => fields.get(columnId)).join("_") : name, "unique");
+		const key = claimName(base, fieldName(base), (candidate) => candidate !== "id" && !names.has(candidate));
+		names.add(key);
+		columnIds.forEach((columnId) => keys.set(columnId, key));
+	});
+	return keys;
+}
+function relationFields(context, table, used) {
+	const reserved = /* @__PURE__ */ new Set();
+	const relations = [];
+	const claim = (base, isOptional) => {
+		const field = claimName(base, toRustIdentifier(base), (candidate) => {
+			const plain = candidate.replace(RAW_PREFIX, "");
+			const setter = `${plain}_option`;
+			return !used.has(plain) && !reserved.has(plain) && !SHADOWING_FIELDS.has(plain) && !(isOptional && (used.has(setter) || reserved.has(setter)));
+		});
+		const plain = field.replace(RAW_PREFIX, "");
+		used.add(plain);
+		if (isOptional) reserved.add(`${plain}_option`);
+		return field;
+	};
+	const push = (kind, resolved, other, base, isOptional) => {
+		relations.push({
+			kind,
+			resolved,
+			field: claim(base, isOptional || kind === "has_one"),
+			target: resolved.isSelf ? "Entity" : `super::${getModule(context, other).name}::Entity`,
+			isOptional,
+			variant: "",
+			isExplicit: false
+		});
+	};
+	context.relationships.filter(({ endTable }) => endTable.id === table.id).forEach((resolved) => {
+		const parent = getModule(context, resolved.startTable);
+		const base = (resolved.isNamed ? foreignKeyStem(resolved) : null) ?? (resolved.isSelf ? `parent_${parent.base}` : parent.base);
+		push("belongs_to", resolved, resolved.startTable, base, resolved.end.some(isNullable));
+	});
+	context.relationships.filter(({ startTable }) => startTable.id === table.id).forEach((resolved) => {
+		const child = getModule(context, resolved.endTable).base;
+		const isOne = !resolved.isNamed && hasOneRelationship(resolved.relationship.relationshipType);
+		const stem = resolved.isNamed ? foreignKeyStem(resolved) : null;
+		const base = isOne ? child : stem === null ? `${child}_list` : `${child}_by_${stem}_list`;
+		push(isOne ? "has_one" : "has_many", resolved, resolved.endTable, base, false);
+	});
+	nameVariants(context, table, relations);
+	return relations;
+}
+function nameVariants(context, table, relations) {
+	const taken = /* @__PURE__ */ new Set();
+	relations.forEach((relation) => {
+		const target = relation.resolved.isSelf ? table : relation.kind === "belongs_to" ? relation.resolved.startTable : relation.resolved.endTable;
+		const inferred = toUpperCamelCase(getModule(context, target).name);
+		const wanted = relation.resolved.isNamed ? stableUpperCamelCase(relation.field.replace(RAW_PREFIX, "")) : inferred;
+		const stable = stableUpperCamelCase(wanted);
+		let variant = wanted;
+		for (let n = 2; taken.has(variant) || variant === "Self"; n++) variant = `${stable}${n}`;
+		taken.add(variant);
+		relation.variant = variant;
+		relation.isExplicit = relation.resolved.isNamed || variant !== inferred;
+	});
+}
+function foreignKeyStem({ end }) {
+	const stem = end.length === 1 ? stripIdWord(end[0].name) : null;
+	return stem === null || toSnakeCase(stem.normalize("NFC")) === "" ? null : rustBase(stem, "column");
+}
+function claimName(base, first, isFree) {
+	let name = first;
+	for (let n = 2; !isFree(name); n++) name = `${base}_${n}`;
+	return name;
+}
+function rustBase(name, fallback) {
+	const base = toSnakeCase(name.normalize("NFC").replace(NON_XID_CONTINUE, " ")).replace(NON_XID_CONTINUE, "_");
+	const first = Array.from(base)[0];
+	const head = Array.from(toUpperCamelCase(base))[0];
+	if (first !== void 0 && head !== void 0 && XID_START.test(first) && XID_START.test(head)) return base;
+	const rest = base.replace(LEADING_UNDERSCORES, "");
+	return rest === "" ? fallback : `${fallback}_${rest}`;
+}
+function fieldName(base) {
+	return toRustIdentifier(base) === base ? base : `${base}_`;
+}
+function columnVariant(field) {
+	const variant = toUpperCamelCase(field);
+	return variant === "Self" ? "Self_" : variant;
+}
+function derivedColumnName(field) {
+	return field === toSnakeCase(toUpperCamelCase(field)) ? field : toSnakeCase(field);
+}
+function stableUpperCamelCase(value) {
+	let current = toUpperCamelCase(value);
+	for (let next = toUpperCamelCase(current); next !== current; next = toUpperCamelCase(current)) current = next;
+	return current;
+}
+function sqlTableName(state, name) {
+	if (state.settings.bracketType !== BracketType.none) return [null, name];
+	const parts = splitNameParts(name);
+	const table = sqlNamePart(state, parts[parts.length - 1]);
+	return parts.length > 1 ? [sqlNamePart(state, parts[parts.length - 2]), table] : [null, table];
+}
+function sqlNamePart(state, part) {
+	const { bracketType, database } = state.settings;
+	if (bracketType !== BracketType.none) return part;
+	const backticked = BACKTICK_DATABASES.has(database) ? BACKTICKED.exec(part) : null;
+	if (backticked) return backticked[1].replaceAll("``", "`");
+	if (isDelimitedPart(part)) return unquoteNamePart(part);
+	return database === Database.PostgreSQL ? part.replace(ASCII_CAPITALS, (letters) => letters.toLowerCase()) : part;
+}
+function rustString(value) {
+	let literal = "\"";
+	for (const char of value) {
+		const code = char.codePointAt(0);
+		if (char === "\\" || char === "\"") literal += `\\${char}`;
+		else if (char === "\n") literal += "\\n";
+		else if (char === "\r") literal += "\\r";
+		else if (char === "	") literal += "\\t";
+		else if (code < 32 || code === 127 || code >= 8234 && code <= 8238 || code >= 8294 && code <= 8297) literal += `\\u{${code.toString(16).toUpperCase().padStart(4, "0")}}`;
+		else literal += char;
+	}
+	return `${literal}"`;
+}
+function isPrimaryKey({ options }) {
+	return bHas(options, ColumnOption.primaryKey);
+}
+function foldsKeyUnique({ settings: { database } }, column) {
+	return database === Database.PostgreSQL || database === Database.SQLite && !isSqliteRowid(column);
+}
+function isSqliteRowid({ dataType, options }) {
+	return dataType.trim().toUpperCase() === "INTEGER" || bHas(options, ColumnOption.autoIncrement) && isIntegerFamily(dataType);
+}
+function isNullable(column) {
+	return !isPrimaryKey(column) && !bHas(column.options, ColumnOption.notNull);
+}
+function getEntityColumnType(dataType, database) {
+	const columnType = getRustColumnType(dataType, database);
+	const { entityScalar, arrayDepth, selectAs } = columnType;
+	const type = PRELUDE_TYPES[entityScalar];
+	const declared = dataType.trim();
+	return {
+		type: arrayDepth === 1 ? `Vec<${type}>` : type,
+		columnType: seaormColumnType(declared, database, columnType),
+		selectAs: database === Database.SQLite ? sqliteSelectAs(declared, entityScalar) : selectAs,
+		saveAs: selectAs === null ? null : declared,
+		isFloat: entityScalar === "f32" || entityScalar === "f64"
+	};
+}
+function sqliteSelectAs(dataType, scalar) {
+	if (scalar === "decimal") return "REAL";
+	return (scalar === "json" || scalar === "string") && dataType !== "" && NUMERIC_AFFINITIES.has(sqliteAffinity(dataType)) ? "TEXT" : null;
+}
+function seaormColumnType(dataType, database, { scalar, base, args, arrayDepth, isUnsigned }) {
+	if (dataType === "") return null;
+	switch (database) {
+		case Database.PostgreSQL: return arrayDepth > 0 || !fitsU32(args) ? custom(dataType) : postgresColumnType(dataType, base, args);
+		case Database.MySQL:
+		case Database.MariaDB: return ZEROFILL.test(dataType) || isUnsigned && !UNSIGNED_SCALARS.has(scalar) || !fitsU32(args) ? custom(dataType) : mysqlColumnType(dataType, base, args);
+		case Database.SQLite: return sqliteAffinity(dataType) === sqliteAffinity(SQLITE_TYPES[scalar]) ? null : custom(dataType);
+		default: return null;
+	}
+}
+function postgresColumnType(dataType, base, args) {
+	if (POSTGRES_NATIVE_TYPES.has(base) && (args.length === 0 || base === "float")) return null;
+	if (DECIMAL_TYPES.has(base) && args.length > 0) return decimalColumnType(args);
+	if (VARCHAR_TYPES.has(base) && args.length === 1) return `String(StringLen::N(${args[0]}))`;
+	if ((CHAR_TYPES.has(base) || base === "bpchar") && args.length === 1) return `Char(Some(${args[0]}))`;
+	if (CHAR_TYPES.has(base) && args.length === 0) return "Char(None)";
+	const native = args.length === 0 ? POSTGRES_COLUMN_TYPES.get(base) : null;
+	if (native) return native;
+	if (base === "bit" && args.length === 1) return `Bit(Some(${args[0]}))`;
+	if ((base === "varbit" || base === "bit varying") && args.length === 1) return `VarBit(${args[0]})`;
+	return custom(dataType);
+}
+function mysqlColumnType(dataType, base, args) {
+	if (MYSQL_INTEGER_TYPES.has(base) || MYSQL_NATIVE_TYPES.has(base) && args.length === 0 || base === "float" && args.length === 1) return null;
+	if (DECIMAL_TYPES.has(base) && args.length > 0) return decimalColumnType(args);
+	if (VARCHAR_TYPES.has(base) && args.length === 1) return `String(StringLen::N(${args[0]}))`;
+	if (CHAR_TYPES.has(base) && args.length < 2) return args.length === 1 ? `Char(Some(${args[0]}))` : "Char(None)";
+	if (base === "binary" && args.length < 2) return `Binary(${args[0] ?? 1})`;
+	if (base === "varbinary" && args.length === 1) return `VarBinary(StringLen::N(${args[0]}))`;
+	if (base === "text" && args.length === 0) return "Text";
+	if (base === "blob" && args.length === 0) return "Blob";
+	if (base === "year" || base === "sql_tsi_year") return "Year";
+	if (base === "bit" && args.length < 2) return args.length === 1 ? `Bit(Some(${args[0]}))` : "Bit(None)";
+	return custom(dataType);
+}
+function decimalColumnType([precision, scale = 0]) {
+	return `Decimal(Some((${precision}, ${scale})))`;
+}
+function fitsU32(args) {
+	return args.every((arg) => arg <= 4294967295);
+}
+function custom(dataType) {
+	return `custom(${rustString(dataType)})`;
+}
+function sqliteAffinity(dataType) {
+	const name = dataType.toUpperCase();
+	if (name.includes("INT")) return "INTEGER";
+	if (name.includes("CHAR") || name.includes("CLOB") || name.includes("TEXT")) return "TEXT";
+	if (name.includes("BLOB")) return "BLOB";
+	if (name.includes("REAL") || name.includes("FLOA") || name.includes("DOUB")) return "REAL";
+	return "NUMERIC";
+}
+//#endregion
+export { createCode, createTableCode, derivedColumnName, getEntityColumnType, rustString, stableUpperCamelCase };