• Public
  • Public/Protected
  • All

This is the entry point for all interactions with Amazon QLDB.

In order to start using the driver, you need to instantiate it with a ledger name:

let qldbDriver: QldbDriver = new QldbDriver(your-ledger-name);

You can pass more parameters to the constructor of the driver which allow you to control certain limits to improve the performance. Check the QldbDriver.constructor to see all the available parameters.

A single instance of the QldbDriver is attached to only one ledger. All transactions will be executed against the ledger specified.

The driver exposes QldbDriver.executeLambda method which should be used to execute the transactions. Check the QldbDriver.executeLambda method for more details on how to execute the Transaction.

The driver also exposes QldbDriver.getTableNames method, which is a convenience method that returns the list of all the tables in the ledger.





  • new QldbDriver(ledgerName: string, qldbClientOptions?: ClientConfiguration, retryLimit?: number, poolLimit?: number, timeoutMillis?: number): QldbDriver
  • Creates a QldbDriver instance that can be used to execute transactions against Amazon QLDB. A single instance of the QldbDriver is always attached to one ledger, as specified in the ledgerName parameter.


    RangeError if retryLimit is less than 0.


    • ledgerName: string

      The name of the ledger you want to connect to. This is a mandatory parameter.

    • Default value qldbClientOptions: ClientConfiguration = {}

      The object containing options for configuring the low level client. See Low Level Client Constructor.

    • Default value retryLimit: number = 4

      When there is a failure while executing the transaction like OCC or any other retriable failure, the driver will try running your transaction block again. This parameter tells the driver how many times to retry when there are failures. The value must be greater than 0. The default value is 4. See https://docs.aws.amazon.com/qldb/latest/developerguide/driver.best-practices.html#driver.best-practices.configuring for more details.

    • Default value poolLimit: number = 0

      The driver internally uses a pool of sessions to execute the transactions. The poolLimit parameter specifies the number of sessions that the driver can hold in the pool. The default is set to maximum number of sockets specified in the globalAgent. See https://docs.aws.amazon.com/qldb/latest/developerguide/driver.best-practices.html#driver.best-practices.configuring for more details.

    • Default value timeoutMillis: number = 30000

      The number of ms the driver should wait for a session to be available in the pool before giving up. The default value is 30000.

    Returns QldbDriver


Private _availablePermits

_availablePermits: number

Protected _isClosed

_isClosed: boolean

Protected _ledgerName

_ledgerName: string

Private _poolLimit

_poolLimit: number

Protected _qldbClient

_qldbClient: QLDBSession

Protected _retryLimit

_retryLimit: number

Private _semaphore

_semaphore: Semaphore

Private _sessionPool

_sessionPool: QldbSessionImpl[]

Private _timeoutMillis

_timeoutMillis: number


Private _createSession

Private _returnSessionToPool

Protected _throwIfClosed

  • _throwIfClosed(): void


  • close(): void
  • This is a driver shutdown method which closes all the sessions and marks the driver as closed. Once the driver is closed, no transactions can be executed on that driver instance.

    Note: There is no corresponding open method and the only option is to instantiate another driver.

    Returns void


  • executeLambda(transactionFuntion: function, retryIndicator?: function): Promise<any>
  • This is the primary method to execute a transaction against Amazon QLDB ledger.

    When this method is invoked, the driver will acquire a Transaction and hand it to the TransactionExecutor you passed via the transactionFunction parameter. Once the transactionFunction's execution is done, the driver will try to commit the transaction. If there is a failure along the way, the driver will retry the entire transaction block. This would mean that your code inside the transactionFunction function should be idempotent.

    You can also return the results from the transactionFunction. Here is an example code of executing a transaction

    let result = driver.executeLambda(async (txn:TransactionExecutor) => {
      let a = await txn.execute("SELECT a from Table1");
      let b = await txn.execute("SELECT b from Table2");
      return {a: a, b: b};

    Please keep in mind that the entire transaction will be committed once all the code inside the transactionFunction is executed. So for the above example the values inside the transactionFunction, a and b, are speculative values. If the commit of the transaction fails, the entire transactionFunction will be retried.

    The function passed via retryIndicator parameter is invoked whenever there is a failure and the driver is about to retry the transaction. The retryIndicator will be called with the current attempt number.


    • transactionFuntion: function
    • Optional retryIndicator: function

      An Optional function which will be invoked when the transactionFunction is about to be retried due to a failure.

        • (retryAttempt: number): void
        • Parameters

          • retryAttempt: number

          Returns void

    Returns Promise<any>


  • deprecated

    [NOT RECOMMENDED] It is not recommended to use this method during transaction execution. Instead, please use QldbDriver.executeLambda to execute the transaction.

    Create and return a newly instantiated QldbSession object. This will implicitly start a new session with QLDB.


    DriverClosedError when this driver is closed.

    Returns Promise<QldbSession>

    Promise which fulfills with a QldbSession.


  • getTableNames(): Promise<string[]>
  • A helper method to get all the table names in a ledger.

    Returns Promise<string[]>

    Promise which fulfills with an array of table names.

Generated using TypeDoc