Function verifySelectLockInShareMode

test/integration/transaction.test.js:1094–1204

()

        it('supports for share (i.e. `SELECT ... LOCK IN SHARE MODE`)', async function() {
          const verifySelectLockInShareMode = async () => {
            const User = this.sequelize.define('user', {
              username: DataTypes.STRING,
              awesome: DataTypes.BOOLEAN
            }, { timestamps: false });

            await this.sequelize.sync({ force: true });
            const { id } = await User.create({ username: 'jan' });

            // First, we start a transaction T1 and perform a SELECT with it using the `LOCK.SHARE` mode (setting a shared mode lock on the row).
            // This will cause other sessions to be able to read the row but not modify it.
            // So, if another transaction tries to update those same rows, it will wait until T1 commits (or rolls back).
            // https://dev.mysql.com/doc/refman/5.7/en/innodb-locking-reads.html
            const t1 = await this.sequelize.transaction();
            await User.findByPk(id, { lock: t1.LOCK.SHARE, transaction: t1 });

            // Then we start another transaction T2 and see that it can indeed read the same row.
            const t2 = await this.sequelize.transaction({ isolationLevel: Transaction.ISOLATION_LEVELS.READ_COMMITTED });
            const t2Jan = await User.findByPk(id, { transaction: t2 });

            // Then, we want to see that an attempt to update that row from T2 will be queued until T1 commits.
            const executionOrder = [];
            const [t2AttemptData, t1AttemptData] = await pSettle([
              (async () => {
                try {
                  executionOrder.push('Begin attempt to update via T2');
                  await t2Jan.update({ awesome: false }, { transaction: t2 });
                  executionOrder.push('Done updating via T2');
                } catch (error) {
                  executionOrder.push('Failed to update via T2'); // Shouldn't happen
                  throw error;
                }

                await delay(30);

                try {
                  executionOrder.push('Attempting to commit T2');
                  await t2.commit();
                  executionOrder.push('Done committing T2');
                } catch {
                  executionOrder.push('Failed to commit T2'); // Shouldn't happen
                }
              })(),
              (async () => {
                await delay(100);

                try {
                  executionOrder.push('Begin attempt to read via T1');
                  await User.findAll({ transaction: t1 });
                  executionOrder.push('Done reading via T1');
                } catch (error) {
                  executionOrder.push('Failed to read via T1'); // Shouldn't happen
                  throw error;
                }

                await delay(150);

                try {