Skip to main content

Version: Next

abstractAbstractSqlConnection

Hierarchy

Connection
- AbstractSqlConnection

Constructors

constructor

new AbstractSqlConnection(config, options, type): AbstractSqlConnection

Inherited from Connection.constructor
Parameters
- config: Configuration<IDatabaseDriver<Connection>, EntityManager<IDatabaseDriver<Connection>>>
- optionaloptions: ConnectionOptions
- type: ConnectionType = 'write'
Returns AbstractSqlConnection

Methods

begin

begin(options): Promise<ControlledTransaction<any, any>>

Overrides Connection.begin
Parameters
- options: { ctx?: ControlledTransaction<any, any>; eventBroadcaster?: TransactionEventBroadcaster; isolationLevel?: IsolationLevel; loggerContext?: LogContext; readOnly?: boolean } = {}
Returns Promise<ControlledTransaction<any, any>>

checkConnection

checkConnection(): Promise<{ ok: true } | { error?: Error; ok: false; reason: string }>

Overrides Connection.checkConnection
Are we connected to the database
Returns Promise<{ ok: true } | { error?: Error; ok: false; reason: string }>

close

close(force): Promise<void>

Overrides Connection.close
Closes the database connection (aka disconnect)
Parameters
- optionalforce: boolean
Returns Promise<void>

commit

commit(ctx, eventBroadcaster, loggerContext): Promise<void>

Overrides Connection.commit
Parameters
- ctx: ControlledTransaction<any, any>
- optionaleventBroadcaster: TransactionEventBroadcaster
- optionalloggerContext: LogContext
Returns Promise<void>

connect

connect(options): Promise<void>

Overrides Connection.connect
Establishes connection to database
Parameters
- optionaloptions: { skipOnConnect?: boolean }
Returns Promise<void>

createKysely

createKysely(): void

Returns void

abstractcreateKyselyDialect

createKyselyDialect(overrides): Dialect

Parameters
- overrides: Dictionary
Returns Dialect

inheritedensureConnection

ensureConnection(): Promise<void>

Inherited from Connection.ensureConnection
Ensure the connection exists, this is used to support lazy connect when using new MikroORM() instead of the async init method.
Returns Promise<void>

execute

execute<T>(query, params, method, ctx, loggerContext): Promise<T>

Overrides Connection.execute
Parameters
- query: string | RawQueryFragment | NativeQueryBuilder
- params: readonly unknown[] = []
- method: get | all | run = 'all'
- optionalctx: any
- optionalloggerContext: LoggingOptions
Returns Promise<T>

executeDump

executeDump(dump): Promise<void>

Overrides Connection.executeDump
Execute raw SQL queries, handy from running schema dump loaded from a file. This method doesn't support transactions, as opposed to orm.schema.execute(), which is used internally.
Parameters
- dump: string
Returns Promise<void>

getClient

getClient<T>(): Kysely<T>

Returns Kysely<T>

inheritedgetConnectionOptions

getConnectionOptions(): ConnectionConfig

Inherited from Connection.getConnectionOptions
Returns ConnectionConfig

inheritedgetPlatform

getPlatform(): Platform

Inherited from Connection.getPlatform
Returns Platform

isConnected

isConnected(): Promise<boolean>

Overrides Connection.isConnected
Are we connected to the database
Returns Promise<boolean>

rollback

rollback(ctx, eventBroadcaster, loggerContext): Promise<void>

Overrides Connection.rollback
Parameters
- ctx: ControlledTransaction<any, any>
- optionaleventBroadcaster: TransactionEventBroadcaster
- optionalloggerContext: LogContext
Returns Promise<void>

inheritedsetMetadata

setMetadata(metadata): void

Inherited from Connection.setMetadata
Parameters
- metadata: MetadataStorage
Returns void

inheritedsetPlatform

setPlatform(platform): void

Inherited from Connection.setPlatform
Parameters
- platform: Platform
Returns void

stream

stream<T>(query, params, ctx, loggerContext): AsyncIterableIterator<T, any, any>

Parameters
- query: string | RawQueryFragment | NativeQueryBuilder
- params: readonly unknown[] = []
- optionalctx: Kysely<any>
- optionalloggerContext: LoggingOptions
Returns AsyncIterableIterator<T, any, any>

transactional

transactional<T>(cb, options): Promise<T>

Overrides Connection.transactional
Parameters
- cb: (trx) => Promise<T>
- options: { ctx?: ControlledTransaction<any, []>; eventBroadcaster?: TransactionEventBroadcaster; isolationLevel?: IsolationLevel; loggerContext?: LogContext; readOnly?: boolean } = {}
Returns Promise<T>