Skip to main content

Version: 6.3

abstractAbstractSqlConnection

Hierarchy

Connection
- AbstractSqlConnection

Constructors

constructor

new AbstractSqlConnection(config, options, type): AbstractSqlConnection

Overrides Connection.constructor
Parameters
- config: Configuration<IDatabaseDriver<Connection>, EntityManager<IDatabaseDriver<Connection>>>
- optionaloptions: ConnectionOptions
- optionaltype: read | write
Returns AbstractSqlConnection

Methods

begin

begin(options): Promise<Transaction<any, any[]>>

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

checkConnection

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

Overrides Connection.checkConnection
Are we connected to the database
Returns Promise<{ error?: Error; ok: boolean; 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): Promise<void>

Overrides Connection.commit
Parameters
- ctx: Transaction<any, any[]>
- optionaleventBroadcaster: TransactionEventBroadcaster
Returns Promise<void>

connect

connect(): void | Promise<void>

Overrides Connection.connect
Establishes connection to database
Returns void | Promise<void>

abstractcreateKnex

createKnex(): void

Returns void

ensureConnection

ensureConnection(): Promise<void>

Inherited from Connection.ensureConnection
Ensure the connection exists, this is used to support lazy connect when using MikroORM.initSync()
Returns Promise<void>

execute

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

Overrides Connection.execute
Type parameters
- T: QueryResult<{ id: number }> | EntityData<Partial<any>> | EntityData<Partial<any>>[] = EntityData<Partial<any>>[]
Parameters
- queryOrKnex: string | QueryBuilder<any, any> | Raw<any>
- params: unknown[] = []
- method: get | all | run = 'all'
- optionalctx: any
- optionalloggerContext: LoggingOptions
Returns Promise<T>

getClientUrl

getClientUrl(): string

Inherited from Connection.getClientUrl
Returns string

getConnectionOptions

getConnectionOptions(): ConnectionConfig

Inherited from Connection.getConnectionOptions
Returns ConnectionConfig

abstractgetDefaultClientUrl

getDefaultClientUrl(): string

Inherited from Connection.getDefaultClientUrl
Returns default client url for given driver (e.g. mongodb://127.0.0.1:27017 for mongodb)
Returns string

getKnex

getKnex(): Knex<any, any[]>

Returns Knex<any, any[]>

getPlatform

getPlatform(): Platform

Inherited from Connection.getPlatform
Returns Platform

isConnected

isConnected(): Promise<boolean>

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

loadFile

loadFile(path): Promise<void>

Execute raw SQL queries from file
Parameters
- path: string
Returns Promise<void>

rollback

rollback(ctx, eventBroadcaster): Promise<void>

Overrides Connection.rollback
Parameters
- ctx: Transaction<any, any[]>
- optionaleventBroadcaster: TransactionEventBroadcaster
Returns Promise<void>

setMetadata

setMetadata(metadata): void

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

setPlatform

setPlatform(platform): void

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

transactional

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

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