biz-a-cli 2.3.79 → 2.3.80-15224

package/engine/domain/firebird-ddl.js

@@ -0,0 +1,1097 @@
+export const buildTableStructureQueries = (tableName) => {
+	const normalizedTable = normalizeIdentifier(tableName);
+	const tableLiteral = toLiteral(normalizedTable);
+
+	return {
+		tableExistsSql: [
+			'SELECT IIF(EXISTS(',
+			'  SELECT 1',
+			'  FROM RDB$RELATIONS r',
+			`  WHERE UPPER(TRIM(r.RDB$RELATION_NAME)) = ${tableLiteral}`,
+			'    AND COALESCE(r.RDB$SYSTEM_FLAG, 0) = 0',
+			'    AND r.RDB$VIEW_BLR IS NULL',
+			'), 1, 0) AS TABLE_EXISTS',
+			'FROM RDB$DATABASE;',
+		].join('\n'),
+
+		columnsSql: [
+			'SELECT',
+			'  TRIM(rf.RDB$FIELD_NAME) AS COLUMN_NAME,',
+			'  CASE',
+			"    WHEN f.RDB$FIELD_TYPE = 7 THEN 'SMALLINT'",
+			"    WHEN f.RDB$FIELD_TYPE = 8 THEN 'INTEGER'",
+			"    WHEN f.RDB$FIELD_TYPE = 10 THEN 'FLOAT'",
+			"    WHEN f.RDB$FIELD_TYPE = 12 THEN 'DATE'",
+			"    WHEN f.RDB$FIELD_TYPE = 13 THEN 'TIME'",
+			"    WHEN f.RDB$FIELD_TYPE = 14 THEN 'CHAR'",
+			"    WHEN f.RDB$FIELD_TYPE = 16 AND COALESCE(f.RDB$FIELD_SUB_TYPE, 0) = 0 THEN 'BIGINT'",
+			"    WHEN f.RDB$FIELD_TYPE = 16 AND f.RDB$FIELD_SUB_TYPE = 1 THEN 'NUMERIC'",
+			"    WHEN f.RDB$FIELD_TYPE = 16 AND f.RDB$FIELD_SUB_TYPE = 2 THEN 'DECIMAL'",
+			"    WHEN f.RDB$FIELD_TYPE = 23 THEN 'SMALLINT'",
+			"    WHEN f.RDB$FIELD_TYPE = 27 THEN 'DOUBLE PRECISION'",
+			"    WHEN f.RDB$FIELD_TYPE = 35 THEN 'TIMESTAMP'",
+			"    WHEN f.RDB$FIELD_TYPE = 37 THEN 'VARCHAR'",
+			"    WHEN f.RDB$FIELD_TYPE = 261 THEN 'BLOB'",
+			"    ELSE 'UNKNOWN'",
+			'  END AS DATA_TYPE,',
+			'  CASE',
+			'    WHEN f.RDB$FIELD_TYPE IN (14, 37) THEN f.RDB$CHARACTER_LENGTH',
+			'    WHEN f.RDB$FIELD_TYPE = 16 AND COALESCE(f.RDB$FIELD_SUB_TYPE, 0) IN (1, 2) THEN f.RDB$FIELD_PRECISION',
+			'    ELSE NULL',
+			'  END AS FIELD_SIZE,',
+			'  ABS(COALESCE(f.RDB$FIELD_SCALE, 0)) AS FIELD_SCALE,',
+			'  IIF(COALESCE(rf.RDB$NULL_FLAG, 0) = 1, 0, 1) AS IS_NULLABLE,',
+			'  TRIM(COALESCE(CAST(rf.RDB$DEFAULT_SOURCE AS VARCHAR(4096)), CAST(f.RDB$DEFAULT_SOURCE AS VARCHAR(4096)))) AS DEFAULT_SOURCE,',
+			'  TRIM(f.RDB$COMPUTED_SOURCE) AS COMPUTED_SOURCE,',
+			'  rf.RDB$FIELD_POSITION AS COLUMN_POSITION',
+			'FROM RDB$RELATION_FIELDS rf',
+			'JOIN RDB$FIELDS f ON f.RDB$FIELD_NAME = rf.RDB$FIELD_SOURCE',
+			`WHERE UPPER(TRIM(rf.RDB$RELATION_NAME)) = ${tableLiteral}`,
+			'ORDER BY rf.RDB$FIELD_POSITION;',
+		].join('\n'),
+
+		primaryKeySql: [
+			'SELECT',
+			'  TRIM(rc.RDB$CONSTRAINT_NAME) AS CONSTRAINT_NAME,',
+			'  TRIM(seg.RDB$FIELD_NAME) AS COLUMN_NAME,',
+			'  seg.RDB$FIELD_POSITION AS COLUMN_POSITION',
+			'FROM RDB$RELATION_CONSTRAINTS rc',
+			'JOIN RDB$INDEX_SEGMENTS seg ON seg.RDB$INDEX_NAME = rc.RDB$INDEX_NAME',
+			`WHERE UPPER(TRIM(rc.RDB$RELATION_NAME)) = ${tableLiteral}`,
+			"  AND rc.RDB$CONSTRAINT_TYPE = 'PRIMARY KEY'",
+			'ORDER BY seg.RDB$FIELD_POSITION;',
+		].join('\n'),
+
+		uniqueKeysSql: [
+			'SELECT',
+			'  TRIM(rc.RDB$CONSTRAINT_NAME) AS CONSTRAINT_NAME,',
+			'  TRIM(seg.RDB$FIELD_NAME) AS COLUMN_NAME,',
+			'  seg.RDB$FIELD_POSITION AS COLUMN_POSITION',
+			'FROM RDB$RELATION_CONSTRAINTS rc',
+			'JOIN RDB$INDEX_SEGMENTS seg ON seg.RDB$INDEX_NAME = rc.RDB$INDEX_NAME',
+			`WHERE UPPER(TRIM(rc.RDB$RELATION_NAME)) = ${tableLiteral}`,
+			"  AND rc.RDB$CONSTRAINT_TYPE = 'UNIQUE'",
+			'ORDER BY rc.RDB$CONSTRAINT_NAME, seg.RDB$FIELD_POSITION;',
+		].join('\n'),
+
+		checkConstraintsSql: [
+			'SELECT',
+			'  TRIM(rc.RDB$CONSTRAINT_NAME) AS CONSTRAINT_NAME,',
+			'  TRIM(CAST(t.RDB$TRIGGER_SOURCE AS VARCHAR(4096))) AS CHECK_SOURCE',
+			'FROM RDB$RELATION_CONSTRAINTS rc',
+			'JOIN RDB$CHECK_CONSTRAINTS cc ON cc.RDB$CONSTRAINT_NAME = rc.RDB$CONSTRAINT_NAME',
+			'LEFT JOIN RDB$TRIGGERS t ON t.RDB$TRIGGER_NAME = cc.RDB$TRIGGER_NAME',
+			`WHERE UPPER(TRIM(rc.RDB$RELATION_NAME)) = ${tableLiteral}`,
+			"  AND rc.RDB$CONSTRAINT_TYPE = 'CHECK'",
+			'ORDER BY rc.RDB$CONSTRAINT_NAME;',
+		].join('\n'),
+
+		indexesSql: [
+			'SELECT',
+			'  TRIM(i.RDB$INDEX_NAME) AS INDEX_NAME,',
+			'  COALESCE(i.RDB$UNIQUE_FLAG, 0) AS IS_UNIQUE,',
+			'  COALESCE(i.RDB$INDEX_TYPE, 0) AS IS_DESCENDING,',
+			'  IIF(COALESCE(i.RDB$INDEX_INACTIVE, 0) = 1, 0, 1) AS IS_ACTIVE,',
+			'  TRIM(i.RDB$EXPRESSION_SOURCE) AS EXPRESSION_SOURCE,',
+			'  TRIM(seg.RDB$FIELD_NAME) AS COLUMN_NAME,',
+			'  seg.RDB$FIELD_POSITION AS COLUMN_POSITION',
+			'FROM RDB$INDICES i',
+			'LEFT JOIN RDB$INDEX_SEGMENTS seg ON seg.RDB$INDEX_NAME = i.RDB$INDEX_NAME',
+			'LEFT JOIN RDB$RELATION_CONSTRAINTS rc ON rc.RDB$INDEX_NAME = i.RDB$INDEX_NAME',
+			`WHERE UPPER(TRIM(i.RDB$RELATION_NAME)) = ${tableLiteral}`,
+			'  AND rc.RDB$INDEX_NAME IS NULL',
+			'ORDER BY i.RDB$INDEX_NAME, seg.RDB$FIELD_POSITION;',
+		].join('\n'),
+
+		foreignKeysSql: [
+			'SELECT',
+			'  TRIM(rc.RDB$CONSTRAINT_NAME) AS FK_NAME,',
+			'  TRIM(seg.RDB$FIELD_NAME) AS COLUMN_NAME,',
+			'  seg.RDB$FIELD_POSITION AS COLUMN_POSITION,',
+			'  TRIM(ref.RDB$RELATION_NAME) AS REF_TABLE_NAME,',
+			'  TRIM(refSeg.RDB$FIELD_NAME) AS REF_COLUMN_NAME,',
+			'  TRIM(refc.RDB$DELETE_RULE) AS DELETE_RULE,',
+			'  TRIM(refc.RDB$UPDATE_RULE) AS UPDATE_RULE',
+			'FROM RDB$RELATION_CONSTRAINTS rc',
+			'JOIN RDB$REF_CONSTRAINTS refc ON refc.RDB$CONSTRAINT_NAME = rc.RDB$CONSTRAINT_NAME',
+			'JOIN RDB$RELATION_CONSTRAINTS ref ON ref.RDB$CONSTRAINT_NAME = refc.RDB$CONST_NAME_UQ',
+			'JOIN RDB$INDEX_SEGMENTS seg ON seg.RDB$INDEX_NAME = rc.RDB$INDEX_NAME',
+			'JOIN RDB$INDEX_SEGMENTS refSeg',
+			'  ON refSeg.RDB$INDEX_NAME = ref.RDB$INDEX_NAME',
+			' AND refSeg.RDB$FIELD_POSITION = seg.RDB$FIELD_POSITION',
+			`WHERE UPPER(TRIM(rc.RDB$RELATION_NAME)) = ${tableLiteral}`,
+			"  AND rc.RDB$CONSTRAINT_TYPE = 'FOREIGN KEY'",
+			'ORDER BY rc.RDB$CONSTRAINT_NAME, seg.RDB$FIELD_POSITION;',
+		].join('\n'),
+		incomingForeignKeysSql: [
+			'SELECT',
+			'  TRIM(fk_rc.RDB$CONSTRAINT_NAME) AS FK_NAME,',
+			'  TRIM(fk_rc.RDB$RELATION_NAME) AS FK_TABLE_NAME,',
+			'  TRIM(fk_seg.RDB$FIELD_NAME) AS FK_COLUMN_NAME,',
+			'  TRIM(pk_seg.RDB$FIELD_NAME) AS REF_COLUMN_NAME,',
+			'  fk_seg.RDB$FIELD_POSITION AS COLUMN_POSITION',
+			'FROM RDB$RELATION_CONSTRAINTS fk_rc',
+			'JOIN RDB$REF_CONSTRAINTS refc ON refc.RDB$CONSTRAINT_NAME = fk_rc.RDB$CONSTRAINT_NAME',
+			'JOIN RDB$RELATION_CONSTRAINTS pk_rc ON pk_rc.RDB$CONSTRAINT_NAME = refc.RDB$CONST_NAME_UQ',
+			'JOIN RDB$INDEX_SEGMENTS fk_seg ON fk_seg.RDB$INDEX_NAME = fk_rc.RDB$INDEX_NAME',
+			'JOIN RDB$INDEX_SEGMENTS pk_seg ON pk_seg.RDB$INDEX_NAME = pk_rc.RDB$INDEX_NAME',
+			'  AND pk_seg.RDB$FIELD_POSITION = fk_seg.RDB$FIELD_POSITION',
+			"WHERE fk_rc.RDB$CONSTRAINT_TYPE = 'FOREIGN KEY'",
+			`  AND UPPER(TRIM(pk_rc.RDB$RELATION_NAME)) = ${tableLiteral}`,
+			'ORDER BY fk_rc.RDB$CONSTRAINT_NAME, fk_seg.RDB$FIELD_POSITION;',
+		].join('\n'),
+		columnDependenciesSql: [
+			'SELECT',
+			'  TRIM(d.RDB$FIELD_NAME) AS COLUMN_NAME,',
+			'  TRIM(d.RDB$DEPENDENT_NAME) AS DEPENDENT_NAME,',
+			'  d.RDB$DEPENDENT_TYPE AS DEPENDENT_TYPE',
+			'FROM RDB$DEPENDENCIES d',
+			`WHERE UPPER(TRIM(d.RDB$DEPENDED_ON_NAME)) = ${tableLiteral}`,
+			'  AND d.RDB$FIELD_NAME IS NOT NULL',
+			'ORDER BY d.RDB$FIELD_NAME, d.RDB$DEPENDENT_NAME;',
+		].join('\n'),
+	};
+};
+
+export const compareTableStructure = (expected, actual) => {
+	const differences = [];
+	const expectedName = normalizeIdentifier(expected.name);
+	const actualName = normalizeIdentifier(actual.tableName);
+
+	if (expectedName !== actualName) {
+		differences.push(
+			`Table name mismatch. expected "${expectedName}", actual "${actualName}".`,
+		);
+	}
+
+	if (!actual.tableExists) {
+		differences.push(`Table "${expectedName}" does not exist.`);
+		return { isSame: false, differences };
+	}
+
+	compareColumns(expected, actual, differences);
+	comparePrimaryKey(expected, actual, differences);
+	compareUniqueKeys(expected, actual, differences);
+	compareIndexes(expected, actual, differences);
+	compareForeignKeys(expected, actual, differences);
+
+	return {
+		isSame: differences.length === 0,
+		differences,
+	};
+};
+
+export const buildStructureSnapshotFromRows = (input) => {
+	const tableExistsValue =
+		Number(
+			input.tableExistsRows?.[0]?.['TABLE_EXISTS'] ??
+				input.tableExistsRows?.[0]?.['table_exists'] ??
+				0,
+		) === 1;
+
+	const columns = (input.columnRows ?? []).map((row) => ({
+		name: toUpperText(row['COLUMN_NAME'] ?? row['column_name']),
+		type: toUpperText(row['DATA_TYPE'] ?? row['data_type']),
+		size: toNumberOrUndefined(row['FIELD_SIZE'] ?? row['field_size']),
+		scale: toNumberOrUndefined(row['FIELD_SCALE'] ?? row['field_scale']),
+		nullable: Number(row['IS_NULLABLE'] ?? row['is_nullable'] ?? 1) === 1,
+		defaultExpression: normalizeExpression(
+			row['DEFAULT_SOURCE'] ?? row['default_source'],
+		),
+		computedBy: normalizeExpression(
+			row['COMPUTED_SOURCE'] ?? row['computed_source'],
+		),
+	}));
+
+	const primaryKey = groupColumnsBySingleConstraint(input.primaryKeyRows ?? []);
+	const uniqueKeys = groupColumnsByConstraint(
+		input.uniqueKeyRows ?? [],
+		'CONSTRAINT_NAME',
+	);
+	const checks = groupCheckConstraints(input.checkConstraintRows ?? []);
+	const indexes = groupIndexes(input.indexRows ?? []);
+	const foreignKeys = groupForeignKeys(input.foreignKeyRows ?? []);
+	const incomingForeignKeys = groupIncomingForeignKeys(
+		input.incomingForeignKeyRows ?? [],
+	);
+	const columnDependencies = (input.columnDependencyRows ?? []).map((row) => ({
+		columnName: toUpperText(row['COLUMN_NAME'] ?? row['column_name']),
+		dependentName: toUpperText(row['DEPENDENT_NAME'] ?? row['dependent_name']),
+		dependentType: Number(row['DEPENDENT_TYPE'] ?? row['dependent_type'] ?? 0),
+	}));
+
+	return {
+		tableName: normalizeIdentifier(input.tableName),
+		tableExists: tableExistsValue,
+		columns,
+		primaryKey,
+		uniqueKeys,
+		checks,
+		indexes,
+		foreignKeys,
+		incomingForeignKeys,
+		columnDependencies,
+	};
+};
+
+export const generateExecuteBlockSql = (schema) => {
+	const statements = [];
+
+	for (const table of schema.tables) {
+		const createTable = buildCreateTableStatement(table);
+		const generatorName = normalizeIdentifier(
+			table.generatorName ?? `${table.name}_GEN`,
+		);
+		const triggerName = normalizeIdentifier(
+			table.triggerName ?? `${table.name}_BI`,
+		);
+		const identityColumn = normalizeIdentifier(
+			table.identityColumnName ?? 'ID',
+		);
+		const shouldGenerateIdentityTrigger =
+			!!table.identityColumnName &&
+			hasColumnName(table.columns, identityColumn);
+		const identityValueExpression = resolveIdentityValueExpression(
+			table,
+			identityColumn,
+			generatorName,
+		);
+
+		if (shouldGenerateIdentityTrigger) {
+			statements.push(`CREATE GENERATOR ${generatorName};`);
+		}
+
+		statements.push(stripIdentifierQuotes(createTable));
+
+		if (shouldGenerateIdentityTrigger) {
+			statements.push(
+				buildIdentityTriggerStatement(
+					table.name,
+					triggerName,
+					identityColumn,
+					identityValueExpression,
+				),
+			);
+		}
+
+		for (const index of table.indexes ?? []) {
+			for (const statement of buildIndexStatements(table.name, index)) {
+				statements.push(stripIdentifierQuotes(statement));
+			}
+		}
+
+		for (const foreignKey of table.foreignKeys ?? []) {
+			statements.push(
+				stripIdentifierQuotes(
+					buildAddForeignKeyStatement(table.name, foreignKey),
+				),
+			);
+		}
+	}
+
+	return []
+		.concat('EXECUTE BLOCK AS BEGIN')
+		.concat(
+			statements.map(
+				(statement) => `EXECUTE STATEMENT ${toLiteral(statement)};`,
+			),
+		)
+		.concat('END')
+		.join(' ');
+};
+
+export const generateCreateTableSql = (table, createIfNotExists = true) => {
+	const createTable = buildCreateTableStatement(table);
+	if (!createIfNotExists) {
+		return createTable;
+	}
+	return wrapCreateIfMissing(createTable);
+};
+
+export const generateCreateSchemaSql = (schema, createIfNotExists = true) => {
+	const createTableStatements = [];
+	const createIndexStatements = [];
+	const addForeignKeyStatements = [];
+
+	for (const table of schema.tables) {
+		createTableStatements.push(
+			generateCreateTableSql(table, createIfNotExists),
+		);
+
+		for (const index of table.indexes ?? []) {
+			for (const statement of buildIndexStatements(table.name, index)) {
+				createIndexStatements.push(
+					createIfNotExists ? wrapCreateIfMissing(statement) : statement,
+				);
+			}
+		}
+
+		for (const foreignKey of table.foreignKeys ?? []) {
+			const statement = buildAddForeignKeyStatement(table.name, foreignKey);
+			addForeignKeyStatements.push(
+				createIfNotExists ? wrapCreateIfMissing(statement) : statement,
+			);
+		}
+	}
+
+	return [
+		...createTableStatements,
+		...createIndexStatements,
+		...addForeignKeyStatements,
+	].join('\n\n');
+};
+
+const buildCreateTableStatement = (table) => {
+	const tableBody = table.columns.map((column) => buildColumnDefinition(column));
+
+	if (table.primaryKey && table.primaryKey.columns.length > 0) {
+		const primaryKeyName = table.primaryKey.name ?? `PK_${table.name}`;
+		tableBody.push(
+			`CONSTRAINT ${quoteIdentifier(primaryKeyName)} PRIMARY KEY (${joinColumns(table.primaryKey.columns)})`,
+		);
+	}
+
+	for (const uniqueKey of table.uniqueKeys ?? []) {
+		tableBody.push(
+			`CONSTRAINT ${quoteIdentifier(uniqueKey.name)} UNIQUE (${joinColumns(uniqueKey.columns)})`,
+		);
+	}
+
+	for (const checkItem of table.checks ?? []) {
+		tableBody.push(
+			`CONSTRAINT ${quoteIdentifier(checkItem.name)} CHECK (${checkItem.expression})`,
+		);
+	}
+
+	return `CREATE TABLE ${quoteIdentifier(table.name)} (\n  ${tableBody.join(',\n  ')}\n);`;
+};
+
+const buildColumnDefinition = (column) => {
+	const parts = [quoteIdentifier(column.name)];
+
+	if (column.computedBy) {
+		parts.push(`COMPUTED BY (${column.computedBy})`);
+		return parts.join(' ');
+	}
+
+	parts.push(resolveColumnType(column));
+
+	if (column.defaultExpression) {
+		parts.push(`DEFAULT ${column.defaultExpression}`);
+	} else if (column.defaultValue !== undefined) {
+		parts.push(`DEFAULT ${toLiteral(column.defaultValue)}`);
+	}
+
+	if (column.collate) {
+		parts.push(`COLLATE ${column.collate}`);
+	}
+
+	if (column.check) {
+		parts.push(`CHECK (${column.check})`);
+	}
+
+	if (column.nullable === false) {
+		parts.push('NOT NULL');
+	}
+
+	return parts.join(' ');
+};
+
+const resolveColumnType = (column) => {
+	const hasSize = typeof column.size === 'number';
+	const hasScale = typeof column.scale === 'number';
+
+	const normalizedType = normalizeFb25TypeName(column.type);
+
+	if (!hasSize) {
+		return normalizedType;
+	}
+	if (!hasScale) {
+		return `${normalizedType}(${column.size})`;
+	}
+	return `${normalizedType}(${column.size},${column.scale})`;
+};
+
+const buildCreateIndexStatement = (tableName, index) => {
+	const mode = [index.unique ? 'UNIQUE' : '', index.descending ? 'DESC' : '']
+		.filter(Boolean)
+		.join(' ');
+	const modePart = mode.length > 0 ? `${mode} ` : '';
+
+	if (index.expression) {
+		return `CREATE ${modePart}INDEX ${quoteIdentifier(index.name)} ON ${quoteIdentifier(tableName)} COMPUTED BY (${index.expression});`;
+	}
+
+	return `CREATE ${modePart}INDEX ${quoteIdentifier(index.name)} ON ${quoteIdentifier(tableName)} (${joinColumns(index.columns ?? [])});`;
+};
+
+const buildAlterIndexInactiveStatement = (indexName) => {
+	return `ALTER INDEX ${quoteIdentifier(indexName)} INACTIVE;`;
+};
+
+const buildIndexStatements = (tableName, index) => {
+	const statements = [buildCreateIndexStatement(tableName, index)];
+	if (index.active === false) {
+		statements.push(buildAlterIndexInactiveStatement(index.name));
+	}
+	return statements;
+};
+
+const buildAddForeignKeyStatement = (tableName, foreignKey) => {
+	const clauses = [
+		`ALTER TABLE ${quoteIdentifier(tableName)}`,
+		`ADD CONSTRAINT ${quoteIdentifier(foreignKey.name)}`,
+		`FOREIGN KEY (${joinColumns(foreignKey.columns)})`,
+		`REFERENCES ${quoteIdentifier(foreignKey.referenceTable)} (${joinColumns(foreignKey.referenceColumns)})`,
+		...(foreignKey.onDelete ? [`ON DELETE ${foreignKey.onDelete}`] : []),
+		...(foreignKey.onUpdate ? [`ON UPDATE ${foreignKey.onUpdate}`] : []),
+	];
+
+	return `${clauses.join(' ')};`;
+};
+
+const buildIdentityTriggerStatement = (
+	tableName,
+	triggerName,
+	identityColumn,
+	valueExpression,
+) => {
+	const normalizedTableName = normalizeIdentifier(tableName);
+	const normalizedTriggerName = normalizeIdentifier(triggerName);
+	const normalizedIdentityColumn = normalizeIdentifier(identityColumn);
+	return [
+		`CREATE TRIGGER ${normalizedTriggerName} FOR ${normalizedTableName} ACTIVE`,
+		'BEFORE INSERT POSITION 0 AS BEGIN',
+		`IF (NEW.${normalizedIdentityColumn} IS NULL) THEN NEW.${normalizedIdentityColumn} = ${valueExpression};`,
+		'END',
+	].join(' ');
+};
+
+const resolveIdentityValueExpression = (table, identityColumn, generatorName) => {
+	return `GEN_ID(${normalizeIdentifier(generatorName)}, 1)`;
+};
+
+const wrapCreateIfMissing = (statement) => {
+	return [
+		'EXECUTE BLOCK AS',
+		'BEGIN',
+		`  EXECUTE STATEMENT ${toLiteral(statement)};`,
+		'WHEN SQLCODE -607 DO',
+		'BEGIN',
+		'END',
+		'END',
+	].join('\n');
+};
+
+const joinColumns = (columns) => {
+	return columns.map((column) => quoteIdentifier(column)).join(', ');
+};
+
+const quoteIdentifier = (identifier) => {
+	const normalized = normalizeIdentifier(identifier);
+	return `"${normalized.replace(/"/g, '""')}"`;
+};
+
+const hasColumnName = (columns, columnName) => {
+	const normalizedColumnName = normalizeIdentifier(columnName);
+	return columns.some(
+		(column) => normalizeIdentifier(column.name) === normalizedColumnName,
+	);
+};
+
+const stripIdentifierQuotes = (statement) => {
+	return statement.replace(/"/g, '');
+};
+
+const compareColumns = (expected, actual, differences) => {
+	const expectedMap = new Map();
+	const actualMap = new Map();
+
+	for (const column of expected.columns) {
+		expectedMap.set(column.name.trim().toUpperCase(), column);
+	}
+	for (const column of actual.columns) {
+		actualMap.set(column.name.trim().toUpperCase(), column);
+	}
+
+	for (const [columnName, expectedColumn] of expectedMap) {
+		const actualColumn = actualMap.get(columnName);
+		if (!actualColumn) {
+			differences.push(`Column "${columnName}" is missing in actual table.`);
+			continue;
+		}
+
+		const expectedType = normalizeExpectedColumnType(expectedColumn);
+		const actualType = normalizeActualColumnType(actualColumn);
+		if (expectedType !== actualType) {
+			differences.push(
+				`Column "${columnName}" type mismatch. expected ${expectedType}, actual ${actualType}.`,
+			);
+		}
+
+		const expectedNullable = expectedColumn.nullable !== false;
+		const actualNullable =
+			expectedNullable ||
+			!hasFirebird25NotNullCheck(actual, expectedColumn.name)
+				? actualColumn.nullable !== false
+				: false;
+		if (expectedNullable !== actualNullable) {
+			differences.push(
+				`Column "${columnName}" nullable mismatch. expected ${expectedNullable}, actual ${actualNullable}.`,
+			);
+		}
+
+		if (expectedColumn.defaultExpression) {
+			const expectedDefault = normalizeExpression(
+				expectedColumn.defaultExpression,
+			);
+			const actualDefault = normalizeExpression(actualColumn.defaultExpression);
+			if (expectedDefault !== actualDefault) {
+				differences.push(
+					`Column "${columnName}" default expression mismatch. expected "${expectedDefault}", actual "${actualDefault}".`,
+				);
+			}
+		} else if (expectedColumn.defaultValue !== undefined) {
+			const expectedDefault = normalizeExpression(
+				toLiteral(expectedColumn.defaultValue),
+			);
+			const actualDefault = normalizeExpression(actualColumn.defaultExpression);
+			if (expectedDefault !== actualDefault) {
+				differences.push(
+					`Column "${columnName}" default value mismatch. expected "${expectedDefault}", actual "${actualDefault}".`,
+				);
+			}
+		}
+
+		if (expectedColumn.computedBy) {
+			const expectedComputed = normalizeExpression(expectedColumn.computedBy);
+			const actualComputed = normalizeExpression(actualColumn.computedBy);
+			if (expectedComputed !== actualComputed) {
+				differences.push(
+					`Column "${columnName}" computed expression mismatch. expected "${expectedComputed}", actual "${actualComputed}".`,
+				);
+			}
+		}
+	}
+
+	for (const columnName of actualMap.keys()) {
+		if (!expectedMap.has(columnName)) {
+			differences.push(
+				`Column "${columnName}" exists in actual table but not in expected JSON.`,
+			);
+		}
+	}
+};
+
+const hasFirebird25NotNullCheck = (actual, columnName) => {
+	return (actual.checks ?? []).some((check) =>
+		isFirebird25NotNullCheckForColumn(check, columnName),
+	);
+};
+
+const isFirebird25NotNullCheckForColumn = (check, columnName) => {
+	const expression = String(check?.expression ?? '')
+		.replace(/^CHECK\s*/i, '')
+		.replace(/"/g, '')
+		.replace(/\s+/g, '')
+		.toUpperCase();
+	const normalizedColumnName = normalizeIdentifier(columnName);
+	return (
+		expression === `${normalizedColumnName}ISNOTNULL` ||
+		expression === `(${normalizedColumnName}ISNOTNULL)`
+	);
+};
+
+const comparePrimaryKey = (expected, actual, differences) => {
+	const expectedPk = (expected.primaryKey?.columns ?? []).map((column) =>
+		column.trim().toUpperCase(),
+	);
+	const actualPk = (actual.primaryKey ?? []).map((column) =>
+		column.trim().toUpperCase(),
+	);
+	if (!isSameOrderedArray(expectedPk, actualPk)) {
+		differences.push(
+			`Primary key mismatch. expected [${expectedPk.join(', ')}], actual [${actualPk.join(', ')}].`,
+		);
+	}
+};
+
+const compareUniqueKeys = (expected, actual, differences) => {
+	const expectedMap = new Map();
+	const actualMap = new Map();
+
+	for (const uniqueKey of expected.uniqueKeys ?? []) {
+		expectedMap.set(
+			uniqueKey.name.trim().toUpperCase(),
+			uniqueKey.columns.map((column) => column.trim().toUpperCase()),
+		);
+	}
+	for (const uniqueKey of actual.uniqueKeys ?? []) {
+		actualMap.set(
+			uniqueKey.name.trim().toUpperCase(),
+			uniqueKey.columns.map((column) => column.trim().toUpperCase()),
+		);
+	}
+
+	compareNamedColumnCollections('Unique key', expectedMap, actualMap, differences);
+};
+
+const compareIndexes = (expected, actual, differences) => {
+	const expectedMap = new Map();
+	const actualMap = new Map();
+
+	for (const index of expected.indexes ?? []) {
+		expectedMap.set(index.name.trim().toUpperCase(), index);
+	}
+	for (const index of actual.indexes ?? []) {
+		actualMap.set(index.name.trim().toUpperCase(), index);
+	}
+
+	for (const [indexName, expectedIndex] of expectedMap) {
+		const actualIndex = actualMap.get(indexName);
+		if (!actualIndex) {
+			differences.push(`Index "${indexName}" is missing in actual table.`);
+			continue;
+		}
+
+		const expectedColumns = (expectedIndex.columns ?? []).map((column) =>
+			column.trim().toUpperCase(),
+		);
+		const actualColumns = (actualIndex.columns ?? []).map((column) =>
+			column.trim().toUpperCase(),
+		);
+		if (!isSameOrderedArray(expectedColumns, actualColumns)) {
+			differences.push(
+				`Index "${indexName}" columns mismatch. expected [${expectedColumns.join(', ')}], actual [${actualColumns.join(', ')}].`,
+			);
+		}
+
+		const expectedExpression = normalizeExpression(expectedIndex.expression);
+		const actualExpression = normalizeExpression(actualIndex.expression);
+		if (expectedExpression !== actualExpression) {
+			differences.push(
+				`Index "${indexName}" expression mismatch. expected "${expectedExpression}", actual "${actualExpression}".`,
+			);
+		}
+
+		const expectedUnique = expectedIndex.unique === true;
+		const actualUnique = actualIndex.unique === true;
+		if (expectedUnique !== actualUnique) {
+			differences.push(
+				`Index "${indexName}" unique flag mismatch. expected ${expectedUnique}, actual ${actualUnique}.`,
+			);
+		}
+
+		const expectedDescending = expectedIndex.descending === true;
+		const actualDescending = actualIndex.descending === true;
+		if (expectedDescending !== actualDescending) {
+			differences.push(
+				`Index "${indexName}" descending flag mismatch. expected ${expectedDescending}, actual ${actualDescending}.`,
+			);
+		}
+	}
+
+	for (const indexName of actualMap.keys()) {
+		if (!expectedMap.has(indexName)) {
+			differences.push(
+				`Index "${indexName}" exists in actual table but not in expected JSON.`,
+			);
+		}
+	}
+};
+
+const compareForeignKeys = (expected, actual, differences) => {
+	const expectedMap = new Map();
+	const actualMap = new Map();
+
+	for (const fk of expected.foreignKeys ?? []) {
+		expectedMap.set(fk.name.trim().toUpperCase(), fk);
+	}
+	for (const fk of actual.foreignKeys ?? []) {
+		actualMap.set(fk.name.trim().toUpperCase(), fk);
+	}
+
+	for (const [fkName, expectedFk] of expectedMap) {
+		const actualFk = actualMap.get(fkName);
+		if (!actualFk) {
+			differences.push(`Foreign key "${fkName}" is missing in actual table.`);
+			continue;
+		}
+
+		const expectedColumns = expectedFk.columns.map((column) =>
+			column.trim().toUpperCase(),
+		);
+		const actualColumns = actualFk.columns.map((column) =>
+			column.trim().toUpperCase(),
+		);
+		if (!isSameOrderedArray(expectedColumns, actualColumns)) {
+			differences.push(
+				`Foreign key "${fkName}" local columns mismatch. expected [${expectedColumns.join(', ')}], actual [${actualColumns.join(', ')}].`,
+			);
+		}
+
+		const expectedRefTable = expectedFk.referenceTable.trim().toUpperCase();
+		const actualRefTable = actualFk.referenceTable.trim().toUpperCase();
+		if (expectedRefTable !== actualRefTable) {
+			differences.push(
+				`Foreign key "${fkName}" reference table mismatch. expected "${expectedRefTable}", actual "${actualRefTable}".`,
+			);
+		}
+
+		const expectedRefColumns = expectedFk.referenceColumns.map((column) =>
+			column.trim().toUpperCase(),
+		);
+		const actualRefColumns = actualFk.referenceColumns.map((column) =>
+			column.trim().toUpperCase(),
+		);
+		if (!isSameOrderedArray(expectedRefColumns, actualRefColumns)) {
+			differences.push(
+				`Foreign key "${fkName}" reference columns mismatch. expected [${expectedRefColumns.join(', ')}], actual [${actualRefColumns.join(', ')}].`,
+			);
+		}
+
+		const expectedDeleteRule = normalizeRule(expectedFk.onDelete);
+		const actualDeleteRule = normalizeRule(actualFk.onDelete);
+		if (expectedDeleteRule !== actualDeleteRule) {
+			differences.push(
+				`Foreign key "${fkName}" ON DELETE mismatch. expected "${expectedDeleteRule}", actual "${actualDeleteRule}".`,
+			);
+		}
+
+		const expectedUpdateRule = normalizeRule(expectedFk.onUpdate);
+		const actualUpdateRule = normalizeRule(actualFk.onUpdate);
+		if (expectedUpdateRule !== actualUpdateRule) {
+			differences.push(
+				`Foreign key "${fkName}" ON UPDATE mismatch. expected "${expectedUpdateRule}", actual "${actualUpdateRule}".`,
+			);
+		}
+	}
+
+	for (const fkName of actualMap.keys()) {
+		if (!expectedMap.has(fkName)) {
+			differences.push(
+				`Foreign key "${fkName}" exists in actual table but not in expected JSON.`,
+			);
+		}
+	}
+};
+
+const compareNamedColumnCollections = (label, expected, actual, differences) => {
+	for (const [name, expectedColumns] of expected) {
+		const actualColumns = actual.get(name);
+		if (!actualColumns) {
+			differences.push(`${label} "${name}" is missing in actual table.`);
+			continue;
+		}
+		if (!isSameOrderedArray(expectedColumns, actualColumns)) {
+			differences.push(
+				`${label} "${name}" columns mismatch. expected [${expectedColumns.join(', ')}], actual [${actualColumns.join(', ')}].`,
+			);
+		}
+	}
+	for (const name of actual.keys()) {
+		if (!expected.has(name)) {
+			differences.push(`${label} "${name}" exists in actual table but not in expected JSON.`);
+		}
+	}
+};
+
+const groupColumnsBySingleConstraint = (rows) => {
+	return [...rows]
+		.sort(
+			(a, b) =>
+				Number(a['COLUMN_POSITION'] ?? a['column_position'] ?? 0) -
+				Number(b['COLUMN_POSITION'] ?? b['column_position'] ?? 0),
+		)
+		.map((row) => toUpperText(row['COLUMN_NAME'] ?? row['column_name']))
+		.filter((name) => name.length > 0);
+};
+
+const groupColumnsByConstraint = (rows, constraintNameKey) => {
+	const map = new Map();
+	for (const row of rows) {
+		const name = toUpperText(
+			row[constraintNameKey] ?? row[constraintNameKey.toLowerCase()],
+		);
+		if (!map.has(name)) {
+			map.set(name, []);
+		}
+		map.get(name)?.push({
+			position: Number(row['COLUMN_POSITION'] ?? row['column_position'] ?? 0),
+			column: toUpperText(row['COLUMN_NAME'] ?? row['column_name']),
+		});
+	}
+
+	return [...map.entries()].map(([name, data]) => ({
+		name,
+		columns: data.sort((a, b) => a.position - b.position).map((item) => item.column),
+	}));
+};
+
+const groupCheckConstraints = (rows) => {
+	return (rows ?? [])
+		.map((row) => ({
+			name: toUpperText(row['CONSTRAINT_NAME'] ?? row['constraint_name']),
+			expression: normalizeExpression(
+				row['CHECK_SOURCE'] ??
+					row['check_source'] ??
+					row['EXPRESSION'] ??
+					row['expression'],
+			),
+		}))
+		.filter((check) => check.name.length > 0);
+};
+
+const groupIndexes = (rows) => {
+	const map = new Map();
+
+	for (const row of rows) {
+		const name = toUpperText(row['INDEX_NAME'] ?? row['index_name']);
+		if (!map.has(name)) {
+			map.set(name, {
+				unique: Number(row['IS_UNIQUE'] ?? row['is_unique'] ?? 0) === 1,
+				descending:
+					Number(row['IS_DESCENDING'] ?? row['is_descending'] ?? 0) === 1,
+				active: Number(row['IS_ACTIVE'] ?? row['is_active'] ?? 1) === 1,
+				expression: normalizeExpression(
+					row['EXPRESSION_SOURCE'] ?? row['expression_source'],
+				),
+				columns: [],
+			});
+		}
+		const columnName = toUpperText(row['COLUMN_NAME'] ?? row['column_name']);
+		if (columnName.length > 0) {
+			map.get(name)?.columns.push({
+				position: Number(row['COLUMN_POSITION'] ?? row['column_position'] ?? 0),
+				column: columnName,
+			});
+		}
+	}
+
+	return [...map.entries()].map(([name, index]) => ({
+		name,
+		unique: index.unique,
+		descending: index.descending,
+		active: index.active,
+		expression: index.expression,
+		columns: index.columns
+			.sort((a, b) => a.position - b.position)
+			.map((item) => item.column),
+	}));
+};
+
+const groupForeignKeys = (rows) => {
+	const map = new Map();
+
+	for (const row of rows) {
+		const name = toUpperText(row['FK_NAME'] ?? row['fk_name']);
+		if (!map.has(name)) {
+			map.set(name, {
+				referenceTable: toUpperText(
+					row['REF_TABLE_NAME'] ?? row['ref_table_name'],
+				),
+				deleteRule: normalizeRule(row['DELETE_RULE'] ?? row['delete_rule']),
+				updateRule: normalizeRule(row['UPDATE_RULE'] ?? row['update_rule']),
+				columns: [],
+				referenceColumns: [],
+			});
+		}
+
+		map.get(name)?.columns.push({
+			position: Number(row['COLUMN_POSITION'] ?? row['column_position'] ?? 0),
+			column: toUpperText(row['COLUMN_NAME'] ?? row['column_name']),
+		});
+		map.get(name)?.referenceColumns.push({
+			position: Number(row['COLUMN_POSITION'] ?? row['column_position'] ?? 0),
+			column: toUpperText(row['REF_COLUMN_NAME'] ?? row['ref_column_name']),
+		});
+	}
+
+	return [...map.entries()].map(([name, fk]) => ({
+		name,
+		referenceTable: fk.referenceTable,
+		onDelete: fk.deleteRule,
+		onUpdate: fk.updateRule,
+		columns: fk.columns.sort((a, b) => a.position - b.position).map((item) => item.column),
+		referenceColumns: fk.referenceColumns
+			.sort((a, b) => a.position - b.position)
+			.map((item) => item.column),
+	}));
+};
+
+const groupIncomingForeignKeys = (rows) => {
+	const map = new Map();
+
+	for (const row of rows) {
+		const fkName = toUpperText(row['FK_NAME'] ?? row['fk_name']);
+		const fkTableName = toUpperText(row['FK_TABLE_NAME'] ?? row['fk_table_name']);
+		const key = `${fkTableName}|${fkName}`;
+		if (!map.has(key)) {
+			map.set(key, {
+				name: fkName,
+				tableName: fkTableName,
+				columns: [],
+				referenceColumns: [],
+			});
+		}
+
+		map.get(key)?.columns.push({
+			position: Number(row['COLUMN_POSITION'] ?? row['column_position'] ?? 0),
+			column: toUpperText(row['FK_COLUMN_NAME'] ?? row['fk_column_name']),
+		});
+		map.get(key)?.referenceColumns.push({
+			position: Number(row['COLUMN_POSITION'] ?? row['column_position'] ?? 0),
+			column: toUpperText(row['REF_COLUMN_NAME'] ?? row['ref_column_name']),
+		});
+	}
+
+	return [...map.values()].map((item) => ({
+		name: item.name,
+		tableName: item.tableName,
+		columns: item.columns.sort((a, b) => a.position - b.position).map((row) => row.column),
+		referenceColumns: item.referenceColumns
+			.sort((a, b) => a.position - b.position)
+			.map((row) => row.column),
+	}));
+};
+
+const normalizeExpectedColumnType = (column) => {
+	return normalizeType(column.type, column.size, column.scale);
+};
+
+const normalizeActualColumnType = (column) => {
+	return normalizeType(column.type, column.size, column.scale);
+};
+
+const normalizeType = (type, size, scale) => {
+	const baseType = normalizeFb25TypeName(type);
+	const supportsLength = ['CHAR', 'VARCHAR'].includes(baseType);
+	const supportsPrecision = ['NUMERIC', 'DECIMAL'].includes(baseType);
+	const hasSize = typeof size === 'number' && Number.isFinite(size) && size > 0;
+	const hasScale = typeof scale === 'number' && Number.isFinite(scale);
+
+	if (!supportsLength && !supportsPrecision) {
+		return baseType;
+	}
+
+	if (!hasSize) {
+		return baseType;
+	}
+
+	if (supportsLength) {
+		return `${baseType}(${size})`;
+	}
+
+	if (!hasScale || scale === 0) {
+		return `${baseType}(${size})`;
+	}
+
+	return `${baseType}(${size},${scale})`;
+};
+
+const normalizeExpression = (expression) => {
+	if (typeof expression !== 'string') {
+		return '';
+	}
+	return expression.replace(/\s+/g, ' ').trim().toUpperCase();
+};
+
+const normalizeRule = (value) => {
+	const text = toUpperText(value);
+	if (text.length === 0) {
+		return undefined;
+	}
+	if (text === 'RESTRICT') {
+		return 'NO ACTION';
+	}
+	if (
+		text === 'NO ACTION' ||
+		text === 'CASCADE' ||
+		text === 'SET NULL' ||
+		text === 'SET DEFAULT'
+	) {
+		return text;
+	}
+	return undefined;
+};
+
+const isSameOrderedArray = (expected, actual) => {
+	if (expected.length !== actual.length) {
+		return false;
+	}
+	for (let i = 0; i < expected.length; i++) {
+		if (expected[i] !== actual[i]) {
+			return false;
+		}
+	}
+	return true;
+};
+
+const normalizeIdentifier = (value) => {
+	const source = String(value ?? '');
+	// Skip the camelCase->snake_case split for already-uppercase input (e.g. a hash-suffixed
+	// name this function itself already produced) -- otherwise a hex hash like "1E8A9B" gets
+	// spurious underscores inserted at digit->letter boundaries ("1_E8_A9_B"), pushing an
+	// already-valid 31-char identifier over the limit and forcing a second, different hash.
+	const withWordBreaks = /[a-z]/.test(source) ? source.replace(/([a-z0-9])([A-Z])/g, '$1_$2') : source;
+	const normalized = withWordBreaks
+		.replace(/[^A-Za-z0-9_$]+/g, '_')
+		.replace(/_+/g, '_')
+		.replace(/^_+|_+$/g, '')
+		.toUpperCase();
+	const raw = normalized || 'COL';
+	if (raw.length <= 31) {
+		return raw;
+	}
+	const hash = toSimpleHash(raw).slice(0, 6);
+	const leadingLength = 31 - hash.length - 1;
+	// Strip a trailing underscore left by the slice so we never emit a double underscore before
+	// the hash -- a lone trailing "_" here would otherwise get silently collapsed by any later
+	// re-normalization pass, producing a different identifier than this function itself stored.
+	return raw.slice(0, leadingLength).replace(/_+$/, '') + '_' + hash;
+};
+
+const toSimpleHash = (input) => {
+	let hash = 0;
+	for (let index = 0; index < input.length; index += 1) {
+		hash = (hash << 5) - hash + input.charCodeAt(index);
+		hash |= 0;
+	}
+	return Math.abs(hash).toString(16).toUpperCase();
+};
+
+const toUpperText = (value) => {
+	if (typeof value !== 'string') {
+		return '';
+	}
+	return value.trim().toUpperCase();
+};
+
+const toNumberOrUndefined = (value) => {
+	if (value == null || value === '') {
+		return undefined;
+	}
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : undefined;
+};
+
+const normalizeFb25TypeName = (type) => {
+	const upperType = toUpperText(type);
+	if (upperType === 'BOOLEAN') {
+		return 'SMALLINT';
+	}
+	return upperType;
+};
+
+const toLiteral = (value) => {
+	if (value === null) {
+		return 'NULL';
+	}
+	if (typeof value === 'number') {
+		return `${value}`;
+	}
+	if (typeof value === 'boolean') {
+		return value ? '1' : '0';
+	}
+	return `'${value.replace(/'/g, "''")}'`;
+};