@mikro-orm/knex 6.6.11-dev.0 → 6.6.11-dev.1

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -1,6 +1,6 @@
 import type { Knex } from 'knex';
 import type { CheckDef, Column, IndexDef, TableDifference, Table, ForeignKey, MySqlTableBuilder } from '../../typings';
-import { type Dictionary, type Type } from '@mikro-orm/core';
+import { type Dictionary, type Transaction, type Type } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection';
 import { SchemaHelper } from '../../schema/SchemaHelper';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema';
@@ -17,11 +17,11 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     enableForeignKeysSQL(): string;
     finalizeTable(table: Knex.CreateTableBuilder, charset: string, collate?: string): void;
     getListTablesSQL(): string;
-    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[]): Promise<void>;
-    getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
-    getAllColumns(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Column[]>>;
-    getAllChecks(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<CheckDef[]>>;
-    getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<ForeignKey>>>;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
+    getAllIndexes(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<IndexDef[]>>;
+    getAllColumns(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<Column[]>>;
+    getAllChecks(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
+    getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<Dictionary<ForeignKey>>>;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string;
     createTableColumn(table: MySqlTableBuilder, column: Column, fromTable: DatabaseTable, changedProperties?: Set<string>, alter?: boolean): Knex.ColumnBuilder | undefined;
     configureColumnDefault(column: Column, col: Knex.ColumnBuilder, knex: Knex, changedProperties?: Set<string>): Knex.ColumnBuilder;
@@ -30,7 +30,7 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
     private getColumnDeclarationSQL;
     getForeignKeysSQL(tableName: string, schemaName?: string): string;
-    getAllEnumDefinitions(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<Dictionary<string[]>>>;
+    getAllEnumDefinitions(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<Dictionary<string[]>>>;
     private supportsCheckConstraints;
     protected getChecksSQL(tables: Table[]): string;
     getChecks(connection: AbstractSqlConnection, tableName: string, schemaName: string, columns?: Column[]): Promise<CheckDef[]>;

package/dialects/mysql/MySqlSchemaHelper.js

@@ -32,15 +32,15 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
     getListTablesSQL() {
         return `select table_name as table_name, nullif(table_schema, schema()) as schema_name, table_comment as table_comment from information_schema.tables where table_type = 'BASE TABLE' and table_schema = schema()`;
     }
-    async loadInformationSchema(schema, connection, tables) {
+    async loadInformationSchema(schema, connection, tables, schemas, ctx) {
         if (tables.length === 0) {
             return;
         }
-        const columns = await this.getAllColumns(connection, tables);
-        const indexes = await this.getAllIndexes(connection, tables);
-        const checks = await this.getAllChecks(connection, tables);
-        const fks = await this.getAllForeignKeys(connection, tables);
-        const enums = await this.getAllEnumDefinitions(connection, tables);
+        const columns = await this.getAllColumns(connection, tables, ctx);
+        const indexes = await this.getAllIndexes(connection, tables, ctx);
+        const checks = await this.getAllChecks(connection, tables, ctx);
+        const fks = await this.getAllForeignKeys(connection, tables, ctx);
+        const enums = await this.getAllEnumDefinitions(connection, tables, ctx);
         for (const t of tables) {
             const key = this.getTableKey(t);
             const table = schema.addTable(t.table_name, t.schema_name, t.table_comment);
@@ -48,12 +48,12 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
             table.init(columns[key], indexes[key], checks[key], pks, fks[key], enums[key]);
         }
     }
-    async getAllIndexes(connection, tables) {
+    async getAllIndexes(connection, tables, ctx) {
         const sql = `select table_name as table_name, nullif(table_schema, schema()) as schema_name, index_name as index_name, non_unique as non_unique, column_name as column_name /*!80013 , expression as expression */
         from information_schema.statistics where table_schema = database()
         and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')})
         order by schema_name, table_name, index_name, seq_in_index`;
-        const allIndexes = await connection.execute(sql);
+        const allIndexes = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
         for (const index of allIndexes) {
             const key = this.getTableKey(index);
@@ -76,7 +76,7 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
         }
         return ret;
     }
-    async getAllColumns(connection, tables) {
+    async getAllColumns(connection, tables, ctx) {
         const sql = `select table_name as table_name,
       nullif(table_schema, schema()) as schema_name,
       column_name as column_name,
@@ -93,7 +93,7 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
       ifnull(datetime_precision, character_maximum_length) length
       from information_schema.columns where table_schema = database() and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name))})
       order by ordinal_position`;
-        const allColumns = await connection.execute(sql);
+        const allColumns = await connection.execute(sql, [], 'all', ctx);
         const str = (val) => val != null ? '' + val : val;
         const extra = (val) => val.replace(/auto_increment|default_generated|(stored|virtual) generated/i, '').trim() || undefined;
         const ret = {};
@@ -125,13 +125,13 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
         }
         return ret;
     }
-    async getAllChecks(connection, tables) {
+    async getAllChecks(connection, tables, ctx) {
         /* istanbul ignore next */
-        if (!await this.supportsCheckConstraints(connection)) {
+        if (!await this.supportsCheckConstraints(connection, ctx)) {
             return {};
         }
         const sql = this.getChecksSQL(tables);
-        const allChecks = await connection.execute(sql);
+        const allChecks = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
         for (const check of allChecks) {
             const key = this.getTableKey(check);
@@ -145,14 +145,14 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
         }
         return ret;
     }
-    async getAllForeignKeys(connection, tables) {
+    async getAllForeignKeys(connection, tables, ctx) {
         const sql = `select k.constraint_name as constraint_name, nullif(k.table_schema, schema()) as schema_name, k.table_name as table_name, k.column_name as column_name, k.referenced_table_name as referenced_table_name, k.referenced_column_name as referenced_column_name, c.update_rule as update_rule, c.delete_rule as delete_rule
         from information_schema.key_column_usage k
         inner join information_schema.referential_constraints c on c.constraint_name = k.constraint_name and c.table_name = k.table_name
         where k.table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')})
         and k.table_schema = database() and c.constraint_schema = database() and k.referenced_column_name is not null
         order by constraint_name, k.ordinal_position`;
-        const allFks = await connection.execute(sql);
+        const allFks = await connection.execute(sql, [], 'all', ctx);
         const ret = {};
         for (const fk of allFks) {
             const key = this.getTableKey(fk);
@@ -253,23 +253,23 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
             + `inner join information_schema.referential_constraints c on c.constraint_name = k.constraint_name and c.table_name = '${tableName}' `
             + `where k.table_name = '${tableName}' and k.table_schema = database() and c.constraint_schema = database() and k.referenced_column_name is not null`;
     }
-    async getAllEnumDefinitions(connection, tables) {
+    async getAllEnumDefinitions(connection, tables, ctx) {
         const sql = `select column_name as column_name, column_type as column_type, table_name as table_name
       from information_schema.columns
       where data_type = 'enum' and table_name in (${tables.map(t => `'${t.table_name}'`).join(', ')}) and table_schema = database()`;
-        const enums = await connection.execute(sql);
+        const enums = await connection.execute(sql, [], 'all', ctx);
         return enums.reduce((o, item) => {
             o[item.table_name] ??= {};
             o[item.table_name][item.column_name] = item.column_type.match(/enum\((.*)\)/)[1].split(',').map((item) => item.match(/'(.*)'/)[1]);
             return o;
         }, {});
     }
-    async supportsCheckConstraints(connection) {
+    async supportsCheckConstraints(connection, ctx) {
         if (this._cache.supportsCheckConstraints != null) {
             return this._cache.supportsCheckConstraints;
         }
         const sql = `select 1 from information_schema.tables where table_name = 'CHECK_CONSTRAINTS' and table_schema = 'information_schema'`;
-        const res = await connection.execute(sql);
+        const res = await connection.execute(sql, [], 'all', ctx);
         return this._cache.supportsCheckConstraints = res.length > 0;
     }
     getChecksSQL(tables) {

package/dialects/sqlite/BaseSqliteSchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import type { Connection, Dictionary } from '@mikro-orm/core';
+import type { Connection, Dictionary, Transaction } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection';
 import { SchemaHelper } from '../../schema/SchemaHelper';
 import type { CheckDef, Column, IndexDef, TableDifference } from '../../typings';
@@ -10,10 +10,10 @@ export declare abstract class BaseSqliteSchemaHelper extends SchemaHelper {
     getDropDatabaseSQL(name: string): string;
     getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
     private parseTableDefinition;
-    getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<any[]>;
-    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName: string): Promise<Dictionary<string[]>>;
-    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string): Promise<string[]>;
-    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;
+    getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string, ctx?: Transaction): Promise<any[]>;
+    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName: string, ctx?: Transaction): Promise<Dictionary<string[]>>;
+    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string, ctx?: Transaction): Promise<string[]>;
+    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string, ctx?: Transaction): Promise<IndexDef[]>;
     getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<CheckDef[]>;
     getForeignKeysSQL(tableName: string): string;
     mapForeignKeys(fks: any[], tableName: string): Dictionary;

package/dialects/sqlite/BaseSqliteSchemaHelper.js

@@ -49,10 +49,10 @@ class BaseSqliteSchemaHelper extends SchemaHelper_1.SchemaHelper {
         }
         return columns;
     }
-    async getColumns(connection, tableName, schemaName) {
-        const columns = await connection.execute(`pragma table_xinfo('${tableName}')`);
+    async getColumns(connection, tableName, schemaName, ctx) {
+        const columns = await connection.execute(`pragma table_xinfo('${tableName}')`, [], 'all', ctx);
         const sql = `select sql from sqlite_master where type = ? and name = ?`;
-        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
+        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get', ctx);
         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');
@@ -82,9 +82,9 @@ class BaseSqliteSchemaHelper extends SchemaHelper_1.SchemaHelper {
             };
         });
     }
-    async getEnumDefinitions(connection, checks, tableName, schemaName) {
+    async getEnumDefinitions(connection, checks, tableName, schemaName, ctx) {
         const sql = `select sql from sqlite_master where type = ? and name = ?`;
-        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
+        const tableDefinition = await connection.execute(sql, ['table', tableName], 'get', ctx);
         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):
@@ -99,15 +99,15 @@ class BaseSqliteSchemaHelper extends SchemaHelper_1.SchemaHelper {
             return o;
         }, {});
     }
-    async getPrimaryKeys(connection, indexes, tableName, schemaName) {
+    async getPrimaryKeys(connection, indexes, tableName, schemaName, ctx) {
         const sql = `pragma table_info(\`${tableName}\`)`;
-        const cols = await connection.execute(sql);
+        const cols = await connection.execute(sql, [], 'all', ctx);
         return cols.filter(col => !!col.pk).map(col => col.name);
     }
-    async getIndexes(connection, tableName, schemaName) {
+    async getIndexes(connection, tableName, schemaName, ctx) {
         const sql = `pragma table_info(\`${tableName}\`)`;
-        const cols = await connection.execute(sql);
-        const indexes = await connection.execute(`pragma index_list(\`${tableName}\`)`);
+        const cols = await connection.execute(sql, [], 'all', ctx);
+        const indexes = await connection.execute(`pragma index_list(\`${tableName}\`)`, [], 'all', ctx);
         const ret = [];
         for (const col of cols.filter(c => c.pk)) {
             ret.push({
@@ -119,7 +119,7 @@ class BaseSqliteSchemaHelper extends SchemaHelper_1.SchemaHelper {
             });
         }
         for (const index of indexes.filter(index => !this.isImplicitIndex(index.name))) {
-            const res = await connection.execute(`pragma index_info(\`${index.name}\`)`);
+            const res = await connection.execute(`pragma index_info(\`${index.name}\`)`, [], 'all', ctx);
             ret.push(...res.map(row => ({
                 columnNames: [row.name],
                 keyName: index.name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.6.11-dev.0",
+  "version": "6.6.11-dev.1",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,7 +66,7 @@
     "@mikro-orm/core": "^6.6.10"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.6.11-dev.0",
+    "@mikro-orm/core": "6.6.11-dev.1",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/schema/DatabaseSchema.d.ts

@@ -1,4 +1,4 @@
-import { type Configuration, type Dictionary, type EntityMetadata } from '@mikro-orm/core';
+import { type Configuration, type Dictionary, type EntityMetadata, type Transaction } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -34,7 +34,7 @@ export declare class DatabaseSchema {
     hasNamespace(namespace: string): boolean;
     hasNativeEnum(name: string): boolean;
     getNamespaces(): string[];
-    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[]): Promise<DatabaseSchema>;
+    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[], ctx?: Transaction): Promise<DatabaseSchema>;
     static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string): DatabaseSchema;
     private static getSchemaName;
     private static matchName;

package/schema/DatabaseSchema.js

@@ -59,14 +59,14 @@ class DatabaseSchema {
     getNamespaces() {
         return [...this.namespaces];
     }
-    static async create(connection, platform, config, schemaName, schemas, takeTables, skipTables) {
+    static async create(connection, platform, config, schemaName, schemas, takeTables, skipTables, ctx) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema') ?? platform.getDefaultSchemaName());
-        const allTables = await connection.execute(platform.getSchemaHelper().getListTablesSQL());
+        const allTables = await connection.execute(platform.getSchemaHelper().getListTablesSQL(), [], 'all', ctx);
         const parts = config.get('migrations').tableName.split('.');
         const migrationsTableName = parts[1] ?? parts[0];
         const migrationsSchemaName = parts.length > 1 ? parts[0] : config.get('schema', platform.getDefaultSchemaName());
         const tables = allTables.filter(t => this.isTableNameAllowed(t.table_name, takeTables, skipTables) && (t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName)));
-        await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
+        await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined, ctx);
         return schema;
     }
     static fromMetadata(metadata, platform, config, schemaName) {

package/schema/SchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type Connection, type Dictionary } from '@mikro-orm/core';
+import { type Connection, type Dictionary, type Transaction } from '@mikro-orm/core';
 import type { Knex } from 'knex';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -14,15 +14,15 @@ export declare abstract class SchemaHelper {
     getSchemaEnd(disableForeignKeys?: boolean): string;
     finalizeTable(table: Knex.TableBuilder, charset: string, collate?: string): void;
     supportsSchemaConstraints(): boolean;
-    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[] | undefined, tableName: string, schemaName?: string): Promise<string[]>;
+    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[] | undefined, tableName: string, schemaName?: string, ctx?: Transaction): Promise<string[]>;
     inferLengthFromColumnType(type: string): number | undefined;
-    getForeignKeys(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Dictionary>;
+    getForeignKeys(connection: AbstractSqlConnection, tableName: string, schemaName?: string, ctx?: Transaction): Promise<Dictionary>;
     protected getTableKey(t: Table): string;
-    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string): Promise<Dictionary<string[]>>;
+    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName?: string, ctx?: Transaction): Promise<Dictionary<string[]>>;
     getCreateNativeEnumSQL(name: string, values: unknown[], schema?: string): string;
     getDropNativeEnumSQL(name: string, schema?: string): string;
     getAlterNativeEnumSQL(name: string, schema?: string, value?: string, items?: string[], oldItems?: string[]): string;
-    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[], ctx?: Transaction): Promise<void>;
     getListTablesSQL(schemaName?: string): string;
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;
     getCreateIndexSQL(tableName: string, index: IndexDef, partialExpression?: boolean): string;
@@ -37,10 +37,10 @@ export declare abstract class SchemaHelper {
     getPostAlterTable(tableDiff: TableDifference, safe: boolean): string;
     getAlterColumnAutoincrement(tableName: string, column: Column, schemaName?: string): string;
     getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
-    getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
-    getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<Column[]>;
-    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;
-    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string, columns?: Column[]): Promise<CheckDef[]>;
+    getNamespaces(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string[]>;
+    getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string, ctx?: Transaction): Promise<Column[]>;
+    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string, ctx?: Transaction): Promise<IndexDef[]>;
+    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string, columns?: Column[], ctx?: Transaction): Promise<CheckDef[]>;
     protected mapIndexes(indexes: IndexDef[]): Promise<IndexDef[]>;
     getForeignKeysSQL(tableName: string, schemaName?: string): string;
     mapForeignKeys(fks: any[], tableName: string, schemaName?: string): Dictionary;

package/schema/SchemaHelper.js

@@ -31,7 +31,7 @@ class SchemaHelper {
     supportsSchemaConstraints() {
         return true;
     }
-    async getPrimaryKeys(connection, indexes = [], tableName, schemaName) {
+    async getPrimaryKeys(connection, indexes = [], tableName, schemaName, ctx) {
         const pks = indexes.filter(i => i.primary).map(pk => pk.columnNames);
         return core_1.Utils.flatten(pks);
     }
@@ -42,8 +42,8 @@ class SchemaHelper {
         }
         return +match[1];
     }
-    async getForeignKeys(connection, tableName, schemaName) {
-        const fks = await connection.execute(this.getForeignKeysSQL(tableName, schemaName));
+    async getForeignKeys(connection, tableName, schemaName, ctx) {
+        const fks = await connection.execute(this.getForeignKeysSQL(tableName, schemaName), [], 'all', ctx);
         return this.mapForeignKeys(fks, tableName, schemaName);
     }
     getTableKey(t) {
@@ -57,7 +57,7 @@ class SchemaHelper {
         }
         return unquote(t.table_name);
     }
-    async getEnumDefinitions(connection, checks, tableName, schemaName) {
+    async getEnumDefinitions(connection, checks, tableName, schemaName, ctx) {
         return {};
     }
     getCreateNativeEnumSQL(name, values, schema) {
@@ -69,15 +69,15 @@ class SchemaHelper {
     getAlterNativeEnumSQL(name, schema, value, items, oldItems) {
         throw new Error('Not supported by given driver');
     }
-    async loadInformationSchema(schema, connection, tables, schemas) {
+    async loadInformationSchema(schema, connection, tables, schemas, ctx) {
         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);
+            const cols = await this.getColumns(connection, table.name, table.schema, ctx);
+            const indexes = await this.getIndexes(connection, table.name, table.schema, ctx);
+            const checks = await this.getChecks(connection, table.name, table.schema, cols, ctx);
+            const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema, ctx);
+            const fks = await this.getForeignKeys(connection, table.name, table.schema, ctx);
+            const enums = await this.getEnumDefinitions(connection, checks, table.name, table.schema, ctx);
             table.init(cols, indexes, checks, pks, fks, enums);
         }
     }
@@ -173,16 +173,16 @@ class SchemaHelper {
     getChangeColumnCommentSQL(tableName, to, schemaName) {
         return '';
     }
-    async getNamespaces(connection) {
+    async getNamespaces(connection, ctx) {
         return [];
     }
-    async getColumns(connection, tableName, schemaName) {
+    async getColumns(connection, tableName, schemaName, ctx) {
         throw new Error('Not supported by given driver');
     }
-    async getIndexes(connection, tableName, schemaName) {
+    async getIndexes(connection, tableName, schemaName, ctx) {
         throw new Error('Not supported by given driver');
     }
-    async getChecks(connection, tableName, schemaName, columns) {
+    async getChecks(connection, tableName, schemaName, columns, ctx) {
         throw new Error('Not supported by given driver');
     }
     async mapIndexes(indexes) {