Skip to content

Database diagrams editor that allows you to visualize and design your DB with a single query.

fix: unique with pk on sql import (#1022)

Guy Ben-Aharon20208f6a5131
diff --git a/src/lib/data/sql-import/dialect-importers/mysql/__tests__/mysql-core.test.ts b/src/lib/data/sql-import/dialect-importers/mysql/__tests__/mysql-core.test.ts
new file mode 100644
index 00000000..1b79c63c
--- /dev/null
+++ b/src/lib/data/sql-import/dialect-importers/mysql/__tests__/mysql-core.test.ts
@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest';
+import { fromMySQL } from '../mysql';
+
+describe('MySQL Core Parser Tests', () => {
+ describe('Primary Key Uniqueness', () => {
+ it('should mark single-column primary key field as unique', async () => {
+ const sql = `
+CREATE TABLE \`table_1\` (
+ \`id\` BIGINT NOT NULL,
+ CONSTRAINT \`pk_table_1_id\` PRIMARY KEY (\`id\`)
+) ENGINE=InnoDB;
+ `;
+
+ const result = await fromMySQL(sql);
+
+ expect(result.tables).toHaveLength(1);
+ const table = result.tables[0];
+ expect(table.name).toBe('table_1');
+
+ const idColumn = table.columns.find((c) => c.name === 'id');
+ expect(idColumn).toBeDefined();
+ expect(idColumn?.primaryKey).toBe(true);
+ expect(idColumn?.unique).toBe(true);
+ });
+
+ it('should not mark composite primary key fields as unique individually', async () => {
+ const sql = `
+CREATE TABLE \`table_1\` (
+ \`id\` BIGINT NOT NULL,
+ \`field_2\` BIGINT NOT NULL,
+ CONSTRAINT \`pk_table_1_id\` PRIMARY KEY (\`id\`, \`field_2\`)
+) ENGINE=InnoDB;
+ `;
+
+ const result = await fromMySQL(sql);
+
+ expect(result.tables).toHaveLength(1);
+ const table = result.tables[0];
+ expect(table.name).toBe('table_1');
+
+ const idColumn = table.columns.find((c) => c.name === 'id');
+ expect(idColumn).toBeDefined();
+ expect(idColumn?.primaryKey).toBe(true);
+ expect(idColumn?.unique).toBe(false);
+
+ const field2Column = table.columns.find(
+ (c) => c.name === 'field_2'
+ );
+ expect(field2Column).toBeDefined();
+ expect(field2Column?.primaryKey).toBe(true);
+ expect(field2Column?.unique).toBe(false);
+ });
+ });
+});
diff --git a/src/lib/data/sql-import/dialect-importers/mysql/mysql.ts b/src/lib/data/sql-import/dialect-importers/mysql/mysql.ts
index 07241c10..7fef28fe 100644
--- a/src/lib/data/sql-import/dialect-importers/mysql/mysql.ts
+++ b/src/lib/data/sql-import/dialect-importers/mysql/mysql.ts
@@ -424,6 +424,9 @@ export async function fromMySQL(sqlContent: string): Promise<SQLParserResult> {
)
);
+ const isSingleColumnPK =
+ pkColumns.length === 1;
+
// Mark columns as PK
for (const colName of pkColumns) {
const col =
@@ -434,6 +437,12 @@ export async function fromMySQL(sqlContent: string): Promise<SQLParserResult> {
);
if (col) {
col.primaryKey = true;
+ // Only mark as unique if single-column PK
+ if (
+ isSingleColumnPK
+ ) {
+ col.unique = true;
+ }
}
}
diff --git a/src/lib/data/sql-import/dialect-importers/oracle/__tests__/oracle-core.test.ts b/src/lib/data/sql-import/dialect-importers/oracle/__tests__/oracle-core.test.ts
index aa340795..f07d431d 100644
--- a/src/lib/data/sql-import/dialect-importers/oracle/__tests__/oracle-core.test.ts
+++ b/src/lib/data/sql-import/dialect-importers/oracle/__tests__/oracle-core.test.ts
@@ -302,4 +302,54 @@ describe('Oracle Core Parser Tests', () => {
result.tables[0].columns.find((c) => c.name === 'Id')
).toBeDefined();
});
+
+ describe('Primary Key Uniqueness', () => {
+ it('should mark single-column primary key field as unique', async () => {
+ const sql = `
+CREATE TABLE table_1 (
+ id NUMBER(19) NOT NULL,
+ CONSTRAINT pk_table_1_id PRIMARY KEY (id)
+);
+ `;
+
+ const result = await fromOracle(sql);
+
+ expect(result.tables).toHaveLength(1);
+ const table = result.tables[0];
+ expect(table.name).toBe('table_1');
+
+ const idColumn = table.columns.find((c) => c.name === 'id');
+ expect(idColumn).toBeDefined();
+ expect(idColumn?.primaryKey).toBe(true);
+ expect(idColumn?.unique).toBe(true);
+ });
+
+ it('should not mark composite primary key fields as unique individually', async () => {
+ const sql = `
+CREATE TABLE table_1 (
+ id NUMBER(19) NOT NULL,
+ field_2 NUMBER(19) NOT NULL,
+ CONSTRAINT pk_table_1_id PRIMARY KEY (id, field_2)
+);
+ `;
+
+ const result = await fromOracle(sql);
+
+ expect(result.tables).toHaveLength(1);
+ const table = result.tables[0];
+ expect(table.name).toBe('table_1');
+
+ const idColumn = table.columns.find((c) => c.name === 'id');
+ expect(idColumn).toBeDefined();
+ expect(idColumn?.primaryKey).toBe(true);
+ expect(idColumn?.unique).toBe(false);
+
+ const field2Column = table.columns.find(
+ (c) => c.name === 'field_2'
+ );
+ expect(field2Column).toBeDefined();
+ expect(field2Column?.primaryKey).toBe(true);
+ expect(field2Column?.unique).toBe(false);
+ });
+ });
});
diff --git a/src/lib/data/sql-import/dialect-importers/oracle/oracle.ts b/src/lib/data/sql-import/dialect-importers/oracle/oracle.ts
index 0221f548..8b421c02 100644
--- a/src/lib/data/sql-import/dialect-importers/oracle/oracle.ts
+++ b/src/lib/data/sql-import/dialect-importers/oracle/oracle.ts
@@ -409,11 +409,18 @@ function parseCreateTableManually(
const pkColumns = pkColumnsMatch[1]
.split(',')
.map((c) => normalizeOracleIdentifier(c.trim()));
+ const isSingleColumnPK = pkColumns.length === 1;
pkColumns.forEach((col) => {
const column = columns.find(
(c) => c.name.toUpperCase() === col.toUpperCase()
);
- if (column) column.primaryKey = true;
+ if (column) {
+ column.primaryKey = true;
+ // Only mark as unique if single-column PK
+ if (isSingleColumnPK) {
+ column.unique = true;
+ }
+ }
});
}
continue;
@@ -436,12 +443,19 @@ function parseCreateTableManually(
const pkColumns = pkColumnsMatch[1]
.split(',')
.map((c) => normalizeOracleIdentifier(c.trim()));
+ const isSingleColumnPK = pkColumns.length === 1;
pkColumns.forEach((col) => {
const column = columns.find(
(c) =>
c.name.toUpperCase() === col.toUpperCase()
);
- if (column) column.primaryKey = true;
+ if (column) {
+ column.primaryKey = true;
+ // Only mark as unique if single-column PK
+ if (isSingleColumnPK) {
+ column.unique = true;
+ }
+ }
});
}
} else if (constraintType === 'UNIQUE') {
diff --git a/src/lib/data/sql-import/dialect-importers/postgresql/__tests__/postgresql-core.test.ts b/src/lib/data/sql-import/dialect-importers/postgresql/__tests__/postgresql-core.test.ts
index 0e03f7b3..8fe2c437 100644
--- a/src/lib/data/sql-import/dialect-importers/postgresql/__tests__/postgresql-core.test.ts
+++ b/src/lib/data/sql-import/dialect-importers/postgresql/__tests__/postgresql-core.test.ts
@@ -550,4 +550,58 @@ CREATE TRIGGER arcane_audit_apprentices AFTER INSERT OR UPDATE OR DELETE ON appr
getPreferredSynonymSpy.mockRestore();
});
});
+
+ describe('Primary Key Uniqueness', () => {
+ it('should mark single-column primary key field as unique', async () => {
+ const sql = `
+CREATE SCHEMA IF NOT EXISTS "public";
+
+CREATE TABLE "public"."table_1" (
+ "id" bigint NOT NULL,
+ CONSTRAINT "pk_table_1_id" PRIMARY KEY ("id")
+);
+ `;
+
+ const result = await fromPostgres(sql);
+
+ expect(result.tables).toHaveLength(1);
+ const table = result.tables[0];
+ expect(table.name).toBe('table_1');
+
+ const idColumn = table.columns.find((c) => c.name === 'id');
+ expect(idColumn).toBeDefined();
+ expect(idColumn?.primaryKey).toBe(true);
+ expect(idColumn?.unique).toBe(true);
+ });
+
+ it('should not mark composite primary key fields as unique individually', async () => {
+ const sql = `
+CREATE SCHEMA IF NOT EXISTS "public";
+
+CREATE TABLE "public"."table_1" (
+ "id" bigint NOT NULL,
+ "field_2" bigint NOT NULL,
+ CONSTRAINT "pk_table_1_id" PRIMARY KEY ("id", "field_2")
+);
+ `;
+
+ const result = await fromPostgres(sql);
+
+ expect(result.tables).toHaveLength(1);
+ const table = result.tables[0];
+ expect(table.name).toBe('table_1');
+
+ const idColumn = table.columns.find((c) => c.name === 'id');
+ expect(idColumn).toBeDefined();
+ expect(idColumn?.primaryKey).toBe(true);
+ expect(idColumn?.unique).toBe(false);
+
+ const field2Column = table.columns.find(
+ (c) => c.name === 'field_2'
+ );
+ expect(field2Column).toBeDefined();
+ expect(field2Column?.primaryKey).toBe(true);
+ expect(field2Column?.unique).toBe(false);
+ });
+ });
});
diff --git a/src/lib/data/sql-import/dialect-importers/postgresql/postgresql.ts b/src/lib/data/sql-import/dialect-importers/postgresql/postgresql.ts
index e94ec6bd..686f95de 100644
--- a/src/lib/data/sql-import/dialect-importers/postgresql/postgresql.ts
+++ b/src/lib/data/sql-import/dialect-importers/postgresql/postgresql.ts
@@ -973,7 +973,11 @@ export async function fromPostgres(
) {
// Process primary key constraint
if (Array.isArray(constraintDef.definition)) {
- constraintDef.definition.forEach(
+ const pkColumns = constraintDef.definition;
+ const isSingleColumnPK =
+ pkColumns.length === 1;
+
+ pkColumns.forEach(
(colDef: ColumnReference) => {
const pkColumnName =
extractColumnName(colDef);
@@ -983,6 +987,11 @@ export async function fromPostgres(
);
if (column) {
column.primaryKey = true;
+ // Only mark as unique if it's a single-column primary key
+ // Composite primary keys don't guarantee uniqueness of individual columns
+ if (isSingleColumnPK) {
+ column.unique = true;
+ }
}
}
);
diff --git a/src/lib/data/sql-import/dialect-importers/sqlite/__tests__/sqlite-import.test.ts b/src/lib/data/sql-import/dialect-importers/sqlite/__tests__/sqlite-import.test.ts
index 5c1ae673..aa8fb01c 100644
--- a/src/lib/data/sql-import/dialect-importers/sqlite/__tests__/sqlite-import.test.ts
+++ b/src/lib/data/sql-import/dialect-importers/sqlite/__tests__/sqlite-import.test.ts
@@ -175,4 +175,54 @@ CREATE TABLE user_products (
targetColumn: 'id',
});
});
+
+ describe('Primary Key Uniqueness', () => {
+ it('should mark single-column primary key field as unique', async () => {
+ const sql = `
+CREATE TABLE table_1 (
+ id INTEGER NOT NULL,
+ CONSTRAINT pk_table_1_id PRIMARY KEY (id)
+);
+ `;
+
+ const result = await fromSQLite(sql);
+
+ expect(result.tables).toHaveLength(1);
+ const table = result.tables[0];
+ expect(table.name).toBe('table_1');
+
+ const idColumn = table.columns.find((c) => c.name === 'id');
+ expect(idColumn).toBeDefined();
+ expect(idColumn?.primaryKey).toBe(true);
+ expect(idColumn?.unique).toBe(true);
+ });
+
+ it('should not mark composite primary key fields as unique individually', async () => {
+ const sql = `
+CREATE TABLE table_1 (
+ id INTEGER NOT NULL,
+ field_2 INTEGER NOT NULL,
+ CONSTRAINT pk_table_1_id PRIMARY KEY (id, field_2)
+);
+ `;
+
+ const result = await fromSQLite(sql);
+
+ expect(result.tables).toHaveLength(1);
+ const table = result.tables[0];
+ expect(table.name).toBe('table_1');
+
+ const idColumn = table.columns.find((c) => c.name === 'id');
+ expect(idColumn).toBeDefined();
+ expect(idColumn?.primaryKey).toBe(true);
+ expect(idColumn?.unique).toBe(false);
+
+ const field2Column = table.columns.find(
+ (c) => c.name === 'field_2'
+ );
+ expect(field2Column).toBeDefined();
+ expect(field2Column?.primaryKey).toBe(true);
+ expect(field2Column?.unique).toBe(false);
+ });
+ });
});
diff --git a/src/lib/data/sql-import/dialect-importers/sqlite/sqlite.ts b/src/lib/data/sql-import/dialect-importers/sqlite/sqlite.ts
index aa03e51d..ff967aef 100644
--- a/src/lib/data/sql-import/dialect-importers/sqlite/sqlite.ts
+++ b/src/lib/data/sql-import/dialect-importers/sqlite/sqlite.ts
@@ -139,6 +139,7 @@ function parseCreateTableStatements(sqlContent: string): {
const tables: {
name: string;
columns: SQLColumn[];
+ primaryKeyColumns?: string[];
}[] = [];
// Remove comments before processing
@@ -162,9 +163,14 @@ function parseCreateTableStatements(sqlContent: string): {
const tableName = match[1];
const tableBody = match[2].trim();
- const table: { name: string; columns: SQLColumn[] } = {
+ const table: {
+ name: string;
+ columns: SQLColumn[];
+ primaryKeyColumns?: string[];
+ } = {
name: tableName,
columns: [],
+ primaryKeyColumns: [],
};
// Special case: sqlite_sequence or tables with columns but no types
@@ -215,14 +221,31 @@ function parseCreateTableStatements(sqlContent: string): {
for (const columnDef of columnDefs) {
const line = columnDef.trim();
+ const upperLine = line.toUpperCase();
- // Skip constraints
+ // Handle table-level PRIMARY KEY constraint
+ // Matches: PRIMARY KEY (col1, col2) or CONSTRAINT name PRIMARY KEY (col1, col2)
if (
- line.toUpperCase().startsWith('FOREIGN KEY') ||
- line.toUpperCase().startsWith('PRIMARY KEY') ||
- line.toUpperCase().startsWith('UNIQUE') ||
- line.toUpperCase().startsWith('CHECK') ||
- line.toUpperCase().startsWith('CONSTRAINT')
+ upperLine.startsWith('PRIMARY KEY') ||
+ (upperLine.startsWith('CONSTRAINT') &&
+ upperLine.includes('PRIMARY KEY'))
+ ) {
+ const pkMatch = line.match(/PRIMARY\s+KEY\s*\(([^)]+)\)/i);
+ if (pkMatch) {
+ const pkCols = pkMatch[1]
+ .split(',')
+ .map((c) => c.trim().replace(/["'`]/g, ''));
+ table.primaryKeyColumns = pkCols;
+ }
+ continue;
+ }
+
+ // Skip other constraints
+ if (
+ upperLine.startsWith('FOREIGN KEY') ||
+ upperLine.startsWith('UNIQUE') ||
+ upperLine.startsWith('CHECK') ||
+ upperLine.startsWith('CONSTRAINT')
) {
continue;
}
@@ -314,6 +337,24 @@ function parseCreateTableStatements(sqlContent: string): {
}
}
+ // Apply table-level PRIMARY KEY constraint to columns
+ if (table.primaryKeyColumns && table.primaryKeyColumns.length > 0) {
+ const isSingleColumnPK = table.primaryKeyColumns.length === 1;
+ for (const col of table.columns) {
+ if (table.primaryKeyColumns.includes(col.name)) {
+ col.primaryKey = true;
+ // Only mark as unique if single-column PK
+ if (isSingleColumnPK) {
+ col.unique = true;
+ }
+ // In SQLite, INTEGER PRIMARY KEY is auto-incrementing
+ if (col.type.toLowerCase() === 'integer') {
+ col.increment = true;
+ }
+ }
+ }
+ }
+
if (table.columns.length > 0 || tableName === 'sqlite_sequence') {
tables.push(table);
}
@@ -482,12 +523,16 @@ function processCreateTableStatement(
// Process constraint definition
const constraintDef = def as ConstraintDefinition;
+ // Get columns from either columns or definition.columns
+ const constraintColumns =
+ constraintDef.columns || constraintDef.definition?.columns;
+
// Process PRIMARY KEY constraint
if (
constraintDef.constraint_type === 'primary key' &&
- constraintDef.columns
+ constraintColumns
) {
- primaryKeyColumns = constraintDef.columns
+ primaryKeyColumns = constraintColumns
.map(extractColumnName)
.filter(Boolean);
}
@@ -495,9 +540,9 @@ function processCreateTableStatement(
// Process UNIQUE constraint
if (
constraintDef.constraint_type === 'unique' &&
- constraintDef.columns
+ constraintColumns
) {
- const uniqueColumns = constraintDef.columns
+ const uniqueColumns = constraintColumns
.map(extractColumnName)
.filter(Boolean);
@@ -519,10 +564,16 @@ function processCreateTableStatement(
// Update primary key flags in columns
if (primaryKeyColumns.length > 0) {
+ const isSingleColumnPK = primaryKeyColumns.length === 1;
columns.forEach((column) => {
if (primaryKeyColumns.includes(column.name)) {
column.primaryKey = true;
+ // Only mark as unique if single-column PK
+ if (isSingleColumnPK) {
+ column.unique = true;
+ }
+
// In SQLite, INTEGER PRIMARY KEY is automatically an alias for ROWID (auto-incrementing)
if (column.type.toLowerCase() === 'integer') {
column.increment = true;
diff --git a/src/lib/data/sql-import/dialect-importers/sqlserver/__tests__/sqlserver-core.test.ts b/src/lib/data/sql-import/dialect-importers/sqlserver/__tests__/sqlserver-core.test.ts
index d1f7673d..855433d3 100644
--- a/src/lib/data/sql-import/dialect-importers/sqlserver/__tests__/sqlserver-core.test.ts
+++ b/src/lib/data/sql-import/dialect-importers/sqlserver/__tests__/sqlserver-core.test.ts
@@ -347,4 +347,54 @@ describe('SQL Server Core Parser Tests', () => {
expect(titleIndex?.unique).toBe(true);
expect(titleIndex?.columns).toContain('Title');
});
+
+ describe('Primary Key Uniqueness', () => {
+ it('should mark single-column primary key field as unique', async () => {
+ const sql = `
+CREATE TABLE [dbo].[table_1] (
+ [id] BIGINT NOT NULL,
+ CONSTRAINT [pk_table_1_id] PRIMARY KEY ([id])
+);
+ `;
+
+ const result = await fromSQLServer(sql);
+
+ expect(result.tables).toHaveLength(1);
+ const table = result.tables[0];
+ expect(table.name).toBe('table_1');
+
+ const idColumn = table.columns.find((c) => c.name === 'id');
+ expect(idColumn).toBeDefined();
+ expect(idColumn?.primaryKey).toBe(true);
+ expect(idColumn?.unique).toBe(true);
+ });
+
+ it('should not mark composite primary key fields as unique individually', async () => {
+ const sql = `
+CREATE TABLE [dbo].[table_1] (
+ [id] BIGINT NOT NULL,
+ [field_2] BIGINT NOT NULL,
+ CONSTRAINT [pk_table_1_id] PRIMARY KEY ([id], [field_2])
+);
+ `;
+
+ const result = await fromSQLServer(sql);
+
+ expect(result.tables).toHaveLength(1);
+ const table = result.tables[0];
+ expect(table.name).toBe('table_1');
+
+ const idColumn = table.columns.find((c) => c.name === 'id');
+ expect(idColumn).toBeDefined();
+ expect(idColumn?.primaryKey).toBe(true);
+ expect(idColumn?.unique).toBe(false);
+
+ const field2Column = table.columns.find(
+ (c) => c.name === 'field_2'
+ );
+ expect(field2Column).toBeDefined();
+ expect(field2Column?.primaryKey).toBe(true);
+ expect(field2Column?.unique).toBe(false);
+ });
+ });
});
diff --git a/src/lib/data/sql-import/dialect-importers/sqlserver/sqlserver.ts b/src/lib/data/sql-import/dialect-importers/sqlserver/sqlserver.ts
index 150c4cdc..7b49b5ad 100644
--- a/src/lib/data/sql-import/dialect-importers/sqlserver/sqlserver.ts
+++ b/src/lib/data/sql-import/dialect-importers/sqlserver/sqlserver.ts
@@ -384,9 +384,16 @@ function parseCreateTableManually(
.replace(/\[|\]|\s+(ASC|DESC)/gi, '')
.trim()
);
+ const isSingleColumnPK = pkColumns.length === 1;
pkColumns.forEach((col) => {
const column = columns.find((c) => c.name === col);
- if (column) column.primaryKey = true;
+ if (column) {
+ column.primaryKey = true;
+ // Only mark as unique if single-column PK
+ if (isSingleColumnPK) {
+ column.unique = true;
+ }
+ }
});
}
continue;
@@ -415,9 +422,16 @@ function parseCreateTableManually(
.replace(/\[|\]|\s+(ASC|DESC)/gi, '')
.trim()
);
+ const isSingleColumnPK = pkColumns.length === 1;
pkColumns.forEach((col) => {
const column = columns.find((c) => c.name === col);
- if (column) column.primaryKey = true;
+ if (column) {
+ column.primaryKey = true;
+ // Only mark as unique if single-column PK
+ if (isSingleColumnPK) {
+ column.unique = true;
+ }
+ }
});
}
} else if (constraintType === 'UNIQUE') {