@mikro-orm/sql 7.0.0-dev.320 → 7.0.0-dev.322

package/schema/DatabaseSchema.js

@@ -4,32 +4,40 @@ import { DatabaseTable } from './DatabaseTable.js';
  * @internal
  */
 export class DatabaseSchema {
-    platform;
     name;
-    tables = [];
-    views = [];
-    namespaces = new Set();
-    nativeEnums = {}; // for postgres
+    #tables = [];
+    #views = [];
+    #namespaces = new Set();
+    #nativeEnums = {}; // for postgres
+    #platform;
     constructor(platform, name) {
-        this.platform = platform;
         this.name = name;
+        this.#platform = platform;
     }
     addTable(name, schema, comment) {
         const namespaceName = schema ?? this.name;
-        const table = new DatabaseTable(this.platform, name, namespaceName);
-        table.nativeEnums = this.nativeEnums;
+        const table = new DatabaseTable(this.#platform, name, namespaceName);
+        table.nativeEnums = this.#nativeEnums;
         table.comment = comment;
-        this.tables.push(table);
+        this.#tables.push(table);
         if (namespaceName != null) {
-            this.namespaces.add(namespaceName);
+            this.#namespaces.add(namespaceName);
         }
         return table;
     }
     getTables() {
-        return this.tables;
+        return this.#tables;
+    }
+    /** @internal */
+    setTables(tables) {
+        this.#tables = tables;
+    }
+    /** @internal */
+    setNamespaces(namespaces) {
+        this.#namespaces = namespaces;
     }
     getTable(name) {
-        return this.tables.find(t => t.name === name || `${t.schema}.${t.name}` === name);
+        return this.#tables.find(t => t.name === name || `${t.schema}.${t.name}` === name);
     }
     hasTable(name) {
         return !!this.getTable(name);
@@ -37,43 +45,47 @@ export class DatabaseSchema {
     addView(name, schema, definition, materialized, withData) {
         const namespaceName = schema ?? this.name;
         const view = { name, schema: namespaceName, definition, materialized, withData };
-        this.views.push(view);
+        this.#views.push(view);
         if (namespaceName != null) {
-            this.namespaces.add(namespaceName);
+            this.#namespaces.add(namespaceName);
         }
         return view;
     }
     getViews() {
-        return this.views;
+        return this.#views;
+    }
+    /** @internal */
+    setViews(views) {
+        this.#views = views;
     }
     getView(name) {
-        return this.views.find(v => v.name === name || `${v.schema}.${v.name}` === name);
+        return this.#views.find(v => v.name === name || `${v.schema}.${v.name}` === name);
     }
     hasView(name) {
         return !!this.getView(name);
     }
     setNativeEnums(nativeEnums) {
-        this.nativeEnums = nativeEnums;
+        this.#nativeEnums = nativeEnums;
         for (const nativeEnum of Object.values(nativeEnums)) {
             if (nativeEnum.schema && nativeEnum.schema !== '*') {
-                this.namespaces.add(nativeEnum.schema);
+                this.#namespaces.add(nativeEnum.schema);
             }
         }
     }
     getNativeEnums() {
-        return this.nativeEnums;
+        return this.#nativeEnums;
     }
     getNativeEnum(name) {
-        return this.nativeEnums[name];
+        return this.#nativeEnums[name];
     }
     hasNamespace(namespace) {
-        return this.namespaces.has(namespace);
+        return this.#namespaces.has(namespace);
     }
     hasNativeEnum(name) {
-        return name in this.nativeEnums;
+        return name in this.#nativeEnums;
     }
     getNamespaces() {
-        return [...this.namespaces];
+        return [...this.#namespaces];
     }
     static async create(connection, platform, config, schemaName, schemas, takeTables, skipTables, skipViews) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema') ?? platform.getDefaultSchemaName());
@@ -94,7 +106,7 @@ export class DatabaseSchema {
         }
         // Filter out skipped views
         if (skipViews && skipViews.length > 0) {
-            schema.views = schema.views.filter(v => this.isNameAllowed(v.name, skipViews));
+            schema.#views = schema.#views.filter(v => this.isNameAllowed(v.name, skipViews));
         }
         return schema;
     }
@@ -291,28 +303,33 @@ export class DatabaseSchema {
             (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner));
     }
     toJSON() {
-        const { platform, namespaces, ...rest } = this;
-        return { namespaces: [...namespaces], ...rest };
+        return {
+            name: this.name,
+            namespaces: [...this.#namespaces],
+            tables: this.#tables,
+            views: this.#views,
+            nativeEnums: this.#nativeEnums,
+        };
     }
     prune(schema, wildcardSchemaTables) {
         const hasWildcardSchema = wildcardSchemaTables.length > 0;
-        this.tables = this.tables.filter(table => {
+        this.#tables = this.#tables.filter(table => {
             return ((!schema && !hasWildcardSchema) || // no schema specified and we don't have any multi-schema entity
                 table.schema === schema || // specified schema matches the table's one
                 (!schema && !wildcardSchemaTables.includes(table.name))); // no schema specified and the table has fixed one provided
         });
-        this.views = this.views.filter(view => {
+        this.#views = this.#views.filter(view => {
             /* v8 ignore next */
             return ((!schema && !hasWildcardSchema) ||
                 view.schema === schema ||
                 (!schema && !wildcardSchemaTables.includes(view.name)));
         });
         // remove namespaces of ignored tables and views
-        for (const ns of this.namespaces) {
-            if (!this.tables.some(t => t.schema === ns) &&
-                !this.views.some(v => v.schema === ns) &&
-                !Object.values(this.nativeEnums).some(e => e.schema === ns)) {
-                this.namespaces.delete(ns);
+        for (const ns of this.#namespaces) {
+            if (!this.#tables.some(t => t.schema === ns) &&
+                !this.#views.some(v => v.schema === ns) &&
+                !Object.values(this.#nativeEnums).some(e => e.schema === ns)) {
+                this.#namespaces.delete(ns);
             }
         }
     }

package/schema/DatabaseTable.d.ts

@@ -6,13 +6,9 @@ import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
  * @internal
  */
 export declare class DatabaseTable {
-    private readonly platform;
+    #private;
     readonly name: string;
     readonly schema?: string | undefined;
-    private columns;
-    private indexes;
-    private checks;
-    private foreignKeys;
     nativeEnums: Dictionary<{
         name: string;
         schema?: string;
@@ -26,6 +22,12 @@ export declare class DatabaseTable {
     removeColumn(name: string): void;
     getIndexes(): IndexDef[];
     getChecks(): CheckDef[];
+    /** @internal */
+    setIndexes(indexes: IndexDef[]): void;
+    /** @internal */
+    setChecks(checks: CheckDef[]): void;
+    /** @internal */
+    setForeignKeys(fks: Dictionary<ForeignKey>): void;
     init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
     addColumn(column: Column): void;
     addColumnFromProperty(prop: EntityProperty, meta: EntityMetadata, config: Configuration): void;

package/schema/DatabaseTable.js

@@ -3,51 +3,60 @@ import { DecimalType, EntitySchema, RawQueryFragment, ReferenceKind, t, Type, Un
  * @internal
  */
 export class DatabaseTable {
-    platform;
     name;
     schema;
-    columns = {};
-    indexes = [];
-    checks = [];
-    foreignKeys = {};
+    #columns = {};
+    #indexes = [];
+    #checks = [];
+    #foreignKeys = {};
+    #platform;
     nativeEnums = {}; // for postgres
     comment;
     constructor(platform, name, schema) {
-        this.platform = platform;
         this.name = name;
         this.schema = schema;
-        Object.defineProperties(this, {
-            platform: { enumerable: false, writable: true },
-        });
+        this.#platform = platform;
     }
     getQuotedName() {
-        return this.platform.quoteIdentifier(this.getShortestName());
+        return this.#platform.quoteIdentifier(this.getShortestName());
     }
     getColumns() {
-        return Object.values(this.columns);
+        return Object.values(this.#columns);
     }
     getColumn(name) {
-        return this.columns[name];
+        return this.#columns[name];
     }
     removeColumn(name) {
-        delete this.columns[name];
+        delete this.#columns[name];
     }
     getIndexes() {
-        return Utils.removeDuplicates(this.indexes);
+        return Utils.removeDuplicates(this.#indexes);
     }
     getChecks() {
-        return this.checks;
+        return this.#checks;
+    }
+    /** @internal */
+    setIndexes(indexes) {
+        this.#indexes = indexes;
+    }
+    /** @internal */
+    setChecks(checks) {
+        this.#checks = checks;
+    }
+    /** @internal */
+    setForeignKeys(fks) {
+        this.#foreignKeys = fks;
     }
     init(cols, indexes = [], checks = [], pks, fks = {}, enums = {}) {
-        this.indexes = indexes;
-        this.checks = checks;
-        this.foreignKeys = fks;
-        this.columns = cols.reduce((o, v) => {
+        this.#indexes = indexes;
+        this.#checks = checks;
+        this.#foreignKeys = fks;
+        this.#columns = cols.reduce((o, v) => {
             const index = indexes.filter(i => i.columnNames[0] === v.name);
             v.primary = v.primary || pks.includes(v.name);
             v.unique = index.some(i => i.unique && !i.primary);
             const type = v.name in enums ? 'enum' : v.type;
-            v.mappedType = this.platform.getMappedType(type);
+            v.mappedType = this.#platform.getMappedType(type);
             v.default = v.default?.toString().startsWith('nextval(') ? null : v.default;
             v.enumItems ??= enums[v.name] || [];
             o[v.name] = v;
@@ -55,12 +64,12 @@ export class DatabaseTable {
         }, {});
     }
     addColumn(column) {
-        this.columns[column.name] = column;
+        this.#columns[column.name] = column;
     }
     addColumnFromProperty(prop, meta, config) {
         prop.fieldNames?.forEach((field, idx) => {
             const type = prop.enum ? 'enum' : prop.columnTypes[idx];
-            const mappedType = this.platform.getMappedType(type);
+            const mappedType = this.#platform.getMappedType(type);
             if (mappedType instanceof DecimalType) {
                 const match = /\w+\((\d+), ?(\d+)\)/.exec(prop.columnTypes[idx]);
                 /* v8 ignore next */
@@ -71,24 +80,24 @@ export class DatabaseTable {
                 }
             }
             if (prop.length == null && prop.columnTypes[idx]) {
-                prop.length = this.platform.getSchemaHelper().inferLengthFromColumnType(prop.columnTypes[idx]);
+                prop.length = this.#platform.getSchemaHelper().inferLengthFromColumnType(prop.columnTypes[idx]);
                 if (typeof mappedType.getDefaultLength !== 'undefined') {
-                    prop.length ??= mappedType.getDefaultLength(this.platform);
+                    prop.length ??= mappedType.getDefaultLength(this.#platform);
                 }
             }
             const primary = !meta.compositePK && prop.fieldNames.length === 1 && !!prop.primary;
-            this.columns[field] = {
+            this.#columns[field] = {
                 name: prop.fieldNames[idx],
                 type: prop.columnTypes[idx],
                 generated: prop.generated instanceof RawQueryFragment
-                    ? this.platform.formatQuery(prop.generated.sql, prop.generated.params)
+                    ? this.#platform.formatQuery(prop.generated.sql, prop.generated.params)
                     : prop.generated,
                 mappedType,
-                unsigned: prop.unsigned && this.platform.isNumericColumn(mappedType),
+                unsigned: prop.unsigned && this.#platform.isNumericColumn(mappedType),
                 autoincrement: prop.autoincrement ??
-                    (primary && prop.kind === ReferenceKind.SCALAR && this.platform.isNumericColumn(mappedType)),
+                    (primary && prop.kind === ReferenceKind.SCALAR && this.#platform.isNumericColumn(mappedType)),
                 primary,
-                nullable: this.columns[field]?.nullable ?? !!prop.nullable,
+                nullable: this.#columns[field]?.nullable ?? !!prop.nullable,
                 nativeEnumName: prop.nativeEnumName,
                 length: prop.length,
                 precision: prop.precision,
@@ -99,29 +108,29 @@ export class DatabaseTable {
                 extra: prop.extra,
                 ignoreSchemaChanges: prop.ignoreSchemaChanges,
             };
-            this.columns[field].unsigned ??= this.columns[field].autoincrement;
+            this.#columns[field].unsigned ??= this.#columns[field].autoincrement;
             if (this.nativeEnums[type]) {
-                this.columns[field].enumItems ??= this.nativeEnums[type].items;
+                this.#columns[field].enumItems ??= this.nativeEnums[type].items;
             }
-            const defaultValue = this.platform.getSchemaHelper().normalizeDefaultValue(prop.defaultRaw, prop.length);
-            this.columns[field].default = defaultValue;
+            const defaultValue = this.#platform.getSchemaHelper().normalizeDefaultValue(prop.defaultRaw, prop.length);
+            this.#columns[field].default = defaultValue;
         });
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.polymorphic) {
             const constraintName = this.getIndexName(prop.foreignKeyName ?? true, prop.fieldNames, 'foreign');
             let schema = prop.targetMeta.root.schema === '*'
                 ? this.schema
-                : (prop.targetMeta.root.schema ?? config.get('schema', this.platform.getDefaultSchemaName()));
+                : (prop.targetMeta.root.schema ?? config.get('schema', this.#platform.getDefaultSchemaName()));
             if (prop.referencedTableName.includes('.')) {
                 schema = undefined;
             }
             // For cross-schema FKs on MySQL/MariaDB (where schema = database), when the referenced
             // table has no explicit schema but the current table does, qualify with dbName so the
             // FK can resolve the referenced table in the correct database
-            if (!schema && this.schema && !this.platform.getDefaultSchemaName()) {
+            if (!schema && this.schema && !this.#platform.getDefaultSchemaName()) {
                 schema = config.get('dbName');
             }
             if (prop.createForeignKeyConstraint) {
-                this.foreignKeys[constraintName] = {
+                this.#foreignKeys[constraintName] = {
                     constraintName,
                     columnNames: prop.fieldNames,
                     localTableName: this.getShortestName(false),
@@ -129,15 +138,15 @@ export class DatabaseTable {
                     referencedTableName: schema ? `${schema}.${prop.referencedTableName}` : prop.referencedTableName,
                 };
                 const schemaConfig = config.get('schemaGenerator');
-                this.foreignKeys[constraintName].deleteRule = prop.deleteRule ?? schemaConfig.defaultDeleteRule;
-                this.foreignKeys[constraintName].updateRule = prop.updateRule ?? schemaConfig.defaultUpdateRule;
+                this.#foreignKeys[constraintName].deleteRule = prop.deleteRule ?? schemaConfig.defaultDeleteRule;
+                this.#foreignKeys[constraintName].updateRule = prop.updateRule ?? schemaConfig.defaultUpdateRule;
                 if (prop.deferMode) {
-                    this.foreignKeys[constraintName].deferMode = prop.deferMode;
+                    this.#foreignKeys[constraintName].deferMode = prop.deferMode;
                 }
             }
         }
         if (prop.index) {
-            this.indexes.push({
+            this.#indexes.push({
                 columnNames: prop.fieldNames,
                 composite: prop.fieldNames.length > 1,
                 keyName: this.getIndexName(prop.index, prop.fieldNames, 'index'),
@@ -147,7 +156,7 @@ export class DatabaseTable {
             });
         }
         if (prop.unique && !(prop.primary && !meta.compositePK)) {
-            this.indexes.push({
+            this.#indexes.push({
                 columnNames: prop.fieldNames,
                 composite: prop.fieldNames.length > 1,
                 keyName: this.getIndexName(prop.unique, prop.fieldNames, 'unique'),
@@ -162,7 +171,7 @@ export class DatabaseTable {
         if (typeof value === 'string') {
             return value;
         }
-        return this.platform.getIndexName(this.name, columnNames, type);
+        return this.#platform.getIndexName(this.name, columnNames, type);
     }
     getEntityDeclaration(namingStrategy, schemaHelper, scalarPropertiesForRelations) {
         const { fksOnColumnProps, fksOnStandaloneProps, columnFks, fkIndexes, nullableForeignKeys, skippedColumnNames } = this.foreignKeysToProps(namingStrategy, scalarPropertiesForRelations);
@@ -170,7 +179,7 @@ export class DatabaseTable {
         const schema = new EntitySchema({ name, collection: this.name, schema: this.schema, comment: this.comment });
         const compositeFkIndexes = {};
         const compositeFkUniques = {};
-        const potentiallyUnmappedIndexes = this.indexes.filter(index => !index.primary && // Skip primary index. Whether it's in use by scalar column or FK, it's already mapped.
+        const potentiallyUnmappedIndexes = this.#indexes.filter(index => !index.primary && // Skip primary index. Whether it's in use by scalar column or FK, it's already mapped.
             // Non-trivial non-composite indexes will be declared at the entity's metadata, though later outputted in the property
             (index.columnNames.length > 1 || // All composite indexes are to be mapped to entity decorators or FK props.
                 skippedColumnNames.includes(index.columnNames[0]) || // Non-composite indexes for skipped columns are to be mapped as entity decorators.
@@ -462,7 +471,7 @@ export class DatabaseTable {
     }
     findFkIndex(currentFk) {
         const fkColumnsLength = currentFk.columnNames.length;
-        const possibleIndexes = this.indexes.filter(index => {
+        const possibleIndexes = this.#indexes.filter(index => {
             return (index.columnNames.length === fkColumnsLength &&
                 !currentFk.columnNames.some((columnName, i) => index.columnNames[i] !== columnName));
         });
@@ -563,7 +572,7 @@ export class DatabaseTable {
      * The shortest name is stripped of the default namespace. All other namespaced elements are returned as full-qualified names.
      */
     getShortestName(skipDefaultSchema = true) {
-        const defaultSchema = this.platform.getDefaultSchemaName();
+        const defaultSchema = this.#platform.getDefaultSchemaName();
         if (!this.schema ||
             this.name.startsWith(defaultSchema + '.') ||
             (this.schema === defaultSchema && skipDefaultSchema)) {
@@ -572,25 +581,25 @@ export class DatabaseTable {
         return `${this.schema}.${this.name}`;
     }
     getForeignKeys() {
-        return this.foreignKeys;
+        return this.#foreignKeys;
     }
     hasColumn(columnName) {
-        return columnName in this.columns;
+        return columnName in this.#columns;
     }
     getIndex(indexName) {
-        return this.indexes.find(i => i.keyName === indexName);
+        return this.#indexes.find(i => i.keyName === indexName);
     }
     hasIndex(indexName) {
         return !!this.getIndex(indexName);
     }
     getCheck(checkName) {
-        return this.checks.find(i => i.name === checkName);
+        return this.#checks.find(i => i.name === checkName);
     }
     hasCheck(checkName) {
         return !!this.getCheck(checkName);
     }
     getPrimaryKey() {
-        return this.indexes.find(i => i.primary);
+        return this.#indexes.find(i => i.primary);
     }
     hasPrimaryKey() {
         return !!this.getPrimaryKey();
@@ -643,15 +652,15 @@ export class DatabaseTable {
         const prop = this.getPropertyName(namingStrategy, column.name, fk);
         const persist = !(column.name in columnFks && typeof fk === 'undefined');
         const index = compositeFkIndexes[prop] ||
-            this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && !idx.unique && !idx.primary);
+            this.#indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && !idx.unique && !idx.primary);
         const unique = compositeFkUniques[prop] ||
-            this.indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && idx.unique && !idx.primary);
+            this.#indexes.find(idx => idx.columnNames[0] === column.name && !idx.composite && idx.unique && !idx.primary);
         const kind = this.getReferenceKind(fk, unique);
         const runtimeType = this.getPropertyTypeForColumn(namingStrategy, column, fk);
         const type = fk
             ? runtimeType
             : (Utils.keys(t).find(k => {
-                const typeInCoreMap = this.platform.getMappedType(k);
+                const typeInCoreMap = this.#platform.getMappedType(k);
                 return ((typeInCoreMap !== Type.getType(UnknownType) || k === 'unknown') && typeInCoreMap === column.mappedType);
             }) ?? runtimeType);
         const ignoreSchemaChanges = type === 'unknown' && column.length ? (column.extra ? ['type', 'extra'] : ['type']) : undefined;
@@ -734,7 +743,7 @@ export class DatabaseTable {
         if (fk) {
             return this.getPropertyTypeForForeignKey(namingStrategy, fk);
         }
-        const enumMode = this.platform.getConfig().get('entityGenerator').enumMode;
+        const enumMode = this.#platform.getConfig().get('entityGenerator').enumMode;
         // If this column is using an enum.
         if (column.enumItems?.length) {
             const name = column.nativeEnumName ?? column.name;
@@ -778,7 +787,7 @@ export class DatabaseTable {
             };
             const columns = meta.createSchemaColumnMappingObject();
             const exp = expression(columns, table, indexName);
-            return exp instanceof RawQueryFragment ? this.platform.formatQuery(exp.sql, exp.params) : exp;
+            return exp instanceof RawQueryFragment ? this.#platform.formatQuery(exp.sql, exp.params) : exp;
         }
         return expression;
     }
@@ -853,7 +862,7 @@ export class DatabaseTable {
         if (index.fillFactor != null && (index.fillFactor < 0 || index.fillFactor > 100)) {
             throw new Error(`fillFactor must be between 0 and 100, got ${index.fillFactor} for index '${name}' on entity '${meta.className}'`);
         }
-        this.indexes.push({
+        this.#indexes.push({
             keyName: name,
             columnNames: properties,
             composite: properties.length > 1,
@@ -874,10 +883,10 @@ export class DatabaseTable {
         });
     }
     addCheck(check) {
-        this.checks.push(check);
+        this.#checks.push(check);
     }
     toJSON() {
-        const { platform, columns, ...rest } = this;
+        const columns = this.#columns;
         const columnsMapped = Utils.keys(columns).reduce((o, col) => {
             const c = columns[col];
             const normalized = {
@@ -914,6 +923,15 @@ export class DatabaseTable {
             o[col] = normalized;
             return o;
         }, {});
-        return { columns: columnsMapped, ...rest };
+        return {
+            name: this.name,
+            schema: this.schema,
+            columns: columnsMapped,
+            indexes: this.#indexes,
+            checks: this.#checks,
+            foreignKeys: this.#foreignKeys,
+            nativeEnums: this.nativeEnums,
+            comment: this.comment,
+        };
     }
 }

package/schema/SchemaComparator.d.ts

@@ -7,9 +7,7 @@ import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
  * Compares two Schemas and return an instance of SchemaDifference.
  */
 export declare class SchemaComparator {
-    private readonly platform;
-    private readonly helper;
-    private readonly logger;
+    #private;
     constructor(platform: AbstractSqlPlatform);
     /**
      * Returns a SchemaDifference object containing the differences between the schemas fromSchema and toSchema.

package/schema/SchemaComparator.js

@@ -3,13 +3,13 @@ import { ArrayType, BooleanType, DateTimeType, inspect, JsonType, parseJsonSafe,
  * Compares two Schemas and return an instance of SchemaDifference.
  */
 export class SchemaComparator {
-    platform;
-    helper;
-    logger;
+    #helper;
+    #logger;
+    #platform;
     constructor(platform) {
-        this.platform = platform;
-        this.helper = this.platform.getSchemaHelper();
-        this.logger = this.platform.getConfig().getLogger();
+        this.#platform = platform;
+        this.#helper = this.#platform.getSchemaHelper();
+        this.#logger = this.#platform.getConfig().getLogger();
     }
     /**
      * Returns a SchemaDifference object containing the differences between the schemas fromSchema and toSchema.
@@ -35,13 +35,13 @@ export class SchemaComparator {
         };
         const foreignKeysToTable = {};
         for (const namespace of toSchema.getNamespaces()) {
-            if (fromSchema.hasNamespace(namespace) || namespace === this.platform.getDefaultSchemaName()) {
+            if (fromSchema.hasNamespace(namespace) || namespace === this.#platform.getDefaultSchemaName()) {
                 continue;
             }
             diff.newNamespaces.add(namespace);
         }
         for (const namespace of fromSchema.getNamespaces()) {
-            if (toSchema.hasNamespace(namespace) || namespace === this.platform.getDefaultSchemaName()) {
+            if (toSchema.hasNamespace(namespace) || namespace === this.#platform.getDefaultSchemaName()) {
                 continue;
             }
             diff.removedNamespaces.add(namespace);
@@ -418,7 +418,7 @@ export class SchemaComparator {
         if (key1.deferMode !== key2.deferMode) {
             return true;
         }
-        if (key1.localTableName === key1.referencedTableName && !this.platform.supportsMultipleCascadePaths()) {
+        if (key1.localTableName === key1.referencedTableName && !this.#platform.supportsMultipleCascadePaths()) {
             return false;
         }
         if (key1.columnNames.some(col => tableDifferences.changedColumns[col]?.changedProperties.has('type'))) {
@@ -430,7 +430,7 @@ export class SchemaComparator {
         };
         const compare = (method) => rule(key1, method) === rule(key2, method);
         // Skip updateRule comparison for platforms that don't support ON UPDATE (e.g., Oracle)
-        const updateRuleDiffers = this.platform.supportsOnUpdate() && !compare('updateRule');
+        const updateRuleDiffers = this.#platform.supportsOnUpdate() && !compare('updateRule');
         return updateRuleDiffers || !compare('deleteRule');
     }
     /**
@@ -440,10 +440,10 @@ export class SchemaComparator {
         const changedProperties = new Set();
         const fromProp = this.mapColumnToProperty({ ...fromColumn, autoincrement: false });
         const toProp = this.mapColumnToProperty({ ...toColumn, autoincrement: false });
-        const fromColumnType = this.platform.normalizeColumnType(fromColumn.mappedType.getColumnType(fromProp, this.platform).toLowerCase(), fromProp);
+        const fromColumnType = this.#platform.normalizeColumnType(fromColumn.mappedType.getColumnType(fromProp, this.#platform).toLowerCase(), fromProp);
         const fromNativeEnum = fromTable.nativeEnums[fromColumnType] ??
             Object.values(fromTable.nativeEnums).find(e => e.name === fromColumnType && e.schema !== '*');
-        let toColumnType = this.platform.normalizeColumnType(toColumn.mappedType.getColumnType(toProp, this.platform).toLowerCase(), toProp);
+        let toColumnType = this.#platform.normalizeColumnType(toColumn.mappedType.getColumnType(toProp, this.#platform).toLowerCase(), toProp);
         const log = (msg, params) => {
             if (logging) {
                 const copy = Utils.copy(params);
@@ -458,7 +458,7 @@ export class SchemaComparator {
             !toColumn.generated) {
             if (!toColumnType.includes('.') &&
                 fromTable.schema &&
-                fromTable.schema !== this.platform.getDefaultSchemaName()) {
+                fromTable.schema !== this.#platform.getDefaultSchemaName()) {
                 toColumnType = `${fromTable.schema}.${toColumnType}`;
             }
             if (fromColumnType !== toColumnType) {
@@ -478,7 +478,7 @@ export class SchemaComparator {
             log(`'autoincrement' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('autoincrement');
         }
-        if (!!fromColumn.unsigned !== !!toColumn.unsigned && this.platform.supportsUnsigned()) {
+        if (!!fromColumn.unsigned !== !!toColumn.unsigned && this.#platform.supportsUnsigned()) {
             log(`'unsigned' changed for column ${fromTable.name}.${fromColumn.name}`, { fromColumn, toColumn });
             changedProperties.add('unsigned');
         }
@@ -575,7 +575,7 @@ export class SchemaComparator {
             // index that has no constraints.
             return true;
         }
-        if (this.platform.supportsDeferredUniqueConstraints() && index1.deferMode !== index2.deferMode) {
+        if (this.#platform.supportsDeferredUniqueConstraints() && index1.deferMode !== index2.deferMode) {
             return false;
         }
         return index1.primary === index2.primary && index1.unique === index2.unique;
@@ -699,8 +699,8 @@ export class SchemaComparator {
         if (from.default && to.default) {
             return from.default.toString().toLowerCase() === to.default.toString().toLowerCase();
         }
-        if (['', this.helper.getDefaultEmptyString()].includes(to.default) && from.default != null) {
-            return ['', this.helper.getDefaultEmptyString()].includes(from.default.toString());
+        if (['', this.#helper.getDefaultEmptyString()].includes(to.default) && from.default != null) {
+            return ['', this.#helper.getDefaultEmptyString()].includes(from.default.toString());
         }
         // eslint-disable-next-line eqeqeq
         return from.default == to.default; // == intentionally
@@ -722,6 +722,6 @@ export class SchemaComparator {
         if (params) {
             message += ' ' + inspect(params);
         }
-        this.logger.log('schema', message);
+        this.#logger.log('schema', message);
     }
 }