runInTransaction<T extends Object> method

Future<Result<T>> runInTransaction<T extends Object>(
  1. String connectionId,
  2. Future<Result<T>> action(
    1. int txnId
    ), {
  3. IsolationLevel? isolationLevel,
  4. SavepointDialect? savepointDialect,
  5. TransactionAccessMode? accessMode,
  6. Duration? lockTimeout,
})

Implementation

Future<Result<T>> runInTransaction<T extends Object>(
  String connectionId,
  Future<Result<T>> Function(int txnId) action, {
  IsolationLevel? isolationLevel,
  SavepointDialect? savepointDialect,
  TransactionAccessMode? accessMode,
  Duration? lockTimeout,
}) =>
    OdbcErrorBoundary.run('runInTransaction', () async {
      final beginResult = await beginTransaction(
        connectionId,
        isolationLevel: isolationLevel,
        savepointDialect: savepointDialect,
        accessMode: accessMode,
        lockTimeout: lockTimeout,
      );
      if (beginResult.isError()) {
        return Failure(beginResult.exceptionOrNull()!);
      }
      final txnId = beginResult.getOrNull()!;

      final userResult = await OdbcErrorBoundary.run(
        'transactionAction',
        () => action(txnId),
      );
      if (userResult.isError()) {
        var error = normalizeOdbcError(
          userResult.exceptionOrNull()!,
          operation: 'transactionAction',
        );
        final rollback = await rollbackTransaction(connectionId, txnId);
        if (rollback.isError()) {
          error = error.withSecondary(
            normalizeOdbcError(
              rollback.exceptionOrNull()!,
              operation: 'rollbackTransaction',
            ),
          );
        }
        return Failure(error);
      }
      final commit = await commitTransaction(connectionId, txnId);
      if (commit.isError()) return Failure(commit.exceptionOrNull()!);
      return userResult;
    });