@mikro-orm/knex 6.4.6-dev.9 → 7.0.0-dev.0

package/schema/SchemaHelper.js

@@ -7,7 +7,7 @@ class SchemaHelper {
     constructor(platform) {
         this.platform = platform;
     }
-    getSchemaBeginning(charset, disableForeignKeys) {
+    getSchemaBeginning(_charset, disableForeignKeys) {
         if (disableForeignKeys) {
             return `${this.disableForeignKeysSQL()}\n`;
         }
@@ -26,7 +26,10 @@ class SchemaHelper {
         return '';
     }
     finalizeTable(table, charset, collate) {
-        //
+        return '';
+    }
+    appendComments(table) {
+        return [];
     }
     supportsSchemaConstraints() {
         return true;
@@ -42,10 +45,6 @@ class SchemaHelper {
         }
         return +match[1];
     }
-    async getForeignKeys(connection, tableName, schemaName) {
-        const fks = await connection.execute(this.getForeignKeysSQL(tableName, schemaName));
-        return this.mapForeignKeys(fks, tableName, schemaName);
-    }
     getTableKey(t) {
         const unquote = (str) => str.replace(/['"`]/g, '');
         const parts = t.table_name.split('.');
@@ -57,9 +56,6 @@ class SchemaHelper {
         }
         return unquote(t.table_name);
     }
-    async getEnumDefinitions(connection, checks, tableName, schemaName) {
-        return {};
-    }
     getCreateNativeEnumSQL(name, values, schema) {
         throw new Error('Not supported by given driver');
     }
@@ -69,51 +65,159 @@ class SchemaHelper {
     getAlterNativeEnumSQL(name, schema, value, items, oldItems) {
         throw new Error('Not supported by given driver');
     }
-    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, cols);
-            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, checks, table.name, table.schema);
-            table.init(cols, indexes, checks, pks, fks, enums);
-        }
-    }
     getListTablesSQL(schemaName) {
         throw new Error('Not supported by given driver');
     }
     getRenameColumnSQL(tableName, oldColumnName, to, schemaName) {
-        tableName = this.platform.quoteIdentifier(tableName);
-        oldColumnName = this.platform.quoteIdentifier(oldColumnName);
-        const columnName = this.platform.quoteIdentifier(to.name);
+        tableName = this.quote(tableName);
+        oldColumnName = this.quote(oldColumnName);
+        const columnName = this.quote(to.name);
         const schemaReference = (schemaName !== undefined && schemaName !== 'public') ? ('"' + schemaName + '".') : '';
         const tableReference = schemaReference + tableName;
         return `alter table ${tableReference} rename column ${oldColumnName} to ${columnName}`;
     }
-    getCreateIndexSQL(tableName, index, partialExpression = false) {
+    getCreateIndexSQL(tableName, index) {
         /* istanbul ignore next */
-        if (index.expression && !partialExpression) {
+        if (index.expression) {
             return index.expression;
         }
-        tableName = this.platform.quoteIdentifier(tableName);
-        const keyName = this.platform.quoteIdentifier(index.keyName);
-        const sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
-        if (index.expression && partialExpression) {
-            return `${sql}(${index.expression})`;
+        tableName = this.quote(tableName);
+        const keyName = this.quote(index.keyName);
+        const defer = index.deferMode ? ` deferrable initially ${index.deferMode}` : '';
+        let sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
+        if (index.unique && index.constraint) {
+            sql = `alter table ${tableName} add constraint ${keyName} unique `;
+        }
+        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 sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
+            const columns = this.platform.getJsonIndexDefinition(index);
+            return `${sql}(${columns.join(', ')})${defer}`;
         }
-        return `${sql}(${index.columnNames.map(c => this.platform.quoteIdentifier(c)).join(', ')})`;
+        return `${sql}(${index.columnNames.map(c => this.quote(c)).join(', ')})${defer}`;
     }
     getDropIndexSQL(tableName, index) {
-        return `drop index ${this.platform.quoteIdentifier(index.keyName)}`;
+        return `drop index ${this.quote(index.keyName)}`;
     }
     getRenameIndexSQL(tableName, index, oldIndexName) {
-        return [this.getDropIndexSQL(tableName, { ...index, keyName: oldIndexName }), this.getCreateIndexSQL(tableName, index)].join(';\n');
+        return [
+            this.getDropIndexSQL(tableName, { ...index, keyName: oldIndexName }),
+            this.getCreateIndexSQL(tableName, index),
+        ];
+    }
+    alterTable(diff, safe) {
+        const ret = [];
+        const [schemaName, tableName] = this.splitTableName(diff.name);
+        if (this.platform.supportsNativeEnums()) {
+            const changedNativeEnums = [];
+            for (const { column, changedProperties } of Object.values(diff.changedColumns)) {
+                if (!column.nativeEnumName) {
+                    continue;
+                }
+                const key = schemaName && schemaName !== this.platform.getDefaultSchemaName() && !column.nativeEnumName.includes('.')
+                    ? schemaName + '.' + column.nativeEnumName
+                    : column.nativeEnumName;
+                if (changedProperties.has('enumItems') && key in diff.fromTable.nativeEnums) {
+                    changedNativeEnums.push([column.nativeEnumName, column.enumItems, diff.fromTable.nativeEnums[key].items]);
+                }
+            }
+            core_1.Utils.removeDuplicates(changedNativeEnums).forEach(([enumName, itemsNew, itemsOld]) => {
+                // postgres allows only adding new items, the values are case insensitive
+                itemsOld = itemsOld.map(v => v.toLowerCase());
+                const newItems = itemsNew.filter(val => !itemsOld.includes(val.toLowerCase()));
+                if (enumName.includes('.')) {
+                    const [enumSchemaName, rawEnumName] = enumName.split('.');
+                    ret.push(...newItems.map(val => this.getAlterNativeEnumSQL(rawEnumName, enumSchemaName, val, itemsNew, itemsOld)));
+                    return;
+                }
+                ret.push(...newItems.map(val => this.getAlterNativeEnumSQL(enumName, schemaName, val, itemsNew, itemsOld)));
+            });
+        }
+        for (const index of Object.values(diff.removedIndexes)) {
+            ret.push(this.dropIndex(diff.name, index));
+        }
+        for (const index of Object.values(diff.changedIndexes)) {
+            ret.push(this.dropIndex(diff.name, index));
+        }
+        for (const check of Object.values(diff.removedChecks)) {
+            ret.push(this.dropConstraint(diff.name, check.name));
+        }
+        for (const check of Object.values(diff.changedChecks)) {
+            ret.push(this.dropConstraint(diff.name, check.name));
+        }
+        /* istanbul ignore else */
+        if (!safe && Object.values(diff.removedColumns).length > 0) {
+            ret.push(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)));
+        }
+        for (const column of Object.values(diff.addedColumns)) {
+            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];
+                ret.push(this.createForeignKey(diff.toTable, foreignKey));
+            }
+        }
+        for (const { column, changedProperties } of Object.values(diff.changedColumns)) {
+            if (changedProperties.size === 1 && changedProperties.has('comment')) {
+                continue;
+            }
+            if (changedProperties.size === 1 && changedProperties.has('enumItems') && column.nativeEnumName) {
+                continue;
+            }
+            this.append(ret, this.alterTableColumn(column, diff.fromTable, changedProperties));
+        }
+        for (const { column, changedProperties } of Object.values(diff.changedColumns).filter(diff => diff.changedProperties.has('comment'))) {
+            if (['type', 'nullable', 'autoincrement', 'unsigned', 'default', 'enumItems'].some(t => changedProperties.has(t))) {
+                continue; // will be handled via column update
+            }
+            ret.push(this.getChangeColumnCommentSQL(tableName, column, schemaName));
+        }
+        for (const [oldColumnName, column] of Object.entries(diff.renamedColumns)) {
+            ret.push(this.getRenameColumnSQL(tableName, oldColumnName, column, schemaName));
+        }
+        for (const foreignKey of Object.values(diff.addedForeignKeys)) {
+            ret.push(this.createForeignKey(diff.toTable, foreignKey));
+        }
+        for (const foreignKey of Object.values(diff.changedForeignKeys)) {
+            ret.push(this.createForeignKey(diff.toTable, foreignKey));
+        }
+        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) {
+                ret.push(this.dropIndex(diff.name, index, oldIndexName));
+                ret.push(this.createIndex(index, diff.toTable));
+            }
+            else {
+                ret.push(...this.getRenameIndexSQL(diff.name, index, oldIndexName));
+            }
+        }
+        for (const check of Object.values(diff.addedChecks)) {
+            ret.push(this.createCheck(diff.toTable, check));
+        }
+        for (const check of Object.values(diff.changedChecks)) {
+            ret.push(this.createCheck(diff.toTable, check));
+        }
+        if ('changedComment' in diff) {
+            ret.push(this.alterTableComment(diff.toTable, diff.changedComment));
+        }
+        return ret;
+    }
+    getAddColumnsSQL(table, columns) {
+        const adds = columns.map(column => {
+            return `add ${this.createTableColumn(column, table)}`;
+        }).join(', ');
+        return [`alter table ${table.getQuotedName()} ${adds}`];
     }
     getDropColumnsSQL(tableName, columns, schemaName) {
-        const name = this.platform.quoteIdentifier((schemaName && schemaName !== this.platform.getDefaultSchemaName() ? schemaName + '.' : '') + tableName);
-        const drops = columns.map(column => `drop column ${this.platform.quoteIdentifier(column.name)}`).join(', ');
+        const name = this.quote(this.getTableName(tableName, schemaName));
+        const drops = columns.map(column => `drop column ${this.quote(column.name)}`).join(', ');
         return `alter table ${name} ${drops}`;
     }
     hasNonDefaultPrimaryKeyName(table) {
@@ -124,51 +228,55 @@ class SchemaHelper {
         const defaultName = this.platform.getDefaultPrimaryName(table.name, pkIndex.columnNames);
         return pkIndex?.keyName !== defaultName;
     }
-    createTableColumn(table, column, fromTable, changedProperties, alter) {
-        const compositePK = fromTable.getPrimaryKey()?.composite;
-        if (column.autoincrement && !column.generated && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
-            const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(fromTable);
-            if (column.mappedType instanceof core_1.BigIntType) {
-                return table.bigIncrements(column.name, { primaryKey });
-            }
-            return table.increments(column.name, { primaryKey });
-        }
-        if (column.mappedType instanceof core_1.EnumType && column.enumItems?.every(item => core_1.Utils.isString(item))) {
-            return table.enum(column.name, column.enumItems);
-        }
-        let columnType = column.type;
-        if (column.generated) {
-            columnType += ` generated always as ${column.generated}`;
-        }
-        return table.specificType(column.name, columnType);
-    }
-    configureColumn(column, col, knex, changedProperties) {
-        const guard = (key) => !changedProperties || changedProperties.has(key);
-        core_1.Utils.runIfNotEmpty(() => col.nullable(), column.nullable && guard('nullable'));
-        core_1.Utils.runIfNotEmpty(() => col.notNullable(), !column.nullable && !column.generated);
-        core_1.Utils.runIfNotEmpty(() => col.unsigned(), column.unsigned);
-        core_1.Utils.runIfNotEmpty(() => col.comment(this.processComment(column.comment)), column.comment);
-        this.configureColumnDefault(column, col, knex, changedProperties);
-        return col;
+    /* istanbul ignore next */
+    castColumn(name, type) {
+        return '';
     }
-    configureColumnDefault(column, col, knex, changedProperties) {
-        const guard = (key) => !changedProperties || changedProperties.has(key);
-        if (changedProperties) {
-            core_1.Utils.runIfNotEmpty(() => col.defaultTo(column.default == null ? null : knex.raw(column.default)), guard('default'));
+    alterTableColumn(column, table, changedProperties) {
+        const sql = [];
+        if (changedProperties.has('default') && column.default == null) {
+            sql.push(`alter table ${table.getQuotedName()} alter column ${this.quote(column.name)} drop default`);
         }
-        else {
-            core_1.Utils.runIfNotEmpty(() => col.defaultTo(knex.raw(column.default)), column.default != null && column.default !== 'null');
+        if (changedProperties.has('type')) {
+            let type = column.type + (column.generated ? ` generated always as ${column.generated}` : '');
+            if (column.nativeEnumName) {
+                type = this.quote(this.getTableName(type, table.schema));
+            }
+            sql.push(`alter table ${table.getQuotedName()} alter column ${this.quote(column.name)} type ${type + this.castColumn(column.name, type)}`);
+        }
+        if (changedProperties.has('default') && column.default != null) {
+            sql.push(`alter table ${table.getQuotedName()} alter column ${this.quote(column.name)} set default ${column.default}`);
+        }
+        if (changedProperties.has('nullable')) {
+            const action = column.nullable ? 'drop' : 'set';
+            sql.push(`alter table ${table.getQuotedName()} alter column ${this.quote(column.name)} ${action} not null`);
+        }
+        return sql;
+    }
+    createTableColumn(column, table, changedProperties) {
+        const compositePK = table.getPrimaryKey()?.composite;
+        const primaryKey = !changedProperties && !this.hasNonDefaultPrimaryKeyName(table);
+        const columnType = column.type + (column.generated ? ` generated always as ${column.generated}` : '');
+        const useDefault = column.default != null && column.default !== 'null' && !column.autoincrement;
+        const col = [this.quote(column.name), columnType];
+        core_1.Utils.runIfNotEmpty(() => col.push('unsigned'), column.unsigned && this.platform.supportsUnsigned());
+        core_1.Utils.runIfNotEmpty(() => col.push('null'), column.nullable);
+        core_1.Utils.runIfNotEmpty(() => col.push('not null'), !column.nullable && !column.generated);
+        core_1.Utils.runIfNotEmpty(() => col.push('auto_increment'), column.autoincrement);
+        core_1.Utils.runIfNotEmpty(() => col.push('unique'), column.autoincrement && !column.primary);
+        if (column.autoincrement && !column.generated && !compositePK && (!changedProperties || changedProperties.has('autoincrement') || changedProperties.has('type'))) {
+            core_1.Utils.runIfNotEmpty(() => col.push('primary key'), primaryKey && column.primary);
         }
-        return col;
+        core_1.Utils.runIfNotEmpty(() => col.push(`default ${column.default}`), useDefault);
+        core_1.Utils.runIfNotEmpty(() => col.push(column.extra), column.extra);
+        core_1.Utils.runIfNotEmpty(() => col.push(`comment ${this.platform.quoteValue(column.comment)}`), column.comment);
+        return col.join(' ');
     }
     getPreAlterTable(tableDiff, safe) {
-        return '';
+        return [];
     }
     getPostAlterTable(tableDiff, safe) {
-        return '';
-    }
-    getAlterColumnAutoincrement(tableName, column, schemaName) {
-        return '';
+        return [];
     }
     getChangeColumnCommentSQL(tableName, to, schemaName) {
         return '';
@@ -176,15 +284,6 @@ class SchemaHelper {
     async getNamespaces(connection) {
         return [];
     }
-    async getColumns(connection, tableName, schemaName) {
-        throw new Error('Not supported by given driver');
-    }
-    async getIndexes(connection, tableName, schemaName) {
-        throw new Error('Not supported by given driver');
-    }
-    async getChecks(connection, tableName, schemaName, columns) {
-        throw new Error('Not supported by given driver');
-    }
     async mapIndexes(indexes) {
         const map = {};
         indexes.forEach(index => {
@@ -198,9 +297,6 @@ class SchemaHelper {
         });
         return Object.values(map);
     }
-    getForeignKeysSQL(tableName, schemaName) {
-        throw new Error('Not supported by given driver');
-    }
     mapForeignKeys(fks, tableName, schemaName) {
         return fks.reduce((ret, fk) => {
             if (ret[fk.constraint_name]) {
@@ -242,15 +338,15 @@ class SchemaHelper {
         return `create database ${name};\n\nuse ${name}`;
     }
     getDropDatabaseSQL(name) {
-        return `drop database if exists ${this.platform.quoteIdentifier(name)}`;
+        return `drop database if exists ${this.quote(name)}`;
     }
     /* istanbul ignore next */
     getCreateNamespaceSQL(name) {
-        return `create schema if not exists ${this.platform.quoteIdentifier(name)}`;
+        return `create schema if not exists ${this.quote(name)}`;
     }
     /* istanbul ignore next */
     getDropNamespaceSQL(name) {
-        return `drop schema if exists ${this.platform.quoteIdentifier(name)}`;
+        return `drop schema if exists ${this.quote(name)}`;
     }
     getDatabaseExistsSQL(name) {
         return `select 1 from information_schema.schemata where schema_name = '${name}'`;
@@ -273,78 +369,98 @@ class SchemaHelper {
             if (e instanceof Error && e.message.includes(this.getDatabaseNotExistsError(name))) {
                 return false;
             }
+            /* istanbul ignore next */
             throw e;
         }
     }
-    /**
-     * Uses `raw` method injected in `AbstractSqlConnection` to allow adding custom queries inside alter statements.
-     */
-    pushTableQuery(table, expression, grouping = 'alterTable') {
-        table._statements.push({ grouping, method: 'raw', args: [expression] });
-    }
-    async dump(builder, append) {
-        if (typeof builder === 'string') {
-            return builder ? builder + (builder.endsWith(';') ? '' : ';') + append : '';
+    append(array, sql, pad = false) {
+        const length = array.length;
+        for (const row of core_1.Utils.asArray(sql)) {
+            if (!row) {
+                continue;
+            }
+            let tmp = row.trim();
+            if (!tmp.endsWith(';')) {
+                tmp += ';';
+            }
+            array.push(tmp);
         }
-        const sql = await builder.generateDdlCommands();
-        const queries = [...sql.pre, ...sql.sql, ...sql.post];
-        if (queries.length === 0) {
-            return '';
+        if (pad && array.length > length) {
+            array.push('');
         }
-        const dump = `${queries.map(q => typeof q === 'object' ? q.sql : q).join(';\n')};${append}`;
-        const tmp = dump.replace(/pragma table_.+/ig, '').replace(/\n\n+/g, '\n').trim();
-        return tmp ? tmp + append : '';
     }
-    createTable(tableDef, alter) {
-        return this.createSchemaBuilder(tableDef.schema).createTable(tableDef.name, table => {
-            tableDef.getColumns().forEach(column => {
-                const col = this.createTableColumn(table, column, tableDef, undefined, alter);
-                this.configureColumn(column, col, this.knex);
-            });
-            for (const index of tableDef.getIndexes()) {
-                const createPrimary = !tableDef.getColumns().some(c => c.autoincrement && c.primary) || this.hasNonDefaultPrimaryKeyName(tableDef);
-                this.createIndex(table, index, tableDef, createPrimary);
-            }
-            for (const check of tableDef.getChecks()) {
-                this.createCheck(table, check);
+    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;
             }
-            if (tableDef.comment) {
-                const comment = this.platform.quoteValue(tableDef.comment).replace(/^'|'$/g, '');
-                table.comment(comment);
-            }
-            if (!this.supportsSchemaConstraints()) {
-                for (const fk of Object.values(tableDef.getForeignKeys())) {
-                    this.createForeignKey(table, fk);
-                }
+        }
+        const primaryKey = table.getPrimaryKey();
+        const createPrimary = !table.getColumns().some(c => c.autoincrement && c.primary) || this.hasNonDefaultPrimaryKeyName(table);
+        if (createPrimary && primaryKey) {
+            const name = this.hasNonDefaultPrimaryKeyName(table) ? `constraint ${this.quote(primaryKey.keyName)} ` : '';
+            sql += `, ${name}primary key (${primaryKey.columnNames.map(c => this.quote(c)).join(', ')})`;
+        }
+        sql += ')';
+        sql += this.finalizeTable(table, this.platform.getConfig().get('charset'), this.platform.getConfig().get('collate'));
+        const ret = [];
+        this.append(ret, sql);
+        this.append(ret, this.appendComments(table));
+        for (const index of table.getIndexes()) {
+            this.append(ret, this.createIndex(index, table));
+        }
+        if (!alter) {
+            for (const check of table.getChecks()) {
+                this.append(ret, this.createCheck(table, check));
             }
-            this.finalizeTable(table, this.platform.getConfig().get('charset'), this.platform.getConfig().get('collate'));
-        });
+        }
+        return ret;
+    }
+    alterTableComment(table, comment) {
+        return `alter table ${table.getQuotedName()} comment = ${this.platform.quoteValue(comment ?? '')}`;
     }
-    createForeignKey(table, foreignKey, schema) {
+    createForeignKey(table, foreignKey, alterTable = true, inline = false) {
         if (!this.options.createForeignKeyConstraints) {
-            return;
+            return '';
+        }
+        const constraintName = this.quote(foreignKey.constraintName);
+        const columnNames = foreignKey.columnNames.map(c => this.quote(c)).join(', ');
+        const referencedColumnNames = foreignKey.referencedColumnNames.map(c => this.quote(c)).join(', ');
+        const referencedTableName = this.quote(this.getReferencedTableName(foreignKey.referencedTableName, table.schema));
+        const sql = [];
+        if (alterTable) {
+            sql.push(`alter table ${table.getQuotedName()} add`);
+        }
+        sql.push(`constraint ${constraintName}`);
+        if (!inline) {
+            sql.push(`foreign key (${columnNames})`);
         }
-        const builder = table
-            .foreign(foreignKey.columnNames, foreignKey.constraintName)
-            .references(foreignKey.referencedColumnNames)
-            .inTable(this.getReferencedTableName(foreignKey.referencedTableName, schema))
-            .withKeyName(foreignKey.constraintName);
+        sql.push(`references ${referencedTableName} (${referencedColumnNames})`);
         if (foreignKey.localTableName !== foreignKey.referencedTableName || this.platform.supportsMultipleCascadePaths()) {
             if (foreignKey.updateRule) {
-                builder.onUpdate(foreignKey.updateRule);
+                sql.push(`on update ${foreignKey.updateRule}`);
             }
             if (foreignKey.deleteRule) {
-                builder.onDelete(foreignKey.deleteRule);
+                sql.push(`on delete ${foreignKey.deleteRule}`);
             }
         }
         if (foreignKey.deferMode) {
-            builder.deferrable(foreignKey.deferMode);
+            sql.push(`deferrable initially ${foreignKey.deferMode}`);
         }
+        return sql.join(' ');
     }
-    splitTableName(name) {
+    splitTableName(name, skipDefaultSchema = false) {
         const parts = name.split('.');
         const tableName = parts.pop();
-        const schemaName = parts.pop();
+        let schemaName = parts.pop();
+        if (skipDefaultSchema && schemaName === this.platform.getDefaultSchemaName()) {
+            schemaName = undefined;
+        }
         return [schemaName, tableName];
     }
     getReferencedTableName(referencedTableName, schema) {
@@ -354,58 +470,37 @@ class SchemaHelper {
         if (schema && schemaName === '*') {
             return `${schema}.${referencedTableName.replace(/^\*\./, '')}`;
         }
-        if (!schemaName || schemaName === this.platform.getDefaultSchemaName()) {
-            return tableName;
-        }
-        return `${schemaName}.${tableName}`;
+        return this.getTableName(tableName, schema);
     }
-    createIndex(table, index, tableDef, createPrimary = false) {
+    createIndex(index, table, createPrimary = false) {
         if (index.primary && !createPrimary) {
-            return;
+            return '';
         }
         if (index.expression) {
-            this.pushTableQuery(table, index.expression);
-        }
-        else if (index.primary) {
-            const keyName = this.hasNonDefaultPrimaryKeyName(tableDef) ? index.keyName : undefined;
-            table.primary(index.columnNames, keyName);
+            return index.expression;
         }
-        else if (index.unique) {
-            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-            if (index.columnNames.some(column => column.includes('.'))) {
-                const columns = this.platform.getJsonIndexDefinition(index);
-                table.index(columns.map(column => this.knex.raw(column)), index.keyName, { indexType: 'unique' });
-            }
-            else {
-                table.unique(index.columnNames, { indexName: index.keyName, deferrable: index.deferMode });
-            }
+        const columns = index.columnNames.map(c => this.quote(c)).join(', ');
+        const defer = index.deferMode ? ` deferrable initially ${index.deferMode}` : '';
+        if (index.primary) {
+            const keyName = this.hasNonDefaultPrimaryKeyName(table) ? `constraint ${index.keyName} ` : '';
+            return `alter table ${table.getQuotedName()} add ${keyName}primary key (${columns})${defer}`;
         }
-        else if (index.type === 'fulltext') {
-            const columns = index.columnNames.map(name => ({ name, type: tableDef.getColumn(name).type }));
+        if (index.type === 'fulltext') {
+            const columns = index.columnNames.map(name => ({ name, type: table.getColumn(name).type }));
             if (this.platform.supportsCreatingFullTextIndex()) {
-                this.pushTableQuery(table, this.platform.getFullTextIndexExpression(index.keyName, tableDef.schema, tableDef.name, columns));
-            }
-        }
-        else {
-            // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-            if (index.columnNames.some(column => column.includes('.'))) {
-                const columns = this.platform.getJsonIndexDefinition(index);
-                table.index(columns.map(column => this.knex.raw(column)), index.keyName, index.type);
-            }
-            else {
-                table.index(index.columnNames, index.keyName, index.type);
+                return this.platform.getFullTextIndexExpression(index.keyName, table.schema, table.name, columns);
             }
         }
+        return this.getCreateIndexSQL(table.getShortestName(), index);
     }
     createCheck(table, check) {
-        table.check(check.expression, {}, check.name);
+        return `alter table ${table.getQuotedName()} add constraint ${this.quote(check.name)} check (${check.expression})`;
     }
-    createSchemaBuilder(schema) {
-        const builder = this.knex.schema;
+    getTableName(table, schema) {
         if (schema && schema !== this.platform.getDefaultSchemaName()) {
-            builder.withSchema(schema);
+            return `${schema}.${table}`;
         }
-        return builder;
+        return table;
     }
     getTablesGroupedBySchemas(tables) {
         return tables.reduce((acc, table) => {
@@ -418,18 +513,33 @@ class SchemaHelper {
             return acc;
         }, new Map());
     }
-    get knex() {
-        const connection = this.platform.getConfig().getDriver().getConnection();
-        return connection.getKnex();
-    }
     get options() {
         return this.platform.getConfig().get('schemaGenerator');
     }
     processComment(comment) {
-        return this.platform.getSchemaHelper().handleMultilineComment(comment);
+        return comment;
     }
-    handleMultilineComment(comment) {
-        return comment.replaceAll('\n', '\\n');
+    quote(...keys) {
+        return this.platform.quoteIdentifier(keys.filter(Boolean).join('.'));
+    }
+    dropForeignKey(tableName, constraintName) {
+        return `alter table ${this.quote(tableName)} drop foreign key ${this.quote(constraintName)}`;
+    }
+    dropIndex(table, index, oldIndexName = index.keyName) {
+        if (index.primary) {
+            return `alter table ${this.quote(table)} drop primary key`;
+        }
+        return `alter table ${this.quote(table)} drop index ${this.quote(oldIndexName)}`;
+    }
+    dropConstraint(table, name) {
+        return `alter table ${this.quote(table)} drop constraint ${this.quote(name)}`;
+    }
+    dropTableIfExists(name, schema) {
+        let sql = `drop table if exists ${this.quote(this.getTableName(name, schema))}`;
+        if (this.platform.usesCascadeStatement()) {
+            sql += ' cascade';
+        }
+        return sql;
     }
 }
 exports.SchemaHelper = SchemaHelper;

package/schema/SqlSchemaGenerator.d.ts

@@ -37,13 +37,11 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         safe?: boolean;
         dropTables?: boolean;
         schema?: string;
-    }): Promise<string>;
+    }): string;
     /**
      * We need to drop foreign keys first for all tables to allow dropping PK constraints.
      */
     private preAlterTable;
-    private postAlterTable;
-    private alterTable;
     /**
      * creates new database and connects to it
      */
@@ -53,12 +51,8 @@ export declare class SqlSchemaGenerator extends AbstractSchemaGenerator<Abstract
         wrap?: boolean;
         ctx?: Transaction;
     }): Promise<void>;
+    dropTableIfExists(name: string, schema?: string): Promise<void>;
     private wrapSchema;
-    private dropIndex;
-    private dropCheck;
-    private dropTable;
-    private createForeignKeys;
-    private dump;
-    private get knex();
+    private append;
 }
 export { SqlSchemaGenerator as SchemaGenerator };