Database diagrams editor that allows you to visualize and design your DB with a single query.
TypeScript databasedbdb-migrationeditorerdmariadbmssqlmysqlpostgresqlreactreact-flowschema-migrationssqlsqlitetypescriptvisualizationxyflow
feat: deterministic SQL export for PostgreSQL to MySQL/MSSQL (#1030)
Jonathan Fishnerfb19a7ac2f8e
diff --git a/src/dialogs/export-sql-dialog/export-sql-dialog.tsx b/src/dialogs/export-sql-dialog/export-sql-dialog.tsxindex df9d29cd..230bae27 100644--- a/src/dialogs/export-sql-dialog/export-sql-dialog.tsx+++ b/src/dialogs/export-sql-dialog/export-sql-dialog.tsx@@ -18,10 +18,11 @@ import {exportBaseSQL,exportSQL,} from '@/lib/data/sql-export/export-sql-script';+import { hasCrossDialectSupport } from '@/lib/data/sql-export/cross-dialect';import { databaseTypeToLabelMap } from '@/lib/databases';import { DatabaseType } from '@/lib/domain/database-type';-import { Annoyed, Sparkles } from 'lucide-react';-import React, { useCallback, useEffect, useRef } from 'react';+import { Annoyed, Sparkles, Blocks, Wand2 } from 'lucide-react';+import React, { useCallback, useEffect, useMemo, useRef } from 'react';import { Trans, useTranslation } from 'react-i18next';import type { BaseDialogProps } from '../common/base-dialog-props';import type { Diagram } from '@/lib/domain/diagram';@@ -49,8 +50,30 @@ export const ExportSQLDialog: React.FC<ExportSQLDialogProps> = ({const [error, setError] = React.useState<boolean>(false);const [isScriptLoading, setIsScriptLoading] =React.useState<boolean>(false);+ const [useAIExport, setUseAIExport] = React.useState<boolean>(false);const abortControllerRef = useRef<AbortController | null>(null);+ // Check if a deterministic export path is available+ const hasDeterministicPath = useMemo(() => {+ return (+ targetDatabaseType === DatabaseType.GENERIC ||+ currentDiagram.databaseType === targetDatabaseType ||+ hasCrossDialectSupport(+ currentDiagram.databaseType,+ targetDatabaseType+ )+ );+ }, [targetDatabaseType, currentDiagram.databaseType]);++ // Show toggle only for cross-dialect exports where both options are available+ const showExportModeToggle = useMemo(() => {+ return (+ hasDeterministicPath &&+ currentDiagram.databaseType !== targetDatabaseType &&+ targetDatabaseType !== DatabaseType.GENERIC+ );+ }, [hasDeterministicPath, currentDiagram.databaseType, targetDatabaseType]);+const exportSQLScript = useCallback(async () => {const filteredDiagram: Diagram = {...currentDiagram,@@ -120,7 +143,8 @@ export const ExportSQLDialog: React.FC<ExportSQLDialogProps> = ({}),};- if (targetDatabaseType === DatabaseType.GENERIC) {+ // Use deterministic export if available and AI export is not selected+ if (hasDeterministicPath && !useAIExport) {return Promise.resolve(exportBaseSQL({diagram: filteredDiagram,@@ -135,7 +159,13 @@ export const ExportSQLDialog: React.FC<ExportSQLDialogProps> = ({signal: abortControllerRef.current?.signal,});}- }, [targetDatabaseType, currentDiagram, filter]);+ }, [+ targetDatabaseType,+ currentDiagram,+ filter,+ hasDeterministicPath,+ useAIExport,+ ]);useEffect(() => {if (!dialog.open) {@@ -249,6 +279,36 @@ export const ExportSQLDialog: React.FC<ExportSQLDialogProps> = ({],})}</DialogDescription>+ {showExportModeToggle && (+ <div className="flex items-center pt-2">+ <div className="grid h-auto grid-cols-2 gap-1 rounded-xl border bg-background p-1">+ <button+ type="button"+ className={`inline-flex items-center justify-center gap-1.5 rounded-lg px-3 py-1 text-xs transition-all ${+ !useAIExport+ ? 'bg-secondary text-secondary-foreground shadow-sm'+ : 'text-muted-foreground hover:bg-muted/50 hover:text-foreground'+ }`}+ onClick={() => setUseAIExport(false)}+ >+ <Blocks className="size-3" />+ Deterministic+ </button>+ <button+ type="button"+ className={`inline-flex items-center justify-center gap-1.5 rounded-lg px-3 py-1 text-xs transition-all ${+ useAIExport+ ? 'bg-secondary text-secondary-foreground shadow-sm'+ : 'text-muted-foreground hover:bg-muted/50 hover:text-foreground'+ }`}+ onClick={() => setUseAIExport(true)}+ >+ <Wand2 className="size-3" />+ AI+ </button>+ </div>+ </div>+ )}</DialogHeader><DialogInternalContent><div className="flex flex-1 items-center justify-center">diff --git a/src/lib/data/sql-export/__tests__/cross-dialect-export.test.ts b/src/lib/data/sql-export/__tests__/cross-dialect-export.test.tsnew file mode 100644index 00000000..9b77659d--- /dev/null+++ b/src/lib/data/sql-export/__tests__/cross-dialect-export.test.ts@@ -0,0 +1,849 @@+import { describe, it, expect } from 'vitest';+import { exportPostgreSQLToMySQL } from '../cross-dialect/postgresql/to-mysql';+import { exportPostgreSQLToMSSQL } from '../cross-dialect/postgresql/to-mssql';+import { exportBaseSQL } from '../export-sql-script';+import { DatabaseType } from '@/lib/domain/database-type';+import type { Diagram } from '@/lib/domain/diagram';+import type { DBTable } from '@/lib/domain/db-table';+import type { DBField } from '@/lib/domain/db-field';+import {+ type DBCustomType,+ DBCustomTypeKind,+} from '@/lib/domain/db-custom-type';++describe('Cross-Dialect Export Tests', () => {+ let idCounter = 0;+ const testId = () => `test-id-${++idCounter}`;+ const testTime = Date.now();++ const createField = (overrides: Partial<DBField>): DBField =>+ ({+ id: testId(),+ name: 'field',+ type: { id: 'text', name: 'text' },+ primaryKey: false,+ nullable: true,+ unique: false,+ createdAt: testTime,+ ...overrides,+ }) as DBField;++ const createTable = (overrides: Partial<DBTable>): DBTable =>+ ({+ id: testId(),+ name: 'table',+ fields: [],+ indexes: [],+ createdAt: testTime,+ x: 0,+ y: 0,+ width: 200,+ ...overrides,+ }) as DBTable;++ const createDiagram = (overrides: Partial<Diagram>): Diagram =>+ ({+ id: testId(),+ name: 'diagram',+ databaseType: DatabaseType.POSTGRESQL,+ tables: [],+ relationships: [],+ createdAt: testTime,+ updatedAt: testTime,+ ...overrides,+ }) as Diagram;++ describe('PostgreSQL to MySQL Export', () => {+ describe('Type Conversions', () => {+ it('should convert basic integer types', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'users',+ fields: [+ createField({+ name: 'id',+ type: { id: 'int', name: 'int' },+ primaryKey: true,+ nullable: false,+ }),+ createField({+ name: 'count',+ type: { id: 'bigint', name: 'bigint' },+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('`id` INT NOT NULL');+ expect(result).toContain('`count` BIGINT');+ });++ it('should convert boolean to TINYINT(1)', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'flags',+ fields: [+ createField({+ name: 'is_active',+ type: { id: 'boolean', name: 'boolean' },+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('TINYINT(1)');+ });++ it('should convert UUID to CHAR(36) with comment', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'entities',+ fields: [+ createField({+ name: 'external_id',+ type: { id: 'uuid', name: 'uuid' },+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('CHAR(36)');+ expect(result).toContain('-- Was: uuid');+ });++ it('should convert JSONB to JSON with inline comment', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'documents',+ fields: [+ createField({+ name: 'data',+ type: { id: 'jsonb', name: 'jsonb' },+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('JSON');+ expect(result).toContain('-- Was: jsonb');+ });++ it('should convert array types to JSON', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'posts',+ fields: [+ createField({+ name: 'tags',+ type: { id: 'text[]', name: 'text[]' },+ isArray: true,+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('JSON');+ expect(result).toContain('PostgreSQL array');+ });++ it('should convert SERIAL to INT AUTO_INCREMENT', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'items',+ fields: [+ createField({+ name: 'id',+ type: { id: 'serial', name: 'serial' },+ primaryKey: true,+ nullable: false,+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('INT');+ expect(result).toContain('AUTO_INCREMENT');+ });++ it('should convert nextval default to AUTO_INCREMENT', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'items',+ fields: [+ createField({+ name: 'id',+ type: { id: 'int', name: 'int' },+ primaryKey: true,+ nullable: false,+ default:+ "nextval('items_id_seq'::regclass)",+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('AUTO_INCREMENT');+ expect(result).not.toContain('nextval');+ });++ it('should convert timestamptz to DATETIME with warning', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'events',+ fields: [+ createField({+ name: 'occurred_at',+ type: {+ id: 'timestamptz',+ name: 'timestamptz',+ },+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('DATETIME');+ expect(result).toContain('-- Was: timestamptz');+ });++ it('should convert inet to VARCHAR(45)', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'connections',+ fields: [+ createField({+ name: 'ip_address',+ type: { id: 'inet', name: 'inet' },+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('VARCHAR(45)');+ });+ });++ describe('ENUM Types', () => {+ it('should convert ENUM to VARCHAR with values comment', () => {+ const customTypes: DBCustomType[] = [+ {+ id: testId(),+ name: 'status_type',+ kind: DBCustomTypeKind.enum,+ values: ['pending', 'active', 'closed'],+ },+ ];++ const diagram = createDiagram({+ customTypes,+ tables: [+ createTable({+ name: 'tickets',+ fields: [+ createField({+ name: 'status',+ type: {+ id: 'status_type',+ name: 'status_type',+ },+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('VARCHAR');+ expect(result).toContain("'pending', 'active', 'closed'");+ });+ });++ describe('Schema Handling', () => {+ it('should convert PostgreSQL schema to MySQL database', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'users',+ schema: 'app',+ fields: [+ createField({+ name: 'id',+ type: { id: 'int', name: 'int' },+ primaryKey: true,+ nullable: false,+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('CREATE DATABASE IF NOT EXISTS `app`');+ expect(result).toContain('`app`.`users`');+ });+ });++ describe('Default Values', () => {+ it('should convert now() to CURRENT_TIMESTAMP', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'logs',+ fields: [+ createField({+ name: 'created_at',+ type: {+ id: 'timestamp',+ name: 'timestamp',+ },+ default: 'now()',+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('DEFAULT CURRENT_TIMESTAMP');+ });++ it('should convert gen_random_uuid() to UUID()', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'entities',+ fields: [+ createField({+ name: 'id',+ type: { id: 'uuid', name: 'uuid' },+ default: 'gen_random_uuid()',+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('DEFAULT (UUID())');+ });+ });++ describe('Warnings Header', () => {+ it('should include conversion notes header', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'test',+ fields: [+ createField({+ name: 'data',+ type: { id: 'jsonb', name: 'jsonb' },+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('-- PostgreSQL to MySQL conversion');+ expect(result).toContain('-- Generated by ChartDB');+ });+ });+ });++ describe('PostgreSQL to SQL Server Export', () => {+ describe('Type Conversions', () => {+ it('should convert boolean to BIT', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'flags',+ fields: [+ createField({+ name: 'is_active',+ type: { id: 'boolean', name: 'boolean' },+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMSSQL({ diagram });++ expect(result).toContain('BIT');+ });++ it('should convert UUID to UNIQUEIDENTIFIER', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'entities',+ fields: [+ createField({+ name: 'id',+ type: { id: 'uuid', name: 'uuid' },+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMSSQL({ diagram });++ expect(result).toContain('UNIQUEIDENTIFIER');+ });++ it('should convert TEXT to NVARCHAR(MAX)', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'articles',+ fields: [+ createField({+ name: 'content',+ type: { id: 'text', name: 'text' },+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMSSQL({ diagram });++ expect(result).toContain('NVARCHAR(MAX)');+ });++ it('should convert SERIAL to INT IDENTITY', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'items',+ fields: [+ createField({+ name: 'id',+ type: { id: 'serial', name: 'serial' },+ primaryKey: true,+ nullable: false,+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMSSQL({ diagram });++ expect(result).toContain('INT');+ expect(result).toContain('IDENTITY(1,1)');+ });++ it('should convert timestamptz to DATETIMEOFFSET', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'events',+ fields: [+ createField({+ name: 'occurred_at',+ type: {+ id: 'timestamptz',+ name: 'timestamptz',+ },+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMSSQL({ diagram });++ expect(result).toContain('DATETIMEOFFSET');+ });++ it('should convert JSON/JSONB to NVARCHAR(MAX)', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'documents',+ fields: [+ createField({+ name: 'data',+ type: { id: 'jsonb', name: 'jsonb' },+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMSSQL({ diagram });++ expect(result).toContain('NVARCHAR(MAX)');+ });+ });++ describe('Default Values', () => {+ it('should convert now() to GETDATE()', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'logs',+ fields: [+ createField({+ name: 'created_at',+ type: {+ id: 'timestamp',+ name: 'timestamp',+ },+ default: 'now()',+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMSSQL({ diagram });++ expect(result).toContain('DEFAULT GETDATE()');+ });++ it('should convert gen_random_uuid() to NEWID()', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'entities',+ fields: [+ createField({+ name: 'id',+ type: { id: 'uuid', name: 'uuid' },+ default: 'gen_random_uuid()',+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMSSQL({ diagram });++ expect(result).toContain('DEFAULT NEWID()');+ });++ it('should convert true/false to 1/0', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'settings',+ fields: [+ createField({+ name: 'is_enabled',+ type: { id: 'boolean', name: 'boolean' },+ default: 'true',+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMSSQL({ diagram });++ expect(result).toContain('DEFAULT 1');+ });+ });++ describe('Schema Handling', () => {+ it('should create SQL Server schema', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'users',+ schema: 'app',+ fields: [+ createField({+ name: 'id',+ type: { id: 'int', name: 'int' },+ primaryKey: true,+ nullable: false,+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMSSQL({ diagram });++ expect(result).toContain(+ "SELECT * FROM sys.schemas WHERE name = 'app'"+ );+ expect(result).toContain('[app].[users]');+ });+ });++ describe('Comments via Extended Properties', () => {+ it('should add table comments as extended properties', () => {+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'users',+ comments: 'User accounts table',+ fields: [+ createField({+ name: 'id',+ type: { id: 'int', name: 'int' },+ primaryKey: true,+ nullable: false,+ }),+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMSSQL({ diagram });++ expect(result).toContain('sp_addextendedproperty');+ expect(result).toContain('User accounts table');+ });+ });+ });++ describe('Export Routing via exportBaseSQL', () => {+ it('should route PostgreSQL to MySQL through deterministic exporter', () => {+ const diagram = createDiagram({+ databaseType: DatabaseType.POSTGRESQL,+ tables: [+ createTable({+ name: 'test',+ fields: [+ createField({+ name: 'id',+ type: { id: 'uuid', name: 'uuid' },+ }),+ ],+ }),+ ],+ });++ const result = exportBaseSQL({+ diagram,+ targetDatabaseType: DatabaseType.MYSQL,+ });++ // Should use deterministic export (CHAR(36) for UUID)+ expect(result).toContain('CHAR(36)');+ expect(result).toContain('-- PostgreSQL to MySQL conversion');+ });++ it('should route PostgreSQL to SQL Server through deterministic exporter', () => {+ const diagram = createDiagram({+ databaseType: DatabaseType.POSTGRESQL,+ tables: [+ createTable({+ name: 'test',+ fields: [+ createField({+ name: 'id',+ type: { id: 'uuid', name: 'uuid' },+ }),+ ],+ }),+ ],+ });++ const result = exportBaseSQL({+ diagram,+ targetDatabaseType: DatabaseType.SQL_SERVER,+ });++ // Should use deterministic export (UNIQUEIDENTIFIER for UUID)+ expect(result).toContain('UNIQUEIDENTIFIER');+ expect(result).toContain('-- PostgreSQL to SQL Server conversion');+ });++ it('should route PostgreSQL to MariaDB through MySQL deterministic exporter', () => {+ const diagram = createDiagram({+ databaseType: DatabaseType.POSTGRESQL,+ tables: [+ createTable({+ name: 'test',+ fields: [+ createField({+ name: 'active',+ type: { id: 'boolean', name: 'boolean' },+ }),+ ],+ }),+ ],+ });++ const result = exportBaseSQL({+ diagram,+ targetDatabaseType: DatabaseType.MARIADB,+ });++ // Should use MySQL-style conversion (TINYINT(1) for boolean)+ expect(result).toContain('TINYINT(1)');+ });+ });++ describe('Index Handling', () => {+ it('should downgrade GIN index to BTREE for MySQL', () => {+ const fieldId = testId();+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'documents',+ fields: [+ createField({+ id: fieldId,+ name: 'data',+ type: { id: 'jsonb', name: 'jsonb' },+ }),+ ],+ indexes: [+ {+ id: testId(),+ name: 'idx_data',+ unique: false,+ fieldIds: [fieldId],+ createdAt: testTime,+ type: 'gin',+ },+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('CREATE INDEX');+ expect(result).toContain('-- GIN index downgraded to BTREE');+ });++ it('should add prefix length for JSON indexes in MySQL', () => {+ const fieldId = testId();+ const diagram = createDiagram({+ tables: [+ createTable({+ name: 'documents',+ fields: [+ createField({+ id: fieldId,+ name: 'data',+ type: { id: 'jsonb', name: 'jsonb' },+ }),+ ],+ indexes: [+ {+ id: testId(),+ name: 'idx_data',+ unique: false,+ fieldIds: [fieldId],+ createdAt: testTime,+ },+ ],+ }),+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ // JSON columns in MySQL need prefix length for indexing+ expect(result).toContain('(255)');+ });+ });++ describe('Foreign Key Handling', () => {+ it('should generate foreign keys with MySQL syntax', () => {+ const sourceFieldId = testId();+ const targetFieldId = testId();+ const sourceTableId = testId();+ const targetTableId = testId();++ const diagram = createDiagram({+ tables: [+ createTable({+ id: sourceTableId,+ name: 'orders',+ fields: [+ createField({+ id: sourceFieldId,+ name: 'user_id',+ type: { id: 'int', name: 'int' },+ }),+ ],+ }),+ createTable({+ id: targetTableId,+ name: 'users',+ fields: [+ createField({+ id: targetFieldId,+ name: 'id',+ type: { id: 'int', name: 'int' },+ primaryKey: true,+ }),+ ],+ }),+ ],+ relationships: [+ {+ id: testId(),+ name: 'fk_orders_users',+ sourceTableId,+ targetTableId,+ sourceFieldId,+ targetFieldId,+ sourceCardinality: 'many',+ targetCardinality: 'one',+ createdAt: testTime,+ },+ ],+ });++ const result = exportPostgreSQLToMySQL({ diagram });++ expect(result).toContain('ALTER TABLE');+ expect(result).toContain('ADD CONSTRAINT');+ expect(result).toContain('FOREIGN KEY');+ expect(result).toContain('REFERENCES');+ });+ });+});diff --git a/src/lib/data/sql-export/cross-dialect/common.ts b/src/lib/data/sql-export/cross-dialect/common.tsnew file mode 100644index 00000000..7a03c6a9--- /dev/null+++ b/src/lib/data/sql-export/cross-dialect/common.ts@@ -0,0 +1,131 @@+/**+ * Common utilities for cross-dialect SQL export.+ * These utilities are shared across all cross-dialect exporters.+ */++import type { Diagram } from '@/lib/domain/diagram';+import type { DBTable } from '@/lib/domain/db-table';++export function isFunction(value: string): boolean {+ // Common SQL functions+ const functionPatterns = [+ /^CURRENT_TIMESTAMP$/i,+ /^NOW\(\)$/i,+ /^GETDATE\(\)$/i,+ /^CURRENT_DATE$/i,+ /^CURRENT_TIME$/i,+ /^UUID\(\)$/i,+ /^NEWID\(\)$/i,+ /^NEXT VALUE FOR/i,+ /^IDENTITY\s*\(\d+,\s*\d+\)$/i,+ ];+ return functionPatterns.some((pattern) => pattern.test(value.trim()));+}++export function isKeyword(value: string): boolean {+ // Common SQL keywords that can be used as default values+ const keywords = [+ 'NULL',+ 'TRUE',+ 'FALSE',+ 'CURRENT_TIMESTAMP',+ 'CURRENT_DATE',+ 'CURRENT_TIME',+ 'CURRENT_USER',+ 'SESSION_USER',+ 'SYSTEM_USER',+ ];+ return keywords.includes(value.trim().toUpperCase());+}++export function strHasQuotes(value: string): boolean {+ return /^['"].*['"]$/.test(value.trim());+}++export function exportFieldComment(comment: string): string {+ if (!comment) {+ return '';+ }++ return comment+ .split('\n')+ .map((commentLine) => ` -- ${commentLine}\n`)+ .join('');+}++export function escapeSQLComment(comment: string): string {+ if (!comment) {+ return '';+ }++ // Escape single quotes by doubling them+ let escaped = comment.replace(/'/g, "''");++ // Replace newlines with spaces to prevent breaking SQL syntax+ // Some databases support multi-line comments with specific syntax,+ // but for maximum compatibility, we'll replace newlines with spaces+ escaped = escaped.replace(/[\r\n]+/g, ' ');++ // Trim any excessive whitespace+ escaped = escaped.replace(/\s+/g, ' ').trim();++ return escaped;+}++export function formatTableComment(comment: string): string {+ if (!comment) {+ return '';+ }++ // Split by newlines and add -- to each line+ return (+ comment+ .split('\n')+ .map((line) => `-- ${line}`)+ .join('\n') + '\n'+ );+}++export function formatMSSQLTableComment(comment: string): string {+ if (!comment) {+ return '';+ }++ // For MSSQL, we use multi-line comment syntax+ // Escape */ to prevent breaking the comment block+ const escaped = comment.replace(/\*\//g, '* /');+ return `/**\n${escaped}\n*/\n`;+}++export function getInlineFK(table: DBTable, diagram: Diagram): string {+ if (!diagram.relationships) {+ return '';+ }++ const fks = diagram.relationships+ .filter((r) => r.sourceTableId === table.id)+ .map((r) => {+ const targetTable = diagram.tables?.find(+ (t) => t.id === r.targetTableId+ );+ const sourceField = table.fields.find(+ (f) => f.id === r.sourceFieldId+ );+ const targetField = targetTable?.fields.find(+ (f) => f.id === r.targetFieldId+ );++ if (!targetTable || !sourceField || !targetField) {+ return '';+ }++ const targetTableName = targetTable.schema+ ? `"${targetTable.schema}"."${targetTable.name}"`+ : `"${targetTable.name}"`;++ return ` FOREIGN KEY ("${sourceField.name}") REFERENCES ${targetTableName}("${targetField.name}")`;+ })+ .filter(Boolean);++ return fks.join(',\n');+}diff --git a/src/lib/data/sql-export/cross-dialect/index.ts b/src/lib/data/sql-export/cross-dialect/index.tsnew file mode 100644index 00000000..f2e699e6--- /dev/null+++ b/src/lib/data/sql-export/cross-dialect/index.ts@@ -0,0 +1,90 @@+/**+ * Cross-dialect SQL export module.+ * Provides deterministic conversion between different database dialects.+ */++import { DatabaseType } from '@/lib/domain/database-type';++// Re-export types+export type {+ TypeMapping,+ TypeMappingTable,+ IndexTypeMapping,+ IndexTypeMappingTable,+} from './types';++// Re-export PostgreSQL exporters+export { exportPostgreSQLToMySQL } from './postgresql/to-mysql';+export { exportPostgreSQLToMSSQL } from './postgresql/to-mssql';++// Re-export unsupported features detection+export {+ detectUnsupportedFeatures,+ formatWarningsHeader,+ getFieldInlineComment,+ getIndexInlineComment,+} from './unsupported-features';+export type {+ UnsupportedFeature,+ UnsupportedFeatureType,+} from './unsupported-features';++/**+ * Supported cross-dialect conversion paths.+ * Maps source database type to an array of supported target database types.+ */+const CROSS_DIALECT_SUPPORT: Partial<Record<DatabaseType, DatabaseType[]>> = {+ [DatabaseType.POSTGRESQL]: [+ DatabaseType.MYSQL,+ DatabaseType.MARIADB,+ DatabaseType.SQL_SERVER,+ ],+};++/**+ * Check if deterministic cross-dialect export is supported from source to target database type.+ *+ * @param sourceDatabaseType - The source database type (diagram's original database)+ * @param targetDatabaseType - The target database type for export+ * @returns true if deterministic cross-dialect export is available, false otherwise+ *+ * @example+ * ```ts+ * hasCrossDialectSupport(DatabaseType.POSTGRESQL, DatabaseType.MYSQL) // true+ * hasCrossDialectSupport(DatabaseType.POSTGRESQL, DatabaseType.SQL_SERVER) // true+ * hasCrossDialectSupport(DatabaseType.MYSQL, DatabaseType.POSTGRESQL) // false (not yet implemented)+ * ```+ */+export function hasCrossDialectSupport(+ sourceDatabaseType: DatabaseType,+ targetDatabaseType: DatabaseType+): boolean {+ // Same database type doesn't need cross-dialect conversion+ if (sourceDatabaseType === targetDatabaseType) {+ return false;+ }++ // Generic target doesn't need cross-dialect conversion+ if (targetDatabaseType === DatabaseType.GENERIC) {+ return false;+ }++ const supportedTargets = CROSS_DIALECT_SUPPORT[sourceDatabaseType];+ if (!supportedTargets) {+ return false;+ }++ return supportedTargets.includes(targetDatabaseType);+}++/**+ * Get all supported target database types for a given source database type.+ *+ * @param sourceDatabaseType - The source database type+ * @returns Array of supported target database types, or empty array if none+ */+export function getSupportedTargetDialects(+ sourceDatabaseType: DatabaseType+): DatabaseType[] {+ return CROSS_DIALECT_SUPPORT[sourceDatabaseType] ?? [];+}diff --git a/src/lib/data/sql-export/cross-dialect/postgresql/to-mssql.ts b/src/lib/data/sql-export/cross-dialect/postgresql/to-mssql.tsnew file mode 100644index 00000000..36a2653a--- /dev/null+++ b/src/lib/data/sql-export/cross-dialect/postgresql/to-mssql.ts@@ -0,0 +1,645 @@+/**+ * Deterministic exporter for PostgreSQL diagrams to SQL Server DDL.+ * Converts PostgreSQL-specific types and features to SQL Server equivalents,+ * with comments for features that cannot be fully converted.+ */++import type { Diagram } from '@/lib/domain/diagram';+import type { DBTable } from '@/lib/domain/db-table';+import type { DBField } from '@/lib/domain/db-field';+import type { DBRelationship } from '@/lib/domain/db-relationship';+import type { DBCustomType } from '@/lib/domain/db-custom-type';+import {+ exportFieldComment,+ formatMSSQLTableComment,+ isFunction,+ isKeyword,+ strHasQuotes,+} from '../common';+import {+ postgresqlIndexTypeToSQLServer,+ getTypeMapping,+ getFallbackTypeMapping,+} from './type-mappings';+import {+ detectUnsupportedFeatures,+ formatWarningsHeader,+ getIndexInlineComment,+} from '../unsupported-features';+import { DatabaseType } from '@/lib/domain/database-type';++/**+ * Convert a PostgreSQL default value to SQL Server equivalent+ */+function convertPostgresDefaultToMSSQL(field: DBField): string {+ if (!field.default) {+ return '';+ }++ const defaultValue = field.default.trim();+ const defaultLower = defaultValue.toLowerCase();++ // Handle sequences (nextval) - these become IDENTITY, no default needed+ if (defaultLower.includes('nextval')) {+ return '';+ }++ // Handle PostgreSQL now() -> SQL Server GETDATE()+ if (defaultLower === 'now()' || defaultLower === 'current_timestamp') {+ return 'GETDATE()';+ }++ // Handle UUID generation functions+ if (+ defaultLower.includes('gen_random_uuid') ||+ defaultLower.includes('uuid_generate')+ ) {+ return 'NEWID()';+ }++ // Handle JSONB/JSON functions+ if (+ defaultLower.includes('json_build_object') ||+ defaultLower.includes('jsonb_build_object')+ ) {+ return "N'{}'";+ }+ if (+ defaultLower.includes('json_build_array') ||+ defaultLower.includes('jsonb_build_array')+ ) {+ return "N'[]'";+ }++ // Handle empty array defaults+ if (+ defaultLower === "'{}'::text[]" ||+ defaultLower.match(/'\{\}'::.*\[\]/)+ ) {+ return "N'[]'";+ }++ // Handle array literals+ if (defaultLower.startsWith('array[')) {+ const content = defaultValue.match(/ARRAY\[(.*?)\]/i)?.[1] || '';+ return `N'[${content}]'`;+ }++ // Handle PostgreSQL true/false -> SQL Server 1/0+ if (defaultLower === 'true') {+ return '1';+ }+ if (defaultLower === 'false') {+ return '0';+ }++ // Strip PostgreSQL type casts+ const withoutCast = defaultValue.split('::')[0].trim();++ // Handle SQL Server specific syntax for wrapped defaults+ if (withoutCast.match(/^\(\(.*\)\)$/)) {+ return withoutCast.replace(/^\(\(|\)\)$/g, '');+ }++ // If it's a function call, try to map to SQL Server+ if (isFunction(withoutCast)) {+ return withoutCast;+ }++ // If it's a keyword, keep it+ if (isKeyword(withoutCast)) {+ return withoutCast;+ }++ // If already quoted, convert to N'' style+ if (strHasQuotes(withoutCast)) {+ // Convert single quotes to N'' style+ if (withoutCast.startsWith("'") && withoutCast.endsWith("'")) {+ return `N${withoutCast}`;+ }+ return withoutCast;+ }++ // If it's a number, keep it+ if (/^-?\d+(\.\d+)?$/.test(withoutCast)) {+ return withoutCast;+ }++ // For other cases, wrap in N''+ return `N'${withoutCast.replace(/'/g, "''")}'`;+}++/**+ * Check if a field type matches a custom enum or composite type+ */+function findCustomType(+ fieldTypeName: string,+ customTypes: DBCustomType[]+): DBCustomType | undefined {+ const normalizedName = fieldTypeName.toLowerCase();+ return customTypes.find((ct) => {+ const ctName = ct.schema ? `${ct.schema}.${ct.name}` : ct.name;+ return (+ ctName.toLowerCase() === normalizedName ||+ ct.name.toLowerCase() === normalizedName+ );+ });+}++/**+ * Map a PostgreSQL type to SQL Server type with size/precision handling+ */+function mapPostgresTypeToMSSQL(+ field: DBField,+ customTypes: DBCustomType[]+): {+ typeName: string;+ inlineComment: string | null;+} {+ const originalType = field.type.name.toLowerCase();+ let inlineComment: string | null = null;++ // Handle array types+ if (field.isArray || originalType.endsWith('[]')) {+ return {+ typeName: 'NVARCHAR(MAX)',+ inlineComment: `Was: ${field.type.name} (PostgreSQL array, stored as JSON)`,+ };+ }++ // Check for custom types (ENUM or composite)+ const customType = findCustomType(field.type.name, customTypes);+ if (customType) {+ if (customType.kind === 'enum') {+ // ENUMs become NVARCHAR(255)+ return {+ typeName: 'NVARCHAR(255)',+ inlineComment: null, // Inline comment handled separately via getEnumValuesComment+ };+ } else if (customType.kind === 'composite') {+ // Composite types become NVARCHAR(MAX) as JSON+ return {+ typeName: 'NVARCHAR(MAX)',+ inlineComment: `Was: ${field.type.name} (PostgreSQL composite type)`,+ };+ }+ }++ // Look up mapping+ const mapping = getTypeMapping(originalType, 'sqlserver');+ const effectiveMapping = mapping || getFallbackTypeMapping('sqlserver');++ let typeName = effectiveMapping.targetType;++ // Handle size/precision+ if (field.characterMaximumLength) {+ if (+ typeName === 'VARCHAR' ||+ typeName === 'NVARCHAR' ||+ typeName === 'CHAR' ||+ typeName === 'NCHAR' ||+ typeName === 'VARBINARY'+ ) {+ typeName = `${typeName}(${field.characterMaximumLength})`;+ }+ } else if (effectiveMapping.defaultLength) {+ if (+ typeName === 'VARCHAR' ||+ typeName === 'NVARCHAR' ||+ typeName === 'CHAR' ||+ typeName === 'NCHAR'+ ) {+ typeName = `${typeName}(${effectiveMapping.defaultLength})`;+ }+ }++ if (field.precision !== undefined && field.scale !== undefined) {+ if (+ typeName === 'DECIMAL' ||+ typeName === 'NUMERIC' ||+ typeName === 'DATETIME2' ||+ typeName === 'DATETIMEOFFSET'+ ) {+ if (typeName === 'DATETIME2' || typeName === 'DATETIMEOFFSET') {+ // For datetime types, only precision applies (fractional seconds)+ if (field.precision !== null && field.precision <= 7) {+ typeName = `${typeName}(${field.precision})`;+ }+ } else {+ typeName = `${typeName}(${field.precision}, ${field.scale})`;+ }+ }+ } else if (field.precision !== undefined) {+ if (typeName === 'DECIMAL' || typeName === 'NUMERIC') {+ typeName = `${typeName}(${field.precision})`;+ }+ } else if (+ effectiveMapping.defaultPrecision &&+ (typeName === 'DECIMAL' || typeName === 'NUMERIC')+ ) {+ typeName = `${typeName}(${effectiveMapping.defaultPrecision}, ${effectiveMapping.defaultScale || 0})`;+ }++ // Set inline comment if conversion note exists+ if (effectiveMapping.includeInlineComment) {+ inlineComment = `Was: ${field.type.name}`;+ }++ return { typeName, inlineComment };+}++/**+ * Check if a field should have IDENTITY+ */+function isIdentity(field: DBField): boolean {+ // Check increment flag+ if (field.increment) {+ return true;+ }++ // Check for serial types+ const typeLower = field.type.name.toLowerCase();+ if (+ typeLower === 'serial' ||+ typeLower === 'smallserial' ||+ typeLower === 'bigserial'+ ) {+ return true;+ }++ // Check for nextval in default+ if (field.default?.toLowerCase().includes('nextval')) {+ return true;+ }++ return false;+}++/**+ * Build enum value comment for custom enum types+ */+function getEnumValuesComment(+ fieldTypeName: string,+ customTypes: DBCustomType[]+): string | null {+ const enumType = customTypes.find((ct) => {+ const ctName = ct.schema ? `${ct.schema}.${ct.name}` : ct.name;+ return (+ ctName.toLowerCase() === fieldTypeName.toLowerCase() ||+ ct.name.toLowerCase() === fieldTypeName.toLowerCase()+ );+ });++ if (enumType?.kind === 'enum' && enumType.values?.length) {+ return `PostgreSQL ENUM: '${enumType.values.join("', '")}'`;+ }++ return null;+}++/**+ * Main export function: PostgreSQL diagram to SQL Server DDL+ */+export function exportPostgreSQLToMSSQL({+ diagram,+ onlyRelationships = false,+}: {+ diagram: Diagram;+ onlyRelationships?: boolean;+}): string {+ if (!diagram.tables || !diagram.relationships) {+ return '';+ }++ const tables = diagram.tables;+ const relationships = diagram.relationships;+ const customTypes = diagram.customTypes || [];++ // Detect unsupported features for warnings header+ const unsupportedFeatures = detectUnsupportedFeatures(+ diagram,+ DatabaseType.SQL_SERVER+ );++ // Build output+ let sqlScript = formatWarningsHeader(+ unsupportedFeatures,+ 'PostgreSQL',+ 'SQL Server'+ );++ if (!onlyRelationships) {+ // Create schemas if they don't exist+ const schemas = new Set<string>();+ tables.forEach((table) => {+ if (table.schema) {+ schemas.add(table.schema);+ }+ });++ schemas.forEach((schema) => {+ sqlScript += `IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = '${schema}')\nBEGIN\n EXEC('CREATE SCHEMA [${schema}]');\nEND;\nGO\n`;+ });++ if (schemas.size > 0) {+ sqlScript += '\n';+ }++ // Generate table creation SQL+ sqlScript += tables+ .map((table: DBTable) => {+ // Skip views+ if (table.isView) {+ return '';+ }++ const tableName = table.schema+ ? `[${table.schema}].[${table.name}]`+ : `[${table.name}]`;++ // Get primary key fields+ const primaryKeyFields = table.fields.filter(+ (f) => f.primaryKey+ );++ return `${+ table.comments+ ? formatMSSQLTableComment(table.comments)+ : ''+ }CREATE TABLE ${tableName} (\n${table.fields+ .map((field: DBField) => {+ const fieldName = `[${field.name}]`;++ // Map type to SQL Server+ const { typeName, inlineComment } =+ mapPostgresTypeToMSSQL(field, customTypes);++ // Check for enum type and get values+ const enumComment = getEnumValuesComment(+ field.type.name,+ customTypes+ );++ // Combine inline comments+ const fullInlineComment = enumComment || inlineComment;++ const notNull = field.nullable ? '' : ' NOT NULL';++ // Handle IDENTITY+ const identity = isIdentity(field)+ ? ' IDENTITY(1,1)'+ : '';++ // Only add UNIQUE constraint if not primary key+ const unique =+ !field.primaryKey && field.unique ? ' UNIQUE' : '';++ // Handle default value+ const convertedDefault =+ convertPostgresDefaultToMSSQL(field);+ const defaultValue =+ convertedDefault && !identity+ ? ` DEFAULT ${convertedDefault}`+ : '';++ // Build inline SQL comment for conversion notes+ const sqlInlineComment = fullInlineComment+ ? ` -- ${fullInlineComment}`+ : '';++ return `${exportFieldComment(field.comments ?? '')} ${fieldName} ${typeName}${notNull}${identity}${unique}${defaultValue}${sqlInlineComment}`;+ })+ .join(',\n')}${+ // Add PRIMARY KEY as table constraint+ primaryKeyFields.length > 0+ ? `,\n ${(() => {+ const pkIndex = table.indexes.find(+ (idx) => idx.isPrimaryKey+ );+ return pkIndex?.name+ ? `CONSTRAINT [${pkIndex.name}] `+ : '';+ })()}PRIMARY KEY (${primaryKeyFields+ .map((f) => `[${f.name}]`)+ .join(', ')})`+ : ''+ }\n);\nGO${+ // Add indexes+ (() => {+ const validIndexes = table.indexes+ .map((index) => {+ // Skip primary key indexes+ if (index.isPrimaryKey) {+ return '';+ }++ // Get the list of fields for this index+ const indexFields = index.fieldIds+ .map((fieldId) => {+ const field = table.fields.find(+ (f) => f.id === fieldId+ );+ return field ? field : null;+ })+ .filter(Boolean);++ // Skip if matches primary key+ if (+ primaryKeyFields.length ===+ indexFields.length &&+ primaryKeyFields.every((pk) =>+ indexFields.some(+ (field) =>+ field && field.id === pk.id+ )+ )+ ) {+ return '';+ }++ // Get index type conversion+ const indexType = (+ index.type || 'btree'+ ).toLowerCase();+ const indexTypeMapping =+ postgresqlIndexTypeToSQLServer[indexType];+ const indexInlineComment =+ getIndexInlineComment(index, 'sqlserver');++ const indexName = table.schema+ ? `[${table.schema}_${index.name}]`+ : `[${index.name}]`;++ const indexFieldNames = indexFields+ .map((field) =>+ field ? `[${field.name}]` : ''+ )+ .filter(Boolean);++ // SQL Server has 32 column limit+ if (indexFieldNames.length > 32) {+ console.warn(+ `Warning: Index ${indexName} has ${indexFieldNames.length} columns. Truncating to 32.`+ );+ indexFieldNames.length = 32;+ }++ const commentStr = indexInlineComment+ ? ` -- ${indexInlineComment}`+ : '';++ return indexFieldNames.length > 0+ ? `CREATE ${index.unique ? 'UNIQUE ' : ''}${indexTypeMapping?.targetType === 'CLUSTERED' ? 'CLUSTERED ' : 'NONCLUSTERED '}INDEX ${indexName}\nON ${tableName} (${indexFieldNames.join(', ')});${commentStr}`+ : '';+ })+ .filter(Boolean)+ .sort((a, b) => a.localeCompare(b));++ return validIndexes.length > 0+ ? `\n-- Indexes\n${validIndexes.join('\nGO\n')}\nGO`+ : '';+ })()+ }`;+ })+ .filter(Boolean)+ .join('\n');++ // Add extended properties for table/column comments+ const commentStatements: string[] = [];+ for (const table of tables) {+ if (table.isView) continue;++ const schemaName = table.schema || 'dbo';++ if (table.comments) {+ commentStatements.push(+ `EXEC sp_addextendedproperty @name=N'MS_Description', @value=N'${table.comments.replace(/'/g, "''")}', @level0type=N'SCHEMA', @level0name=N'${schemaName}', @level1type=N'TABLE', @level1name=N'${table.name}';`+ );+ }++ for (const field of table.fields) {+ if (field.comments) {+ commentStatements.push(+ `EXEC sp_addextendedproperty @name=N'MS_Description', @value=N'${field.comments.replace(/'/g, "''")}', @level0type=N'SCHEMA', @level0name=N'${schemaName}', @level1type=N'TABLE', @level1name=N'${table.name}', @level2type=N'COLUMN', @level2name=N'${field.name}';`+ );+ }+ }+ }++ if (commentStatements.length > 0) {+ sqlScript += '\n-- Table and column descriptions\n';+ sqlScript += commentStatements.join('\nGO\n');+ sqlScript += '\nGO\n';+ }+ }++ // Generate foreign keys+ if (relationships.length > 0) {+ sqlScript += '\n-- Foreign key constraints\n';++ // Process relationships and group by schema+ const foreignKeys = relationships+ .map((r: DBRelationship) => {+ const sourceTable = tables.find(+ (t) => t.id === r.sourceTableId+ );+ const targetTable = tables.find(+ (t) => t.id === r.targetTableId+ );++ if (+ !sourceTable ||+ !targetTable ||+ sourceTable.isView ||+ targetTable.isView+ ) {+ return null;+ }++ const sourceField = sourceTable.fields.find(+ (f) => f.id === r.sourceFieldId+ );+ const targetField = targetTable.fields.find(+ (f) => f.id === r.targetFieldId+ );++ if (!sourceField || !targetField) {+ return null;+ }++ // Determine FK placement based on cardinality+ let fkTable, fkField, refTable, refField;++ if (+ r.sourceCardinality === 'one' &&+ r.targetCardinality === 'many'+ ) {+ fkTable = targetTable;+ fkField = targetField;+ refTable = sourceTable;+ refField = sourceField;+ } else if (+ r.sourceCardinality === 'many' &&+ r.targetCardinality === 'one'+ ) {+ fkTable = sourceTable;+ fkField = sourceField;+ refTable = targetTable;+ refField = targetField;+ } else if (+ r.sourceCardinality === 'one' &&+ r.targetCardinality === 'one'+ ) {+ fkTable = sourceTable;+ fkField = sourceField;+ refTable = targetTable;+ refField = targetField;+ } else {+ return null;+ }++ const fkTableName = fkTable.schema+ ? `[${fkTable.schema}].[${fkTable.name}]`+ : `[${fkTable.name}]`;+ const refTableName = refTable.schema+ ? `[${refTable.schema}].[${refTable.name}]`+ : `[${refTable.name}]`;++ return {+ schema: fkTable.schema || 'dbo',+ sql: `ALTER TABLE ${fkTableName} ADD CONSTRAINT [${r.name || `fk_${fkTable.name}_${fkField.name}`}] FOREIGN KEY([${fkField.name}]) REFERENCES ${refTableName}([${refField.name}]);`,+ };+ })+ .filter(Boolean) as { schema: string; sql: string }[];++ // Group by schema+ const fksBySchema = foreignKeys.reduce(+ (acc, fk) => {+ if (!acc[fk.schema]) {+ acc[fk.schema] = [];+ }+ acc[fk.schema].push(fk.sql);+ return acc;+ },+ {} as Record<string, string[]>+ );++ // Sort schemas and output+ const sortedSchemas = Object.keys(fksBySchema).sort();+ const fkSql = sortedSchemas+ .map((schema, index) => {+ const schemaFks = fksBySchema[schema].join('\nGO\n');+ if (index === 0) {+ return `-- Schema: ${schema}\n${schemaFks}`;+ } else {+ return `\n-- Schema: ${schema}\n${schemaFks}`;+ }+ })+ .join('\n');++ sqlScript += fkSql;+ sqlScript += '\nGO\n';+ }++ return sqlScript;+}diff --git a/src/lib/data/sql-export/cross-dialect/postgresql/to-mysql.ts b/src/lib/data/sql-export/cross-dialect/postgresql/to-mysql.tsnew file mode 100644index 00000000..b52a4b30--- /dev/null+++ b/src/lib/data/sql-export/cross-dialect/postgresql/to-mysql.ts@@ -0,0 +1,601 @@+/**+ * Deterministic exporter for PostgreSQL diagrams to MySQL DDL.+ * Converts PostgreSQL-specific types and features to MySQL equivalents,+ * with comments for features that cannot be fully converted.+ */++import type { Diagram } from '@/lib/domain/diagram';+import type { DBTable } from '@/lib/domain/db-table';+import type { DBField } from '@/lib/domain/db-field';+import type { DBRelationship } from '@/lib/domain/db-relationship';+import type { DBCustomType } from '@/lib/domain/db-custom-type';+import {+ exportFieldComment,+ escapeSQLComment,+ formatTableComment,+ isFunction,+ isKeyword,+ strHasQuotes,+} from '../common';+import {+ postgresqlIndexTypeToMySQL,+ getTypeMapping,+ getFallbackTypeMapping,+} from './type-mappings';+import {+ detectUnsupportedFeatures,+ formatWarningsHeader,+ getIndexInlineComment,+} from '../unsupported-features';+import { DatabaseType } from '@/lib/domain/database-type';++/**+ * Convert a PostgreSQL default value to MySQL equivalent+ */+function convertPostgresDefaultToMySQL(field: DBField): string {+ if (!field.default) {+ return '';+ }++ const defaultValue = field.default.trim();+ const defaultLower = defaultValue.toLowerCase();++ // Handle sequences (nextval) - these become AUTO_INCREMENT, no default needed+ if (defaultLower.includes('nextval')) {+ return '';+ }++ // Handle PostgreSQL now() -> MySQL CURRENT_TIMESTAMP+ if (defaultLower === 'now()' || defaultLower === 'current_timestamp') {+ return 'CURRENT_TIMESTAMP';+ }++ // Handle UUID generation functions+ if (+ defaultLower.includes('gen_random_uuid') ||+ defaultLower.includes('uuid_generate')+ ) {+ return '(UUID())';+ }++ // Handle JSONB/JSON functions+ if (+ defaultLower.includes('json_build_object') ||+ defaultLower.includes('jsonb_build_object')+ ) {+ return "'{}'";+ }+ if (+ defaultLower.includes('json_build_array') ||+ defaultLower.includes('jsonb_build_array')+ ) {+ return "'[]'";+ }++ // Handle empty array defaults+ if (+ defaultLower === "'{}'::text[]" ||+ defaultLower.match(/'\{\}'::.*\[\]/)+ ) {+ return "'[]'";+ }++ // Handle array literals like ARRAY[1,2,3]+ if (defaultLower.startsWith('array[')) {+ const content = defaultValue.match(/ARRAY\[(.*?)\]/i)?.[1] || '';+ return `'[${content}]'`;+ }++ // Strip PostgreSQL type casts+ const withoutCast = defaultValue.split('::')[0].trim();++ // If it's a function call, keep it (MySQL might support it)+ if (isFunction(withoutCast)) {+ return withoutCast;+ }++ // If it's a keyword, keep it+ if (isKeyword(withoutCast)) {+ return withoutCast;+ }++ // If already quoted, keep it+ if (strHasQuotes(withoutCast)) {+ return withoutCast;+ }++ // If it's a number, keep it+ if (/^-?\d+(\.\d+)?$/.test(withoutCast)) {+ return withoutCast;+ }++ // For other cases, add quotes+ return `'${withoutCast.replace(/'/g, "''")}'`;+}++/**+ * Check if a field type matches a custom enum or composite type+ */+function findCustomType(+ fieldTypeName: string,+ customTypes: DBCustomType[]+): DBCustomType | undefined {+ const normalizedName = fieldTypeName.toLowerCase();+ return customTypes.find((ct) => {+ const ctName = ct.schema ? `${ct.schema}.${ct.name}` : ct.name;+ return (+ ctName.toLowerCase() === normalizedName ||+ ct.name.toLowerCase() === normalizedName+ );+ });+}++/**+ * Map a PostgreSQL type to MySQL type with size/precision handling+ */+function mapPostgresTypeToMySQL(+ field: DBField,+ customTypes: DBCustomType[]+): {+ typeName: string;+ inlineComment: string | null;+} {+ const originalType = field.type.name.toLowerCase();+ let inlineComment: string | null = null;++ // Handle array types+ if (field.isArray || originalType.endsWith('[]')) {+ return {+ typeName: 'JSON',+ inlineComment: `Was: ${field.type.name} (PostgreSQL array)`,+ };+ }++ // Check for custom types (ENUM or composite)+ const customType = findCustomType(field.type.name, customTypes);+ if (customType) {+ if (customType.kind === 'enum') {+ // ENUMs become VARCHAR(255)+ return {+ typeName: 'VARCHAR(255)',+ inlineComment: null, // Inline comment handled separately via getEnumValuesComment+ };+ } else if (customType.kind === 'composite') {+ // Composite types become JSON+ return {+ typeName: 'JSON',+ inlineComment: `Was: ${field.type.name} (PostgreSQL composite type)`,+ };+ }+ }++ // Look up mapping+ const mapping = getTypeMapping(originalType, 'mysql');+ const effectiveMapping = mapping || getFallbackTypeMapping('mysql');++ let typeName = effectiveMapping.targetType;++ // Handle size/precision+ if (field.characterMaximumLength) {+ if (+ typeName === 'VARCHAR' ||+ typeName === 'CHAR' ||+ typeName === 'VARBINARY'+ ) {+ typeName = `${typeName}(${field.characterMaximumLength})`;+ }+ } else if (effectiveMapping.defaultLength) {+ if (typeName === 'VARCHAR' || typeName === 'CHAR') {+ typeName = `${typeName}(${effectiveMapping.defaultLength})`;+ }+ }++ if (field.precision !== undefined && field.scale !== undefined) {+ if (typeName === 'DECIMAL' || typeName === 'NUMERIC') {+ typeName = `${typeName}(${field.precision}, ${field.scale})`;+ }+ } else if (field.precision !== undefined) {+ if (typeName === 'DECIMAL' || typeName === 'NUMERIC') {+ typeName = `${typeName}(${field.precision})`;+ }+ } else if (+ effectiveMapping.defaultPrecision &&+ (typeName === 'DECIMAL' || typeName === 'NUMERIC')+ ) {+ typeName = `${typeName}(${effectiveMapping.defaultPrecision}, ${effectiveMapping.defaultScale || 0})`;+ }++ // Set inline comment if conversion note exists+ if (effectiveMapping.includeInlineComment) {+ inlineComment = `Was: ${field.type.name}`;+ }++ return { typeName, inlineComment };+}++/**+ * Check if a field should have AUTO_INCREMENT+ */+function isAutoIncrement(field: DBField): boolean {+ // Check increment flag+ if (field.increment) {+ return true;+ }++ // Check for serial types+ const typeLower = field.type.name.toLowerCase();+ if (+ typeLower === 'serial' ||+ typeLower === 'smallserial' ||+ typeLower === 'bigserial'+ ) {+ return true;+ }++ // Check for nextval in default+ if (field.default?.toLowerCase().includes('nextval')) {+ return true;+ }++ return false;+}++/**+ * Build enum value comment for custom enum types+ */+function getEnumValuesComment(+ fieldTypeName: string,+ customTypes: DBCustomType[]+): string | null {+ // Find matching enum type+ const enumType = customTypes.find((ct) => {+ const ctName = ct.schema ? `${ct.schema}.${ct.name}` : ct.name;+ return (+ ctName.toLowerCase() === fieldTypeName.toLowerCase() ||+ ct.name.toLowerCase() === fieldTypeName.toLowerCase()+ );+ });++ if (enumType?.kind === 'enum' && enumType.values?.length) {+ return `PostgreSQL ENUM: '${enumType.values.join("', '")}'`;+ }++ return null;+}++/**+ * Main export function: PostgreSQL diagram to MySQL DDL+ */+export function exportPostgreSQLToMySQL({+ diagram,+ onlyRelationships = false,+}: {+ diagram: Diagram;+ onlyRelationships?: boolean;+}): string {+ if (!diagram.tables || !diagram.relationships) {+ return '';+ }++ const tables = diagram.tables;+ const relationships = diagram.relationships;+ const customTypes = diagram.customTypes || [];++ // Detect unsupported features for warnings header+ const unsupportedFeatures = detectUnsupportedFeatures(+ diagram,+ DatabaseType.MYSQL+ );++ // Build output+ let sqlScript = formatWarningsHeader(+ unsupportedFeatures,+ 'PostgreSQL',+ 'MySQL'+ );++ if (!onlyRelationships) {+ // Create databases (schemas) if they don't exist+ const schemas = new Set<string>();+ tables.forEach((table) => {+ if (table.schema) {+ schemas.add(table.schema);+ }+ });++ schemas.forEach((schema) => {+ sqlScript += `CREATE DATABASE IF NOT EXISTS \`${schema}\`;\n`;+ });++ if (schemas.size > 0) {+ sqlScript += '\n';+ }++ // Generate table creation SQL+ sqlScript += tables+ .map((table: DBTable) => {+ // Skip views+ if (table.isView) {+ return '';+ }++ // Use schema prefix if available+ const tableName = table.schema+ ? `\`${table.schema}\`.\`${table.name}\``+ : `\`${table.name}\``;++ // Get primary key fields+ const primaryKeyFields = table.fields.filter(+ (f) => f.primaryKey+ );++ return `${+ table.comments ? formatTableComment(table.comments) : ''+ }\nCREATE TABLE IF NOT EXISTS ${tableName} (\n${table.fields+ .map((field: DBField) => {+ const fieldName = `\`${field.name}\``;++ // Map type to MySQL+ const { typeName, inlineComment } =+ mapPostgresTypeToMySQL(field, customTypes);++ // Check for enum type and get values+ const enumComment = getEnumValuesComment(+ field.type.name,+ customTypes+ );++ // Combine inline comments+ const fullInlineComment = enumComment || inlineComment;++ const notNull = field.nullable ? '' : ' NOT NULL';++ // Handle auto_increment+ const autoIncrement = isAutoIncrement(field)+ ? ' AUTO_INCREMENT'+ : '';++ // Only add UNIQUE constraint if the field is not part of the primary key+ const unique =+ !field.primaryKey && field.unique ? ' UNIQUE' : '';++ // Handle default value+ const convertedDefault =+ convertPostgresDefaultToMySQL(field);+ const defaultValue =+ convertedDefault && !autoIncrement+ ? ` DEFAULT ${convertedDefault}`+ : '';++ // MySQL supports inline column comments+ const comment = field.comments+ ? ` COMMENT '${escapeSQLComment(field.comments)}'`+ : '';++ // Build inline SQL comment for conversion notes+ const sqlInlineComment = fullInlineComment+ ? ` -- ${fullInlineComment}`+ : '';++ return `${exportFieldComment(field.comments ?? '')} ${fieldName} ${typeName}${notNull}${autoIncrement}${unique}${defaultValue}${comment}${sqlInlineComment}`;+ })+ .join(',\n')}${+ // Add PRIMARY KEY as table constraint+ primaryKeyFields.length > 0+ ? `,\n ${(() => {+ // Find PK index to get the constraint name+ const pkIndex = table.indexes.find(+ (idx) => idx.isPrimaryKey+ );+ return pkIndex?.name+ ? `CONSTRAINT \`${pkIndex.name}\` `+ : '';+ })()}PRIMARY KEY (${primaryKeyFields+ .map((f) => `\`${f.name}\``)+ .join(', ')})`+ : ''+ }\n)${+ // MySQL supports table comments+ table.comments+ ? ` COMMENT='${escapeSQLComment(table.comments)}'`+ : ''+ };${+ // Add indexes+ (() => {+ const validIndexes = table.indexes+ .map((index) => {+ // Skip primary key indexes+ if (index.isPrimaryKey) {+ return '';+ }++ // Get the list of fields for this index+ const indexFields = index.fieldIds+ .map((fieldId) => {+ const field = table.fields.find(+ (f) => f.id === fieldId+ );+ return field ? field : null;+ })+ .filter(Boolean);++ // Skip if this index exactly matches the primary key fields+ if (+ primaryKeyFields.length ===+ indexFields.length &&+ primaryKeyFields.every((pk) =>+ indexFields.some(+ (field) =>+ field && field.id === pk.id+ )+ )+ ) {+ return '';+ }++ // Get index type conversion info+ const indexType = (+ index.type || 'btree'+ ).toLowerCase();+ const indexTypeMapping =+ postgresqlIndexTypeToMySQL[indexType];+ const indexInlineComment =+ getIndexInlineComment(index, 'mysql');++ // Create index name+ const fieldNamesForIndex = indexFields+ .map((field) => field?.name || '')+ .join('_');+ const uniqueIndicator = index.unique+ ? '_unique'+ : '';+ const indexName = `\`idx_${table.name}_${fieldNamesForIndex}${uniqueIndicator}\``;++ // Get the properly quoted field names+ const indexFieldNames = indexFields+ .map((field) =>+ field ? `\`${field.name}\`` : ''+ )+ .filter(Boolean);++ // Check for text/blob fields that need prefix length+ const indexFieldsWithPrefix =+ indexFieldNames.map((name) => {+ const field = indexFields.find(+ (f) => `\`${f?.name}\`` === name+ );+ if (!field) return name;++ const typeName =+ field.type.name.toLowerCase();+ // Check if it maps to TEXT, JSON, or BLOB in MySQL+ const mapping = getTypeMapping(+ typeName,+ 'mysql'+ );+ const targetType = (+ mapping?.targetType || ''+ ).toUpperCase();+ if (+ targetType === 'TEXT' ||+ targetType === 'LONGTEXT' ||+ targetType === 'MEDIUMTEXT' ||+ targetType === 'JSON' ||+ targetType === 'BLOB' ||+ targetType === 'LONGBLOB'+ ) {+ return `${name}(255)`;+ }+ return name;+ });++ const indexTypeStr =+ indexTypeMapping?.targetType &&+ indexTypeMapping.targetType !== 'BTREE'+ ? ` USING ${indexTypeMapping.targetType}`+ : '';++ const commentStr = indexInlineComment+ ? ` -- ${indexInlineComment}`+ : '';++ return indexFieldNames.length > 0+ ? `CREATE ${index.unique ? 'UNIQUE ' : ''}INDEX ${indexName} ON ${tableName}${indexTypeStr} (${indexFieldsWithPrefix.join(', ')});${commentStr}`+ : '';+ })+ .filter(Boolean)+ .sort((a, b) => a.localeCompare(b));++ return validIndexes.length > 0+ ? `\n-- Indexes\n${validIndexes.join('\n')}`+ : '';+ })()+ }`;+ })+ .filter(Boolean)+ .join('\n');+ }++ // Generate foreign keys+ if (relationships.length > 0) {+ sqlScript += '\n-- Foreign key constraints\n';++ const foreignKeys = relationships+ .map((r: DBRelationship) => {+ const sourceTable = tables.find(+ (t) => t.id === r.sourceTableId+ );+ const targetTable = tables.find(+ (t) => t.id === r.targetTableId+ );++ if (+ !sourceTable ||+ !targetTable ||+ sourceTable.isView ||+ targetTable.isView+ ) {+ return '';+ }++ const sourceField = sourceTable.fields.find(+ (f) => f.id === r.sourceFieldId+ );+ const targetField = targetTable.fields.find(+ (f) => f.id === r.targetFieldId+ );++ if (!sourceField || !targetField) {+ return '';+ }++ // Determine which table should have the foreign key based on cardinality+ let fkTable, fkField, refTable, refField;++ if (+ r.sourceCardinality === 'one' &&+ r.targetCardinality === 'many'+ ) {+ fkTable = targetTable;+ fkField = targetField;+ refTable = sourceTable;+ refField = sourceField;+ } else if (+ r.sourceCardinality === 'many' &&+ r.targetCardinality === 'one'+ ) {+ fkTable = sourceTable;+ fkField = sourceField;+ refTable = targetTable;+ refField = targetField;+ } else if (+ r.sourceCardinality === 'one' &&+ r.targetCardinality === 'one'+ ) {+ fkTable = sourceTable;+ fkField = sourceField;+ refTable = targetTable;+ refField = targetField;+ } else {+ // Many-to-many relationships need a junction table, skip+ return '';+ }++ const fkTableName = fkTable.schema+ ? `\`${fkTable.schema}\`.\`${fkTable.name}\``+ : `\`${fkTable.name}\``;+ const refTableName = refTable.schema+ ? `\`${refTable.schema}\`.\`${refTable.name}\``+ : `\`${refTable.name}\``;++ const constraintName = `\`fk_${fkTable.name}_${fkField.name}\``;++ return `ALTER TABLE ${fkTableName} ADD CONSTRAINT ${constraintName} FOREIGN KEY(\`${fkField.name}\`) REFERENCES ${refTableName}(\`${refField.name}\`);`;+ })+ .filter(Boolean);++ sqlScript += foreignKeys.join('\n');+ }++ return sqlScript;+}diff --git a/src/lib/data/sql-export/cross-dialect/postgresql/type-mappings.ts b/src/lib/data/sql-export/cross-dialect/postgresql/type-mappings.tsnew file mode 100644index 00000000..378abe87--- /dev/null+++ b/src/lib/data/sql-export/cross-dialect/postgresql/type-mappings.ts@@ -0,0 +1,576 @@+/**+ * Type mappings for PostgreSQL as the source dialect.+ * Maps PostgreSQL types to MySQL and SQL Server equivalents.+ */++import type {+ TypeMapping,+ TypeMappingTable,+ IndexTypeMappingTable,+} from '../types';++/**+ * PostgreSQL to MySQL type mappings+ */+export const postgresqlToMySQL: TypeMappingTable = {+ // Integer types+ int: { targetType: 'INT' },+ int4: { targetType: 'INT' },+ integer: { targetType: 'INT' },+ smallint: { targetType: 'SMALLINT' },+ int2: { targetType: 'SMALLINT' },+ bigint: { targetType: 'BIGINT' },+ int8: { targetType: 'BIGINT' },++ // Serial types (auto-increment) - handled specially in exporter+ serial: { targetType: 'INT' },+ smallserial: { targetType: 'SMALLINT' },+ bigserial: { targetType: 'BIGINT' },++ // Floating point types+ real: { targetType: 'FLOAT' },+ float4: { targetType: 'FLOAT' },+ 'double precision': { targetType: 'DOUBLE' },+ float8: { targetType: 'DOUBLE' },+ float: { targetType: 'DOUBLE' },++ // Decimal/Numeric types+ decimal: { targetType: 'DECIMAL', defaultPrecision: 10, defaultScale: 2 },+ numeric: { targetType: 'DECIMAL', defaultPrecision: 10, defaultScale: 2 },+ money: {+ targetType: 'DECIMAL',+ defaultPrecision: 19,+ defaultScale: 4,+ conversionNote: 'PostgreSQL money type converted to DECIMAL(19,4)',+ includeInlineComment: true,+ },++ // Character types+ char: { targetType: 'CHAR', defaultLength: 1 },+ character: { targetType: 'CHAR', defaultLength: 1 },+ varchar: { targetType: 'VARCHAR', defaultLength: 255 },+ 'character varying': { targetType: 'VARCHAR', defaultLength: 255 },+ text: { targetType: 'TEXT' },+ name: { targetType: 'VARCHAR', defaultLength: 63 },++ // Binary types+ bytea: {+ targetType: 'LONGBLOB',+ conversionNote: 'PostgreSQL bytea converted to LONGBLOB',+ includeInlineComment: true,+ },++ // Boolean type+ boolean: { targetType: 'TINYINT(1)' },+ bool: { targetType: 'TINYINT(1)' },++ // Date/Time types+ date: { targetType: 'DATE' },+ time: { targetType: 'TIME' },+ timetz: {+ targetType: 'TIME',+ conversionNote: 'Time zone information lost in conversion',+ includeInlineComment: true,+ },+ 'time with time zone': {+ targetType: 'TIME',+ conversionNote: 'Time zone information lost in conversion',+ includeInlineComment: true,+ },+ 'time without time zone': { targetType: 'TIME' },+ timestamp: { targetType: 'DATETIME' },+ timestamptz: {+ targetType: 'DATETIME',+ conversionNote: 'Time zone information lost in conversion',+ includeInlineComment: true,+ },+ 'timestamp with time zone': {+ targetType: 'DATETIME',+ conversionNote: 'Time zone information lost in conversion',+ includeInlineComment: true,+ },+ 'timestamp without time zone': { targetType: 'DATETIME' },+ interval: {+ targetType: 'VARCHAR',+ defaultLength: 100,+ conversionNote:+ 'PostgreSQL interval type has no MySQL equivalent, stored as string',+ includeInlineComment: true,+ },++ // JSON types+ json: { targetType: 'JSON' },+ jsonb: {+ targetType: 'JSON',+ conversionNote:+ 'JSONB binary optimizations not available in MySQL JSON',+ includeInlineComment: true,+ },++ // UUID type+ uuid: {+ targetType: 'CHAR',+ defaultLength: 36,+ conversionNote: 'UUID stored as CHAR(36)',+ includeInlineComment: true,+ },++ // Network types+ inet: {+ targetType: 'VARCHAR',+ defaultLength: 45,+ conversionNote: 'PostgreSQL inet type converted to VARCHAR',+ includeInlineComment: true,+ },+ cidr: {+ targetType: 'VARCHAR',+ defaultLength: 45,+ conversionNote: 'PostgreSQL cidr type converted to VARCHAR',+ includeInlineComment: true,+ },+ macaddr: {+ targetType: 'VARCHAR',+ defaultLength: 17,+ conversionNote: 'PostgreSQL macaddr type converted to VARCHAR',+ includeInlineComment: true,+ },+ macaddr8: {+ targetType: 'VARCHAR',+ defaultLength: 23,+ conversionNote: 'PostgreSQL macaddr8 type converted to VARCHAR',+ includeInlineComment: true,+ },++ // Bit string types+ bit: { targetType: 'BIT', defaultLength: 1 },+ varbit: { targetType: 'BIT', defaultLength: 64 },+ 'bit varying': { targetType: 'BIT', defaultLength: 64 },++ // Geometric types (MySQL has partial support)+ point: { targetType: 'POINT' },+ line: {+ targetType: 'LINESTRING',+ conversionNote: 'PostgreSQL infinite line converted to LINESTRING',+ includeInlineComment: true,+ },+ lseg: { targetType: 'LINESTRING' },+ box: { targetType: 'POLYGON' },+ path: { targetType: 'LINESTRING' },+ polygon: { targetType: 'POLYGON' },+ circle: {+ targetType: 'POLYGON',+ conversionNote: 'PostgreSQL circle approximated as POLYGON',+ includeInlineComment: true,+ },+ geometry: { targetType: 'GEOMETRY' },+ geography: { targetType: 'GEOMETRY' },++ // Text search types (no MySQL equivalent)+ tsvector: {+ targetType: 'TEXT',+ conversionNote:+ 'PostgreSQL full-text search type has no MySQL equivalent',+ includeInlineComment: true,+ },+ tsquery: {+ targetType: 'TEXT',+ conversionNote:+ 'PostgreSQL full-text search type has no MySQL equivalent',+ includeInlineComment: true,+ },++ // Range types (no MySQL equivalent)+ int4range: {+ targetType: 'JSON',+ conversionNote: 'PostgreSQL range type stored as JSON [lower, upper]',+ includeInlineComment: true,+ },+ int8range: {+ targetType: 'JSON',+ conversionNote: 'PostgreSQL range type stored as JSON [lower, upper]',+ includeInlineComment: true,+ },+ numrange: {+ targetType: 'JSON',+ conversionNote: 'PostgreSQL range type stored as JSON [lower, upper]',+ includeInlineComment: true,+ },+ tsrange: {+ targetType: 'JSON',+ conversionNote: 'PostgreSQL range type stored as JSON [lower, upper]',+ includeInlineComment: true,+ },+ tstzrange: {+ targetType: 'JSON',+ conversionNote: 'PostgreSQL range type stored as JSON [lower, upper]',+ includeInlineComment: true,+ },+ daterange: {+ targetType: 'JSON',+ conversionNote: 'PostgreSQL range type stored as JSON [lower, upper]',+ includeInlineComment: true,+ },++ // OID and system types+ oid: { targetType: 'INT UNSIGNED' },+ regproc: { targetType: 'VARCHAR', defaultLength: 255 },+ regprocedure: { targetType: 'VARCHAR', defaultLength: 255 },+ regoper: { targetType: 'VARCHAR', defaultLength: 255 },+ regoperator: { targetType: 'VARCHAR', defaultLength: 255 },+ regclass: { targetType: 'VARCHAR', defaultLength: 255 },+ regtype: { targetType: 'VARCHAR', defaultLength: 255 },+ regrole: { targetType: 'VARCHAR', defaultLength: 255 },+ regnamespace: { targetType: 'VARCHAR', defaultLength: 255 },+ regconfig: { targetType: 'VARCHAR', defaultLength: 255 },+ regdictionary: { targetType: 'VARCHAR', defaultLength: 255 },++ // XML type+ xml: {+ targetType: 'TEXT',+ conversionNote: 'PostgreSQL XML type converted to TEXT',+ includeInlineComment: true,+ },++ // User-defined and array types (handled specially)+ 'user-defined': {+ targetType: 'JSON',+ conversionNote: 'PostgreSQL custom type converted to JSON',+ includeInlineComment: true,+ },+ array: {+ targetType: 'JSON',+ conversionNote: 'PostgreSQL array type converted to JSON',+ includeInlineComment: true,+ },++ // Enum type (handled specially, but fallback here)+ enum: {+ targetType: 'VARCHAR',+ defaultLength: 255,+ conversionNote: 'PostgreSQL ENUM converted to VARCHAR',+ includeInlineComment: true,+ },+};++/**+ * PostgreSQL to SQL Server type mappings+ */+export const postgresqlToSQLServer: TypeMappingTable = {+ // Integer types+ int: { targetType: 'INT' },+ int4: { targetType: 'INT' },+ integer: { targetType: 'INT' },+ smallint: { targetType: 'SMALLINT' },+ int2: { targetType: 'SMALLINT' },+ bigint: { targetType: 'BIGINT' },+ int8: { targetType: 'BIGINT' },++ // Serial types - handled specially with IDENTITY+ serial: { targetType: 'INT' },+ smallserial: { targetType: 'SMALLINT' },+ bigserial: { targetType: 'BIGINT' },++ // Floating point types+ real: { targetType: 'REAL' },+ float4: { targetType: 'REAL' },+ 'double precision': { targetType: 'FLOAT' },+ float8: { targetType: 'FLOAT' },+ float: { targetType: 'FLOAT' },++ // Decimal/Numeric types+ decimal: { targetType: 'DECIMAL', defaultPrecision: 18, defaultScale: 2 },+ numeric: { targetType: 'NUMERIC', defaultPrecision: 18, defaultScale: 2 },+ money: { targetType: 'MONEY' },++ // Character types+ char: { targetType: 'CHAR', defaultLength: 1 },+ character: { targetType: 'CHAR', defaultLength: 1 },+ varchar: { targetType: 'VARCHAR', defaultLength: 255 },+ 'character varying': { targetType: 'VARCHAR', defaultLength: 255 },+ text: { targetType: 'NVARCHAR(MAX)' },+ name: { targetType: 'NVARCHAR', defaultLength: 128 },++ // Binary types+ bytea: { targetType: 'VARBINARY(MAX)' },++ // Boolean type+ boolean: { targetType: 'BIT' },+ bool: { targetType: 'BIT' },++ // Date/Time types+ date: { targetType: 'DATE' },+ time: { targetType: 'TIME' },+ timetz: {+ targetType: 'TIME',+ conversionNote: 'Time zone offset not preserved',+ includeInlineComment: true,+ },+ 'time with time zone': {+ targetType: 'TIME',+ conversionNote: 'Time zone offset not preserved',+ includeInlineComment: true,+ },+ 'time without time zone': { targetType: 'TIME' },+ timestamp: { targetType: 'DATETIME2' },+ timestamptz: { targetType: 'DATETIMEOFFSET' },+ 'timestamp with time zone': { targetType: 'DATETIMEOFFSET' },+ 'timestamp without time zone': { targetType: 'DATETIME2' },+ interval: {+ targetType: 'NVARCHAR',+ defaultLength: 100,+ conversionNote:+ 'PostgreSQL interval type has no SQL Server equivalent, stored as string',+ includeInlineComment: true,+ },++ // JSON types+ json: { targetType: 'NVARCHAR(MAX)' },+ jsonb: {+ targetType: 'NVARCHAR(MAX)',+ conversionNote:+ 'JSON stored as NVARCHAR(MAX). Use ISJSON() for validation, JSON functions for querying.',+ includeInlineComment: true,+ },++ // UUID type+ uuid: { targetType: 'UNIQUEIDENTIFIER' },++ // Network types+ inet: {+ targetType: 'NVARCHAR',+ defaultLength: 45,+ conversionNote: 'PostgreSQL inet type converted to NVARCHAR',+ includeInlineComment: true,+ },+ cidr: {+ targetType: 'NVARCHAR',+ defaultLength: 45,+ conversionNote: 'PostgreSQL cidr type converted to NVARCHAR',+ includeInlineComment: true,+ },+ macaddr: {+ targetType: 'NVARCHAR',+ defaultLength: 17,+ conversionNote: 'PostgreSQL macaddr type converted to NVARCHAR',+ includeInlineComment: true,+ },+ macaddr8: {+ targetType: 'NVARCHAR',+ defaultLength: 23,+ conversionNote: 'PostgreSQL macaddr8 type converted to NVARCHAR',+ includeInlineComment: true,+ },++ // Bit string types+ bit: { targetType: 'BIT' },+ varbit: {+ targetType: 'VARBINARY',+ defaultLength: 64,+ conversionNote: 'Variable bit string converted to VARBINARY',+ includeInlineComment: true,+ },+ 'bit varying': {+ targetType: 'VARBINARY',+ defaultLength: 64,+ conversionNote: 'Variable bit string converted to VARBINARY',+ includeInlineComment: true,+ },++ // Geometric types+ point: { targetType: 'GEOMETRY' },+ line: { targetType: 'GEOMETRY' },+ lseg: { targetType: 'GEOMETRY' },+ box: { targetType: 'GEOMETRY' },+ path: { targetType: 'GEOMETRY' },+ polygon: { targetType: 'GEOMETRY' },+ circle: {+ targetType: 'GEOMETRY',+ conversionNote: 'Circle represented as geometry point with radius',+ includeInlineComment: true,+ },+ geometry: { targetType: 'GEOMETRY' },+ geography: { targetType: 'GEOGRAPHY' },++ // Text search types (no direct equivalent)+ tsvector: {+ targetType: 'NVARCHAR(MAX)',+ conversionNote:+ 'PostgreSQL full-text search. Use SQL Server Full-Text Search instead.',+ includeInlineComment: true,+ },+ tsquery: {+ targetType: 'NVARCHAR(MAX)',+ conversionNote:+ 'PostgreSQL full-text search. Use SQL Server Full-Text Search instead.',+ includeInlineComment: true,+ },++ // Range types (no SQL Server equivalent)+ int4range: {+ targetType: 'NVARCHAR(MAX)',+ conversionNote:+ 'PostgreSQL range type. Consider using two columns for lower/upper bounds.',+ includeInlineComment: true,+ },+ int8range: {+ targetType: 'NVARCHAR(MAX)',+ conversionNote:+ 'PostgreSQL range type. Consider using two columns for lower/upper bounds.',+ includeInlineComment: true,+ },+ numrange: {+ targetType: 'NVARCHAR(MAX)',+ conversionNote:+ 'PostgreSQL range type. Consider using two columns for lower/upper bounds.',+ includeInlineComment: true,+ },+ tsrange: {+ targetType: 'NVARCHAR(MAX)',+ conversionNote:+ 'PostgreSQL range type. Consider using two columns for lower/upper bounds.',+ includeInlineComment: true,+ },+ tstzrange: {+ targetType: 'NVARCHAR(MAX)',+ conversionNote:+ 'PostgreSQL range type. Consider using two columns for lower/upper bounds.',+ includeInlineComment: true,+ },+ daterange: {+ targetType: 'NVARCHAR(MAX)',+ conversionNote:+ 'PostgreSQL range type. Consider using two columns for lower/upper bounds.',+ includeInlineComment: true,+ },++ // OID and system types+ oid: { targetType: 'INT' },+ regproc: { targetType: 'NVARCHAR', defaultLength: 255 },+ regprocedure: { targetType: 'NVARCHAR', defaultLength: 255 },+ regoper: { targetType: 'NVARCHAR', defaultLength: 255 },+ regoperator: { targetType: 'NVARCHAR', defaultLength: 255 },+ regclass: { targetType: 'NVARCHAR', defaultLength: 255 },+ regtype: { targetType: 'NVARCHAR', defaultLength: 255 },+ regrole: { targetType: 'NVARCHAR', defaultLength: 255 },+ regnamespace: { targetType: 'NVARCHAR', defaultLength: 255 },+ regconfig: { targetType: 'NVARCHAR', defaultLength: 255 },+ regdictionary: { targetType: 'NVARCHAR', defaultLength: 255 },++ // XML type+ xml: { targetType: 'XML' },++ // User-defined and array types+ 'user-defined': {+ targetType: 'NVARCHAR(MAX)',+ conversionNote: 'PostgreSQL custom type converted to NVARCHAR(MAX)',+ includeInlineComment: true,+ },+ array: {+ targetType: 'NVARCHAR(MAX)',+ conversionNote:+ 'PostgreSQL array converted to NVARCHAR(MAX) as JSON array',+ includeInlineComment: true,+ },++ // Enum type (handled specially)+ enum: {+ targetType: 'NVARCHAR',+ defaultLength: 255,+ conversionNote: 'PostgreSQL ENUM converted to NVARCHAR',+ includeInlineComment: true,+ },+};++/**+ * Index type mappings from PostgreSQL to MySQL+ */+export const postgresqlIndexTypeToMySQL: IndexTypeMappingTable = {+ btree: { targetType: 'BTREE' },+ hash: { targetType: 'HASH' },+ gin: {+ targetType: 'BTREE',+ note: 'GIN index downgraded to BTREE (MySQL does not support GIN)',+ },+ gist: {+ targetType: 'BTREE',+ note: 'GiST index downgraded to BTREE (MySQL does not support GiST)',+ },+ spgist: {+ targetType: 'BTREE',+ note: 'SP-GiST index downgraded to BTREE (MySQL does not support SP-GiST)',+ },+ brin: {+ targetType: 'BTREE',+ note: 'BRIN index downgraded to BTREE (MySQL does not support BRIN)',+ },+};++/**+ * Index type mappings from PostgreSQL to SQL Server+ */+export const postgresqlIndexTypeToSQLServer: IndexTypeMappingTable = {+ btree: { targetType: 'NONCLUSTERED' },+ hash: {+ targetType: 'NONCLUSTERED',+ note: 'Hash index converted to NONCLUSTERED',+ },+ gin: {+ targetType: 'NONCLUSTERED',+ note: 'GIN index downgraded to NONCLUSTERED. Consider using Full-Text Index.',+ },+ gist: {+ targetType: 'SPATIAL',+ note: 'GiST index converted to SPATIAL (for geometry types) or NONCLUSTERED',+ },+ spgist: {+ targetType: 'NONCLUSTERED',+ note: 'SP-GiST index converted to NONCLUSTERED',+ },+ brin: {+ targetType: 'NONCLUSTERED',+ note: 'BRIN index converted to NONCLUSTERED',+ },+ clustered: { targetType: 'CLUSTERED' },+ nonclustered: { targetType: 'NONCLUSTERED' },+};++/**+ * Get the type mapping for a PostgreSQL type to a target dialect+ */+export function getTypeMapping(+ postgresType: string,+ targetDialect: 'mysql' | 'sqlserver'+): TypeMapping | undefined {+ const normalizedType = postgresType.toLowerCase().trim();++ // Check for array types+ if (normalizedType.endsWith('[]')) {+ return targetDialect === 'mysql'+ ? postgresqlToMySQL['array']+ : postgresqlToSQLServer['array'];+ }++ const mappingTable =+ targetDialect === 'mysql' ? postgresqlToMySQL : postgresqlToSQLServer;+ return mappingTable[normalizedType];+}++/**+ * Get fallback type mapping when no explicit mapping exists+ */+export function getFallbackTypeMapping(+ targetDialect: 'mysql' | 'sqlserver'+): TypeMapping {+ return targetDialect === 'mysql'+ ? {+ targetType: 'TEXT',+ conversionNote: 'Unknown PostgreSQL type converted to TEXT',+ includeInlineComment: true,+ }+ : {+ targetType: 'NVARCHAR(MAX)',+ conversionNote:+ 'Unknown PostgreSQL type converted to NVARCHAR(MAX)',+ includeInlineComment: true,+ };+}diff --git a/src/lib/data/sql-export/cross-dialect/types.ts b/src/lib/data/sql-export/cross-dialect/types.tsnew file mode 100644index 00000000..138d5423--- /dev/null+++ b/src/lib/data/sql-export/cross-dialect/types.ts@@ -0,0 +1,42 @@+/**+ * Shared type definitions for cross-dialect SQL export.+ * These types are used across all source→target dialect mappings.+ */++/**+ * Represents a type mapping from a source database type to a target type.+ */+export interface TypeMapping {+ /** The target database type name */+ targetType: string;+ /** Optional comment/warning about the conversion */+ conversionNote?: string;+ /** Whether the original type info should be included as inline comment */+ includeInlineComment?: boolean;+ /** For types that need length specification */+ defaultLength?: number;+ /** For types that need precision */+ defaultPrecision?: number;+ /** For types that need scale */+ defaultScale?: number;+}++/**+ * A table of type mappings keyed by source type name.+ */+export type TypeMappingTable = Record<string, TypeMapping>;++/**+ * Represents an index type mapping from source to target database.+ */+export interface IndexTypeMapping {+ /** The target index type name */+ targetType: string;+ /** Optional note about the conversion */+ note?: string;+}++/**+ * A table of index type mappings keyed by source index type.+ */+export type IndexTypeMappingTable = Record<string, IndexTypeMapping>;diff --git a/src/lib/data/sql-export/cross-dialect/unsupported-features.ts b/src/lib/data/sql-export/cross-dialect/unsupported-features.tsnew file mode 100644index 00000000..21d02581--- /dev/null+++ b/src/lib/data/sql-export/cross-dialect/unsupported-features.ts@@ -0,0 +1,368 @@+/**+ * Detects PostgreSQL features that cannot be fully converted to target dialects.+ * Used to generate warning comments in cross-dialect exports.+ */++import type { Diagram } from '@/lib/domain/diagram';+import type { DBTable } from '@/lib/domain/db-table';+import type { DBField } from '@/lib/domain/db-field';+import type { DBIndex } from '@/lib/domain/db-index';+import type { DBCustomType } from '@/lib/domain/db-custom-type';+import { DatabaseType } from '@/lib/domain/database-type';+import {+ getTypeMapping,+ postgresqlIndexTypeToMySQL,+ postgresqlIndexTypeToSQLServer,+} from './postgresql/type-mappings';++export type UnsupportedFeatureType =+ | 'type'+ | 'index'+ | 'constraint'+ | 'default'+ | 'custom_type'+ | 'array'+ | 'schema';++export interface UnsupportedFeature {+ type: UnsupportedFeatureType;+ tableName?: string;+ objectName: string;+ feature: string;+ recommendation: string;+}++/**+ * Detect all unsupported PostgreSQL features when converting to a target dialect+ */+export function detectUnsupportedFeatures(+ diagram: Diagram,+ targetDialect: DatabaseType+): UnsupportedFeature[] {+ const features: UnsupportedFeature[] = [];+ const dialectKey =+ targetDialect === DatabaseType.SQL_SERVER ? 'sqlserver' : 'mysql';++ // Check custom types (ENUMs and composites)+ if (diagram.customTypes && diagram.customTypes.length > 0) {+ features.push(+ ...detectCustomTypeIssues(diagram.customTypes, dialectKey)+ );+ }++ // Check each table+ if (diagram.tables) {+ for (const table of diagram.tables) {+ if (table.isView) continue;++ // Check fields+ features.push(...detectFieldIssues(table, dialectKey));++ // Check indexes+ features.push(...detectIndexIssues(table, dialectKey));+ }+ }++ return features;+}++/**+ * Detect issues with custom types (ENUMs, composites)+ */+function detectCustomTypeIssues(+ customTypes: DBCustomType[],+ dialectKey: 'mysql' | 'sqlserver'+): UnsupportedFeature[] {+ const features: UnsupportedFeature[] = [];++ for (const customType of customTypes) {+ const typeName = customType.schema+ ? `${customType.schema}.${customType.name}`+ : customType.name;++ if (customType.kind === 'enum') {+ const values = customType.values?.join("', '") || '';+ features.push({+ type: 'custom_type',+ objectName: typeName,+ feature: `ENUM type with values: '${values}'`,+ recommendation:+ dialectKey === 'mysql'+ ? `Converted to VARCHAR(255). Consider using MySQL ENUM or CHECK constraint.`+ : `Converted to NVARCHAR(255). Consider using CHECK constraint.`,+ });+ } else if (customType.kind === 'composite') {+ const fields =+ customType.fields?.map((f) => `${f.field}: ${f.type}`) || [];+ features.push({+ type: 'custom_type',+ objectName: typeName,+ feature: `Composite type with fields: ${fields.join(', ')}`,+ recommendation:+ dialectKey === 'mysql'+ ? `Converted to JSON. Consider restructuring as separate columns or JSON.`+ : `Converted to NVARCHAR(MAX) as JSON. Consider restructuring as separate columns.`,+ });+ }+ }++ return features;+}++/**+ * Detect issues with field types and defaults+ */+function detectFieldIssues(+ table: DBTable,+ dialectKey: 'mysql' | 'sqlserver'+): UnsupportedFeature[] {+ const features: UnsupportedFeature[] = [];+ const tableName = table.schema+ ? `${table.schema}.${table.name}`+ : table.name;++ for (const field of table.fields) {+ const typeName = field.type.name.toLowerCase();++ // Check for array types+ if (field.isArray || typeName.endsWith('[]')) {+ features.push({+ type: 'array',+ tableName,+ objectName: field.name,+ feature: `Array type: ${typeName}`,+ recommendation:+ dialectKey === 'mysql'+ ? `Converted to JSON. Use JSON_ARRAY() for inserts.`+ : `Converted to NVARCHAR(MAX) as JSON array.`,+ });+ }++ // Check type mapping for conversion notes+ const mapping = getTypeMapping(typeName, dialectKey);+ if (mapping?.conversionNote) {+ features.push({+ type: 'type',+ tableName,+ objectName: field.name,+ feature: `Type: ${typeName}`,+ recommendation: mapping.conversionNote,+ });+ }++ // Check for PostgreSQL-specific defaults+ if (field.default) {+ const defaultLower = field.default.toLowerCase();++ // Sequences+ if (defaultLower.includes('nextval')) {+ const match = field.default.match(/nextval\('([^']+)'/);+ const seqName = match ? match[1] : 'unknown';+ features.push({+ type: 'default',+ tableName,+ objectName: field.name,+ feature: `Sequence: ${seqName}`,+ recommendation:+ dialectKey === 'mysql'+ ? `Converted to AUTO_INCREMENT.`+ : `Converted to IDENTITY(1,1).`,+ });+ }++ // PostgreSQL-specific functions+ if (+ defaultLower.includes('gen_random_uuid') ||+ defaultLower.includes('uuid_generate')+ ) {+ features.push({+ type: 'default',+ tableName,+ objectName: field.name,+ feature: `UUID generation function`,+ recommendation:+ dialectKey === 'mysql'+ ? `Use UUID() function in MySQL.`+ : `Use NEWID() function in SQL Server.`,+ });+ }++ // Array constructors+ if (+ defaultLower.includes('array[') ||+ defaultLower.includes("'{}")+ ) {+ features.push({+ type: 'default',+ tableName,+ objectName: field.name,+ feature: `Array default value`,+ recommendation:+ dialectKey === 'mysql'+ ? `Converted to JSON array literal.`+ : `Converted to JSON array string.`,+ });+ }+ }+ }++ return features;+}++/**+ * Detect issues with index types+ */+function detectIndexIssues(+ table: DBTable,+ dialectKey: 'mysql' | 'sqlserver'+): UnsupportedFeature[] {+ const features: UnsupportedFeature[] = [];+ const tableName = table.schema+ ? `${table.schema}.${table.name}`+ : table.name;++ const indexTypeMap =+ dialectKey === 'mysql'+ ? postgresqlIndexTypeToMySQL+ : postgresqlIndexTypeToSQLServer;++ for (const index of table.indexes) {+ if (index.isPrimaryKey) continue;++ const indexType = (index.type || 'btree').toLowerCase();+ const mapping = indexTypeMap[indexType];++ if (mapping?.note) {+ features.push({+ type: 'index',+ tableName,+ objectName: index.name,+ feature: `${indexType.toUpperCase()} index`,+ recommendation: mapping.note,+ });+ }+ }++ return features;+}++/**+ * Format unsupported features as a warning comment block for SQL output+ */+export function formatWarningsHeader(+ features: UnsupportedFeature[],+ sourceDialect: string,+ targetDialect: string+): string {+ if (features.length === 0) {+ return `-- ${sourceDialect} to ${targetDialect} conversion\n-- Generated by ChartDB\n`;+ }++ let header = `-- ${sourceDialect} to ${targetDialect} conversion\n`;+ header += `-- Generated by ChartDB\n`;+ header += `--\n`;+ header += `-- CONVERSION NOTES (${features.length} items):\n`;++ // Group by type+ const grouped = groupFeaturesByType(features);++ for (const [type, items] of Object.entries(grouped)) {+ header += `--\n`;+ header += `-- ${formatTypeLabel(type as UnsupportedFeatureType)}:\n`;+ for (const item of items) {+ const location = item.tableName+ ? `${item.tableName}.${item.objectName}`+ : item.objectName;+ header += `-- - ${location}: ${item.feature}\n`;+ }+ }++ header += `--\n\n`;+ return header;+}++/**+ * Group features by their type for organized output+ */+function groupFeaturesByType(+ features: UnsupportedFeature[]+): Record<string, UnsupportedFeature[]> {+ const grouped: Record<string, UnsupportedFeature[]> = {};++ for (const feature of features) {+ if (!grouped[feature.type]) {+ grouped[feature.type] = [];+ }+ grouped[feature.type].push(feature);+ }++ return grouped;+}++/**+ * Format type label for display+ */+function formatTypeLabel(type: UnsupportedFeatureType): string {+ switch (type) {+ case 'custom_type':+ return 'Custom Types (ENUM/Composite)';+ case 'array':+ return 'Array Fields';+ case 'type':+ return 'Type Conversions';+ case 'index':+ return 'Index Type Changes';+ case 'default':+ return 'Default Value Conversions';+ case 'constraint':+ return 'Constraint Changes';+ case 'schema':+ return 'Schema Changes';+ default:+ return type;+ }+}++/**+ * Get inline comment for a specific field conversion+ */+export function getFieldInlineComment(+ field: DBField,+ dialectKey: 'mysql' | 'sqlserver'+): string | null {+ const typeName = field.type.name.toLowerCase();++ // Array types+ if (field.isArray || typeName.endsWith('[]')) {+ return `Was: ${field.type.name} (PostgreSQL array)`;+ }++ // Check type mapping+ const mapping = getTypeMapping(typeName, dialectKey);+ if (mapping?.includeInlineComment && mapping.conversionNote) {+ return `Was: ${field.type.name}`;+ }++ return null;+}++/**+ * Get inline comment for an index conversion+ */+export function getIndexInlineComment(+ index: DBIndex,+ dialectKey: 'mysql' | 'sqlserver'+): string | null {+ const indexType = (index.type || 'btree').toLowerCase();+ const indexTypeMap =+ dialectKey === 'mysql'+ ? postgresqlIndexTypeToMySQL+ : postgresqlIndexTypeToSQLServer;+ const mapping = indexTypeMap[indexType];++ if (mapping?.note) {+ return mapping.note;+ }++ return null;+}diff --git a/src/lib/data/sql-export/export-sql-script.ts b/src/lib/data/sql-export/export-sql-script.tsindex dc846459..12c95ed9 100644--- a/src/lib/data/sql-export/export-sql-script.ts+++ b/src/lib/data/sql-export/export-sql-script.ts@@ -8,6 +8,10 @@ import { exportMSSQL } from './export-per-type/mssql';import { exportPostgreSQL } from './export-per-type/postgresql';import { exportSQLite } from './export-per-type/sqlite';import { exportMySQL } from './export-per-type/mysql';+import {+ exportPostgreSQLToMySQL,+ exportPostgreSQLToMSSQL,+} from './cross-dialect';import { escapeSQLComment } from './export-per-type/common';import {databaseTypesWithCommentSupport,@@ -158,6 +162,20 @@ export const exportBaseSQL = ({}}+ // Deterministic cross-dialect exports (PostgreSQL to MySQL/SQL Server)+ // These do not use LLM and provide consistent, predictable output+ if (!isDBMLFlow && diagram.databaseType === DatabaseType.POSTGRESQL) {+ if (+ targetDatabaseType === DatabaseType.MYSQL ||+ targetDatabaseType === DatabaseType.MARIADB+ ) {+ return exportPostgreSQLToMySQL({ diagram, onlyRelationships });+ }+ if (targetDatabaseType === DatabaseType.SQL_SERVER) {+ return exportPostgreSQLToMSSQL({ diagram, onlyRelationships });+ }+ }+// Filter out the tables that are viewsconst nonViewTables = tables.filter((table) => !table.isView);