make transactions to wait multiple queries and execute them in a proper order

Im migrating from v3 and v4 and now I have

TransactionError: Can't acquire connection for the request. There is another request in progress.

errors. Is it related to Transaction and PreparedStatement internal queues was removed release change somehow? If yes, then can you explain what it means?

[dhensby]

Just to labour the point here: Transactions are connection specific and so all queries in the context of a Transaction have to happen over a single database connection. Likewise, a single connection can only run one query at a time, so queries over one connection need to be run in sequence, not in parallel. The only way you can run queries in parallel is by using more than one connection at a time. Therefore, it is not possible to run parallel queries in the context of a Transaction.

Consider the following example:

const mssql = require('mssql');

async function runTransaction(pool) {
  const transaction = new mssql.Transaction(pool);
  await transaction.begin();
  const req = new mssql.Request(transaction);
  await req.query('INSERT INTO companies (name, active) VALUES ('Microsoft', false);');
  // get all users and get all companies
  // this will fail because you can't run the queries in parallel, there is only a single connection to run on
  const [companies, users] = await Promise.all([
    req.query('SELECT * FROM companies;'),
    req.query('SELECT * FROM users;'),
  ]);
  // instead we have to do this because we only have one connection
  const companies = await req.query('SELECT * FROM companies;'); // this will include the company 'Microsoft' because we are in the transaction
  const users = await req.query('SELECT * FROM users;');
  ...
  await transaction.commit();
}

If we want to run queries in parallel, then we need to run the queries against the pool, but we must accept that the changes we’ve made so far in the transaction will not be reflected in our results:

  const [companies, users] = await Promise.all([
    pool.query('SELECT * FROM companies;'), // this will not include the company 'Microsoft' because it is being run over a connection that does not have the transaction context
    pool.query('SELECT * FROM users;'),
  ]);

You cannot run multiple queries, in parallel, over a single connection. It is for the developer to understand the limitations of transactions and the fact they are performed over a single connection, the parallel execution of the queries is simply not possible in a transaction. The only other option would be to allow the apparent execution of requests in parallel but internally we simply queue the queries and execute the sequentially. This is something I’m considering but it does not solve the underlying issue that they will not and cannot be run in parallel over a single connection.

[samjross]

Since this is the top-level google result for TransactionError: Can't acquire connection for the request. There is another request in progress., I thought I’d give my solution to people, given my context:

I have an app which starts a transaction, and a transaction.request(), and passes the transactionRequest around to different functions which all add onto it, via stuff like await transactionRequest.query`INSERT...`

I use the library await-lock to make this easier – when I first make the transaction, and the transactionRequest that I will later pass on to all the other functions, I add a _lock onto the transactionRequest, transactionRequest._lock = new AwaitLock();, and then every time I want to use the transactionRequest, I’ll first do await transactionRequst._lock.acquireAsync() and then make sure I release it later, in a try{}finally{ transactionRequst._lock.release() }

This has worked a treat