Initial commit - Event Planner application
This commit is contained in:
mberlin
543
node_modules/@mikro-orm/sql/dialects/sqlite/SqliteSchemaHelper.js
generated
vendored
Normal file
543
node_modules/@mikro-orm/sql/dialects/sqlite/SqliteSchemaHelper.js
generated
vendored
Normal file
@@ -0,0 +1,543 @@
|
||||
import { Utils } from '@mikro-orm/core';
|
||||
import { SchemaHelper } from '../../schema/SchemaHelper.js';
|
||||
/** SpatiaLite system views that should be automatically ignored */
|
||||
const SPATIALITE_VIEWS = [
|
||||
'geometry_columns',
|
||||
'spatial_ref_sys',
|
||||
'views_geometry_columns',
|
||||
'virts_geometry_columns',
|
||||
'geom_cols_ref_sys',
|
||||
'spatial_ref_sys_aux',
|
||||
'vector_layers',
|
||||
'vector_layers_auth',
|
||||
'vector_layers_field_infos',
|
||||
'vector_layers_statistics',
|
||||
'ElementaryGeometries',
|
||||
];
|
||||
export class SqliteSchemaHelper extends SchemaHelper {
|
||||
disableForeignKeysSQL() {
|
||||
return 'pragma foreign_keys = off;';
|
||||
}
|
||||
enableForeignKeysSQL() {
|
||||
return 'pragma foreign_keys = on;';
|
||||
}
|
||||
supportsSchemaConstraints() {
|
||||
return false;
|
||||
}
|
||||
getCreateNamespaceSQL(name) {
|
||||
return '';
|
||||
}
|
||||
getDropNamespaceSQL(name) {
|
||||
return '';
|
||||
}
|
||||
getListTablesSQL() {
|
||||
return (
|
||||
`select name as table_name from sqlite_master where type = 'table' and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys' ` +
|
||||
`union all select name as table_name from sqlite_temp_master where type = 'table' order by name`
|
||||
);
|
||||
}
|
||||
async getAllTables(connection, schemas) {
|
||||
const databases = await this.getDatabaseList(connection);
|
||||
const hasAttachedDbs = databases.length > 1; // More than just 'main'
|
||||
// If no attached databases, use original behavior
|
||||
if (!hasAttachedDbs && !schemas?.length) {
|
||||
return connection.execute(this.getListTablesSQL());
|
||||
}
|
||||
// With attached databases, query each one
|
||||
const targetSchemas = schemas?.length ? schemas : databases;
|
||||
const allTables = [];
|
||||
for (const dbName of targetSchemas) {
|
||||
const prefix = this.getSchemaPrefix(dbName);
|
||||
const tables = await connection.execute(
|
||||
`select name from ${prefix}sqlite_master where type = 'table' ` +
|
||||
`and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys'`,
|
||||
);
|
||||
for (const t of tables) {
|
||||
allTables.push({ table_name: t.name, schema_name: dbName });
|
||||
}
|
||||
}
|
||||
return allTables;
|
||||
}
|
||||
async getNamespaces(connection) {
|
||||
return this.getDatabaseList(connection);
|
||||
}
|
||||
getIgnoredViewsCondition() {
|
||||
return SPATIALITE_VIEWS.map(v => `name != '${v}'`).join(' and ');
|
||||
}
|
||||
getListViewsSQL() {
|
||||
return `select name as view_name, sql as view_definition from sqlite_master where type = 'view' and ${this.getIgnoredViewsCondition()} order by name`;
|
||||
}
|
||||
async loadViews(schema, connection, schemaName) {
|
||||
const databases = await this.getDatabaseList(connection);
|
||||
const hasAttachedDbs = databases.length > 1; // More than just 'main'
|
||||
// If no attached databases and no specific schema, use original behavior
|
||||
if (!hasAttachedDbs && !schemaName) {
|
||||
const views = await connection.execute(this.getListViewsSQL());
|
||||
for (const view of views) {
|
||||
schema.addView(view.view_name, schemaName, this.extractViewDefinition(view.view_definition));
|
||||
}
|
||||
return;
|
||||
}
|
||||
// With attached databases, query each one
|
||||
/* v8 ignore next - schemaName branch not commonly used */
|
||||
const targetDbs = schemaName ? [schemaName] : databases;
|
||||
for (const dbName of targetDbs) {
|
||||
const prefix = this.getSchemaPrefix(dbName);
|
||||
const views = await connection.execute(
|
||||
`select name as view_name, sql as view_definition from ${prefix}sqlite_master where type = 'view' and ${this.getIgnoredViewsCondition()} order by name`,
|
||||
);
|
||||
for (const view of views) {
|
||||
schema.addView(view.view_name, dbName, this.extractViewDefinition(view.view_definition));
|
||||
}
|
||||
}
|
||||
}
|
||||
getDropDatabaseSQL(name) {
|
||||
if (name === ':memory:') {
|
||||
return '';
|
||||
}
|
||||
/* v8 ignore next */
|
||||
return `drop database if exists ${this.quote(name)}`;
|
||||
}
|
||||
async loadInformationSchema(schema, connection, tables, schemas) {
|
||||
for (const t of tables) {
|
||||
const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
|
||||
const cols = await this.getColumns(connection, table.name, table.schema);
|
||||
const indexes = await this.getIndexes(connection, table.name, table.schema);
|
||||
const checks = await this.getChecks(connection, table.name, table.schema);
|
||||
const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema);
|
||||
const fks = await this.getForeignKeys(connection, table.name, table.schema);
|
||||
const enums = await this.getEnumDefinitions(connection, table.name, table.schema);
|
||||
table.init(cols, indexes, checks, pks, fks, enums);
|
||||
}
|
||||
}
|
||||
createTable(table, alter) {
|
||||
let sql = `create table ${table.getQuotedName()} (`;
|
||||
const columns = table.getColumns();
|
||||
const lastColumn = columns[columns.length - 1].name;
|
||||
for (const column of columns) {
|
||||
const col = this.createTableColumn(column, table);
|
||||
if (col) {
|
||||
const comma = column.name === lastColumn ? '' : ', ';
|
||||
sql += col + comma;
|
||||
}
|
||||
}
|
||||
const primaryKey = table.getPrimaryKey();
|
||||
const createPrimary = primaryKey?.composite;
|
||||
if (createPrimary && primaryKey) {
|
||||
sql += `, primary key (${primaryKey.columnNames.map(c => this.quote(c)).join(', ')})`;
|
||||
}
|
||||
const parts = [];
|
||||
for (const fk of Object.values(table.getForeignKeys())) {
|
||||
parts.push(this.createForeignKey(table, fk, false));
|
||||
}
|
||||
for (const check of table.getChecks()) {
|
||||
const sql = `constraint ${this.quote(check.name)} check (${check.expression})`;
|
||||
parts.push(sql);
|
||||
}
|
||||
if (parts.length > 0) {
|
||||
sql += ', ' + parts.join(', ');
|
||||
}
|
||||
sql += ')';
|
||||
if (table.comment) {
|
||||
sql += ` /* ${table.comment} */`;
|
||||
}
|
||||
const ret = [];
|
||||
this.append(ret, sql);
|
||||
for (const index of table.getIndexes()) {
|
||||
this.append(ret, this.createIndex(index, table));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
createTableColumn(column, table, _changedProperties) {
|
||||
const col = [this.quote(column.name)];
|
||||
const checks = table.getChecks();
|
||||
const check = checks.findIndex(check => check.columnName === column.name);
|
||||
const useDefault = column.default != null && column.default !== 'null';
|
||||
let columnType = column.type;
|
||||
if (column.autoincrement) {
|
||||
columnType = 'integer';
|
||||
}
|
||||
if (column.generated) {
|
||||
columnType += ` generated always as ${column.generated}`;
|
||||
}
|
||||
col.push(columnType);
|
||||
if (check !== -1) {
|
||||
col.push(`check (${checks[check].expression})`);
|
||||
checks.splice(check, 1);
|
||||
}
|
||||
Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
|
||||
Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
|
||||
Utils.runIfNotEmpty(() => col.push('primary key'), column.primary);
|
||||
Utils.runIfNotEmpty(() => col.push('autoincrement'), column.autoincrement);
|
||||
Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
|
||||
return col.join(' ');
|
||||
}
|
||||
getAddColumnsSQL(table, columns, diff) {
|
||||
return columns.map(column => {
|
||||
let sql = `alter table ${table.getQuotedName()} add column ${this.createTableColumn(column, table)}`;
|
||||
const foreignKey = Object.values(diff.addedForeignKeys).find(
|
||||
fk => fk.columnNames.length === 1 && fk.columnNames[0] === column.name,
|
||||
);
|
||||
if (foreignKey && this.options.createForeignKeyConstraints) {
|
||||
delete diff.addedForeignKeys[foreignKey.constraintName];
|
||||
sql += ' ' + this.createForeignKey(diff.toTable, foreignKey, false, true);
|
||||
}
|
||||
return sql;
|
||||
});
|
||||
}
|
||||
dropForeignKey(tableName, constraintName) {
|
||||
return '';
|
||||
}
|
||||
getDropColumnsSQL(tableName, columns, schemaName) {
|
||||
/* v8 ignore next */
|
||||
const name = this.quote(
|
||||
(schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName,
|
||||
);
|
||||
return columns
|
||||
.map(column => {
|
||||
return `alter table ${name} drop column ${this.quote(column.name)}`;
|
||||
})
|
||||
.join(';\n');
|
||||
}
|
||||
getCreateIndexSQL(tableName, index) {
|
||||
/* v8 ignore next */
|
||||
if (index.expression) {
|
||||
return index.expression;
|
||||
}
|
||||
// SQLite requires: CREATE INDEX schema.index_name ON table_name (columns)
|
||||
// NOT: CREATE INDEX index_name ON schema.table_name (columns)
|
||||
const [schemaName, rawTableName] = this.splitTableName(tableName);
|
||||
const quotedTableName = this.quote(rawTableName);
|
||||
// If there's a schema, prefix the index name with it
|
||||
let keyName;
|
||||
if (schemaName && schemaName !== 'main') {
|
||||
keyName = `${this.quote(schemaName)}.${this.quote(index.keyName)}`;
|
||||
} else {
|
||||
keyName = this.quote(index.keyName);
|
||||
}
|
||||
const sqlPrefix = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${quotedTableName}`;
|
||||
/* v8 ignore next 4 */
|
||||
if (index.columnNames.some(column => column.includes('.'))) {
|
||||
// JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
|
||||
const columns = this.platform.getJsonIndexDefinition(index);
|
||||
return `${sqlPrefix} (${columns.join(', ')})`;
|
||||
}
|
||||
// Use getIndexColumns to support advanced options like sort order and collation
|
||||
return `${sqlPrefix} (${this.getIndexColumns(index)})`;
|
||||
}
|
||||
parseTableDefinition(sql, cols) {
|
||||
const columns = {};
|
||||
const constraints = [];
|
||||
// extract all columns definitions
|
||||
let columnsDef = new RegExp(`create table [\`"']?.*?[\`"']? \\((.*)\\)`, 'i').exec(sql.replaceAll('\n', ''))?.[1];
|
||||
/* v8 ignore next */
|
||||
if (columnsDef) {
|
||||
if (columnsDef.includes(', constraint ')) {
|
||||
constraints.push(...columnsDef.substring(columnsDef.indexOf(', constraint') + 2).split(', '));
|
||||
columnsDef = columnsDef.substring(0, columnsDef.indexOf(', constraint'));
|
||||
}
|
||||
for (let i = cols.length - 1; i >= 0; i--) {
|
||||
const col = cols[i];
|
||||
const re = ` *, *[\`"']?${col.name}[\`"']? (.*)`;
|
||||
const columnDef = new RegExp(re, 'i').exec(columnsDef);
|
||||
if (columnDef) {
|
||||
columns[col.name] = { name: col.name, definition: columnDef[1] };
|
||||
columnsDef = columnsDef.substring(0, columnDef.index);
|
||||
}
|
||||
}
|
||||
}
|
||||
return { columns, constraints };
|
||||
}
|
||||
/**
|
||||
* Returns schema prefix for pragma and sqlite_master queries.
|
||||
* Returns empty string for main database (no prefix needed).
|
||||
*/
|
||||
getSchemaPrefix(schemaName) {
|
||||
if (!schemaName || schemaName === 'main') {
|
||||
return '';
|
||||
}
|
||||
return `${this.platform.quoteIdentifier(schemaName)}.`;
|
||||
}
|
||||
/**
|
||||
* Returns all database names excluding 'temp'.
|
||||
*/
|
||||
async getDatabaseList(connection) {
|
||||
const databases = await connection.execute('pragma database_list');
|
||||
return databases.filter(d => d.name !== 'temp').map(d => d.name);
|
||||
}
|
||||
/**
|
||||
* Extracts the SELECT part from a CREATE VIEW statement.
|
||||
*/
|
||||
extractViewDefinition(viewDefinition) {
|
||||
const match = /create\s+view\s+[`"']?\w+[`"']?\s+as\s+(.*)/is.exec(viewDefinition);
|
||||
/* v8 ignore next - fallback for non-standard view definitions */
|
||||
return match ? match[1] : viewDefinition;
|
||||
}
|
||||
async getColumns(connection, tableName, schemaName) {
|
||||
const prefix = this.getSchemaPrefix(schemaName);
|
||||
const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`);
|
||||
const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
|
||||
const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
|
||||
const composite = columns.reduce((count, col) => count + (col.pk ? 1 : 0), 0) > 1;
|
||||
// there can be only one, so naive check like this should be enough
|
||||
const hasAutoincrement = tableDefinition.sql.toLowerCase().includes('autoincrement');
|
||||
const { columns: columnDefinitions } = this.parseTableDefinition(tableDefinition.sql, columns);
|
||||
return columns.map(col => {
|
||||
const mappedType = connection.getPlatform().getMappedType(col.type);
|
||||
let generated;
|
||||
if (col.hidden > 1) {
|
||||
/* v8 ignore next */
|
||||
const storage = col.hidden === 2 ? 'virtual' : 'stored';
|
||||
const re = new RegExp(`(generated always)? as \\((.*)\\)( ${storage})?$`, 'i');
|
||||
const match = columnDefinitions[col.name].definition.match(re);
|
||||
if (match) {
|
||||
generated = `${match[2]} ${storage}`;
|
||||
}
|
||||
}
|
||||
return {
|
||||
name: col.name,
|
||||
type: col.type,
|
||||
default: this.wrapExpressionDefault(col.dflt_value),
|
||||
nullable: !col.notnull,
|
||||
primary: !!col.pk,
|
||||
mappedType,
|
||||
unsigned: false,
|
||||
autoincrement: !composite && col.pk && this.platform.isNumericColumn(mappedType) && hasAutoincrement,
|
||||
generated,
|
||||
};
|
||||
});
|
||||
}
|
||||
/**
|
||||
* SQLite strips outer parentheses from expression defaults (`DEFAULT (expr)` → `expr` in pragma).
|
||||
* We need to add them back so they match what we generate in DDL.
|
||||
*/
|
||||
wrapExpressionDefault(value) {
|
||||
if (value == null) {
|
||||
return null;
|
||||
}
|
||||
// simple values that are returned as-is from pragma (no wrapping needed)
|
||||
if (
|
||||
/^-?\d/.test(value) ||
|
||||
/^[xX]'/.test(value) ||
|
||||
value.startsWith("'") ||
|
||||
value.startsWith('"') ||
|
||||
value.startsWith('(')
|
||||
) {
|
||||
return value;
|
||||
}
|
||||
const lower = value.toLowerCase();
|
||||
if (['null', 'true', 'false', 'current_timestamp', 'current_date', 'current_time'].includes(lower)) {
|
||||
return value;
|
||||
}
|
||||
// everything else is an expression that had its outer parens stripped
|
||||
return `(${value})`;
|
||||
}
|
||||
async getEnumDefinitions(connection, tableName, schemaName) {
|
||||
const prefix = this.getSchemaPrefix(schemaName);
|
||||
const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
|
||||
const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
|
||||
const checkConstraints = [...(tableDefinition.sql.match(/[`["'][^`\]"']+[`\]"'] text check \(.*?\)/gi) ?? [])];
|
||||
return checkConstraints.reduce((o, item) => {
|
||||
// check constraints are defined as (note that last closing paren is missing):
|
||||
// `type` text check (`type` in ('local', 'global')
|
||||
const match = /[`["']([^`\]"']+)[`\]"'] text check \(.* \((.*)\)/i.exec(item);
|
||||
/* v8 ignore next */
|
||||
if (match) {
|
||||
o[match[1]] = match[2].split(',').map(item => /^\(?'(.*)'/.exec(item.trim())[1]);
|
||||
}
|
||||
return o;
|
||||
}, {});
|
||||
}
|
||||
async getPrimaryKeys(connection, indexes, tableName, schemaName) {
|
||||
const prefix = this.getSchemaPrefix(schemaName);
|
||||
const sql = `pragma ${prefix}table_info(\`${tableName}\`)`;
|
||||
const cols = await connection.execute(sql);
|
||||
return cols.filter(col => !!col.pk).map(col => col.name);
|
||||
}
|
||||
async getIndexes(connection, tableName, schemaName) {
|
||||
const prefix = this.getSchemaPrefix(schemaName);
|
||||
const sql = `pragma ${prefix}table_info(\`${tableName}\`)`;
|
||||
const cols = await connection.execute(sql);
|
||||
const indexes = await connection.execute(`pragma ${prefix}index_list(\`${tableName}\`)`);
|
||||
const ret = [];
|
||||
for (const col of cols.filter(c => c.pk)) {
|
||||
ret.push({
|
||||
columnNames: [col.name],
|
||||
keyName: 'primary',
|
||||
constraint: true,
|
||||
unique: true,
|
||||
primary: true,
|
||||
});
|
||||
}
|
||||
for (const index of indexes.filter(index => !this.isImplicitIndex(index.name))) {
|
||||
const res = await connection.execute(`pragma ${prefix}index_info(\`${index.name}\`)`);
|
||||
ret.push(
|
||||
...res.map(row => ({
|
||||
columnNames: [row.name],
|
||||
keyName: index.name,
|
||||
unique: !!index.unique,
|
||||
constraint: !!index.unique,
|
||||
primary: false,
|
||||
})),
|
||||
);
|
||||
}
|
||||
return this.mapIndexes(ret);
|
||||
}
|
||||
async getChecks(connection, tableName, schemaName) {
|
||||
const { columns, constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
|
||||
const checks = [];
|
||||
for (const key of Object.keys(columns)) {
|
||||
const column = columns[key];
|
||||
const expression = / (check \((.*)\))/i.exec(column.definition);
|
||||
if (expression) {
|
||||
checks.push({
|
||||
name: this.platform.getConfig().getNamingStrategy().indexName(tableName, [column.name], 'check'),
|
||||
definition: expression[1],
|
||||
expression: expression[2],
|
||||
columnName: column.name,
|
||||
});
|
||||
}
|
||||
}
|
||||
for (const constraint of constraints) {
|
||||
const expression = /constraint *[`"']?(.*?)[`"']? * (check \((.*)\))/i.exec(constraint);
|
||||
if (expression) {
|
||||
checks.push({
|
||||
name: expression[1],
|
||||
definition: expression[2],
|
||||
expression: expression[3],
|
||||
});
|
||||
}
|
||||
}
|
||||
return checks;
|
||||
}
|
||||
async getColumnDefinitions(connection, tableName, schemaName) {
|
||||
const prefix = this.getSchemaPrefix(schemaName);
|
||||
const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`);
|
||||
const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
|
||||
const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
|
||||
return this.parseTableDefinition(tableDefinition.sql, columns);
|
||||
}
|
||||
async getForeignKeys(connection, tableName, schemaName) {
|
||||
const { constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
|
||||
const prefix = this.getSchemaPrefix(schemaName);
|
||||
const fks = await connection.execute(`pragma ${prefix}foreign_key_list(\`${tableName}\`)`);
|
||||
const qualifiedTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
|
||||
return fks.reduce((ret, fk) => {
|
||||
const constraintName = this.platform.getIndexName(tableName, [fk.from], 'foreign');
|
||||
const constraint = constraints?.find(c => c.includes(constraintName));
|
||||
ret[constraintName] = {
|
||||
constraintName,
|
||||
columnName: fk.from,
|
||||
columnNames: [fk.from],
|
||||
localTableName: qualifiedTableName,
|
||||
referencedTableName: fk.table,
|
||||
referencedColumnName: fk.to,
|
||||
referencedColumnNames: [fk.to],
|
||||
updateRule: fk.on_update.toLowerCase(),
|
||||
deleteRule: fk.on_delete.toLowerCase(),
|
||||
deferMode: constraint?.match(/ deferrable initially (deferred|immediate)/i)?.[1].toLowerCase(),
|
||||
};
|
||||
return ret;
|
||||
}, {});
|
||||
}
|
||||
getManagementDbName() {
|
||||
return '';
|
||||
}
|
||||
getCreateDatabaseSQL(name) {
|
||||
return '';
|
||||
}
|
||||
async databaseExists(connection, name) {
|
||||
const tables = await connection.execute(this.getListTablesSQL());
|
||||
return tables.length > 0;
|
||||
}
|
||||
/**
|
||||
* Implicit indexes will be ignored when diffing
|
||||
*/
|
||||
isImplicitIndex(name) {
|
||||
// Ignore indexes with reserved names, e.g. autoindexes
|
||||
return name.startsWith('sqlite_');
|
||||
}
|
||||
dropIndex(table, index, oldIndexName = index.keyName) {
|
||||
return `drop index ${this.quote(oldIndexName)}`;
|
||||
}
|
||||
/**
|
||||
* SQLite does not support schema-qualified table names in REFERENCES clauses.
|
||||
* Foreign key references can only point to tables in the same database.
|
||||
*/
|
||||
getReferencedTableName(referencedTableName, schema) {
|
||||
const [schemaName, tableName] = this.splitTableName(referencedTableName);
|
||||
// Strip any schema prefix - SQLite REFERENCES clause doesn't support it
|
||||
return tableName;
|
||||
}
|
||||
alterTable(diff, safe) {
|
||||
const ret = [];
|
||||
const [schemaName, tableName] = this.splitTableName(diff.name);
|
||||
if (
|
||||
Utils.hasObjectKeys(diff.removedChecks) ||
|
||||
Utils.hasObjectKeys(diff.changedChecks) ||
|
||||
Utils.hasObjectKeys(diff.changedForeignKeys) ||
|
||||
Utils.hasObjectKeys(diff.changedColumns)
|
||||
) {
|
||||
return this.getAlterTempTableSQL(diff);
|
||||
}
|
||||
for (const index of Object.values(diff.removedIndexes)) {
|
||||
this.append(ret, this.dropIndex(diff.name, index));
|
||||
}
|
||||
for (const index of Object.values(diff.changedIndexes)) {
|
||||
this.append(ret, this.dropIndex(diff.name, index));
|
||||
}
|
||||
/* v8 ignore next */
|
||||
if (!safe && Object.values(diff.removedColumns).length > 0) {
|
||||
this.append(ret, this.getDropColumnsSQL(tableName, Object.values(diff.removedColumns), schemaName));
|
||||
}
|
||||
if (Object.values(diff.addedColumns).length > 0) {
|
||||
this.append(ret, this.getAddColumnsSQL(diff.toTable, Object.values(diff.addedColumns), diff));
|
||||
}
|
||||
if (Utils.hasObjectKeys(diff.addedForeignKeys) || Utils.hasObjectKeys(diff.addedChecks)) {
|
||||
return this.getAlterTempTableSQL(diff);
|
||||
}
|
||||
for (const [oldColumnName, column] of Object.entries(diff.renamedColumns)) {
|
||||
this.append(ret, this.getRenameColumnSQL(tableName, oldColumnName, column, schemaName));
|
||||
}
|
||||
for (const index of Object.values(diff.addedIndexes)) {
|
||||
ret.push(this.createIndex(index, diff.toTable));
|
||||
}
|
||||
for (const index of Object.values(diff.changedIndexes)) {
|
||||
ret.push(this.createIndex(index, diff.toTable, true));
|
||||
}
|
||||
for (const [oldIndexName, index] of Object.entries(diff.renamedIndexes)) {
|
||||
if (index.unique) {
|
||||
this.append(ret, this.dropIndex(diff.name, index, oldIndexName));
|
||||
this.append(ret, this.createIndex(index, diff.toTable));
|
||||
} else {
|
||||
this.append(ret, this.getRenameIndexSQL(diff.name, index, oldIndexName));
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
getAlterTempTableSQL(changedTable) {
|
||||
const tempName = `${changedTable.toTable.name}__temp_alter`;
|
||||
const quotedName = this.quote(changedTable.toTable.name);
|
||||
const quotedTempName = this.quote(tempName);
|
||||
const [first, ...rest] = this.createTable(changedTable.toTable);
|
||||
const sql = [
|
||||
'pragma foreign_keys = off;',
|
||||
first.replace(`create table ${quotedName}`, `create table ${quotedTempName}`),
|
||||
];
|
||||
const columns = [];
|
||||
for (const column of changedTable.toTable.getColumns()) {
|
||||
const fromColumn = changedTable.fromTable.getColumn(column.name);
|
||||
if (fromColumn) {
|
||||
columns.push(this.quote(column.name));
|
||||
} else {
|
||||
columns.push(`null as ${this.quote(column.name)}`);
|
||||
}
|
||||
}
|
||||
sql.push(`insert into ${quotedTempName} select ${columns.join(', ')} from ${quotedName};`);
|
||||
sql.push(`drop table ${quotedName};`);
|
||||
sql.push(`alter table ${quotedTempName} rename to ${quotedName};`);
|
||||
sql.push(...rest);
|
||||
sql.push('pragma foreign_keys = on;');
|
||||
return sql;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user